求完整的java代码

回答是
完整代码 + 运行结果截图，运行人名不能涉及敏感人物，可以取张三李四之类的

主要代码都提供了，定义一个测试类，运行即可。

你这个截图不就是代码, 照抄一遍不就好了

用java实现学生成绩管理系统（附有详细代码）
students代码

package StudentManger;
/*
学生信息：姓名，地址
 */
public class Student {
    String name;
    String address;
    int ChineseGrade;
    int MathGrade;
    int EnglishGrade;
    int sum;
    double averGrade;
 
    public int getSum() {
        return sum;
    }
 
    public void setSum(int sum) {
        this.sum = sum;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
 
    public String getAddress() {
        return address;
    }
 
    public void setAddress(String address) {
        this.address = address;
    }
 
    public int getChineseGrade() {
        return ChineseGrade;
    }
 
    public void setChineseGrade(int chineseGrade) {
        ChineseGrade = chineseGrade;
    }
 
    public int getMathGrade() {
        return MathGrade;
    }
 
    public void setMathGrade(int mathGrade) {
        MathGrade = mathGrade;
    }
 
    public int getEnglishGrade() {
        return EnglishGrade;
    }
 
    public void setEnglishGrade(int englishGrade) {
        EnglishGrade = englishGrade;
    }
 
    public double getAverGrade() {
        return averGrade;
    }
 
    public void setAverGrade(double averGrade) {
        this.averGrade = averGrade;
    }
}

不知道你这个问题是否已经解决, 如果还没有解决的话:

你可以看下这个问题的回答https://ask.csdn.net/questions/7514168
这篇博客你也可以参考下：使用二维数组实现线性代数中的矩阵相乘（JAVA代码实现）
你还可以看下java参考手册中的 java-国际化 - 介绍如何设计软件，使其能够轻松适应（本地化）各种语言和地区。-与文本打交道》提供了以独立于本地的方式操作文本的技术。-将拉丁文数字转换为其他Unicode数字

除此之外, 这篇博客: 【不就是java设计模式吗】设计模式七大原则，用代码对比方式，化抽象为具体，实打实的教会你中的 2、代码对比 部分也许能够解决你的问题, 你可以仔细阅读以下内容或者直接跳转源博客中阅读:

代码一：

public class class01 {
    public static void main(String[] args) {
        Vehicle1 vehicle = new Vehicle1();
        vehicle.run("汽车");
        vehicle.run("飞机");
        vehicle.run("轮船");
    }
}

class Vehicle1 {
    public void run(String vehicle){
        System.out.println(vehicle + "在高速上行驶");
    }
}

通过代码一可以看出，这样设计的结果是：飞机和轮船也是在高速上行驶，违反了单一职责原则，这显然是错误的。接下来看看代码二，与其对比一下。

代码二：

public class class02 {
    public static void main(String[] args) {
        VehicleRoad road = new VehicleRoad();
        road.run("汽车");
        VehicleWater water = new VehicleWater();
        water.run("轮船");
    }
}

class VehicleRoad {
    public void run(String vehicle) {
        System.out.println(vehicle + "在高速上行驶");
    }
}

class VehicleWater {
    public void run(String vehicle) {
        System.out.println(vehicle + "在水中行驶");
    }
}

通过代码二，我们根据交通工具运行方法不同，分解成不同的类，解决了代码一的问题。但是有一个问题就是，这样很浪费资源，改动很大。貌似不太完美，接下来看看代码三

代码三：

public class class03 {
    public static void main(String[] args) {
        Vehicle2 vehicle = new Vehicle2();
        vehicle.runRoad("汽车");
        vehicle.runWater("轮船");
    }
}
class Vehicle2{
    public void runRoad(String vehicle){
        System.out.println(vehicle + "在高速上行驶");
    }
    public void runWater(String vehicle){
        System.out.println(vehicle + "在水中行驶");
    }
}

代码三通过修改方法，与代码二比较，对原来的类没有做很大的修改，只是增加方法。这里虽然没有在类这个级别上遵守单一职责原则，但是在方法级别上，仍然是遵守单一职责原则。

您还可以看一下陈健老师的微信公众号实战(Java版本,带前后台)课程中的退出登录和取消关注(上)011小节, 巩固相关知识点

如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^

先把图片里面的代码抄写一篇，然后再根据最后的修改点，依次进行代码调整就可以了，例如：控制台输入使用Scanner类，平均分之类的数组之和相加求平均。

你提供的图中，主要代码已经实现了，你要修改的地方主要是：
1）修改getCourseStudents()方法，使用scanner获取用户输入的课程的成绩。
2)提供parseCourse()方法，对课程的成绩进行统计分享。这里主要是计算成绩，需要使用到循环，循环课程的多个成绩，计算总分，除以课程门数，就得到了平均分，最高分和最低分的求法，就是在循环中先将第一门课程的成绩赋值给存储最高分或最低分的变量，然后继续循环，如果下一个成绩大于或者小于这个值，则更新那个变量，最后循环完毕后得到的就是最高分和最低分。
3)提供courseGroup()方法，对课程的成绩进行分组。这里主要需要使用到循环和if条件语句，循环学生的课程成绩，使用if判断每个成绩落在哪个范围。

源码发一下

import java.util.*;

public class CharacterCount {
    public static void main(String[] args) {
        // 读取控制台输入的字符串
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入字符串：");
        String input = scanner.nextLine();
        
        // 创建一个Map来存储字符和出现次数的键值对
        Map<Character, Integer> charCountMap = new HashMap<>();
        
        // 遍历输入字符串，统计每个字符出现的次数
        for (char c : input.toCharArray()) {
            // 如果字符已经在Map中存在，则将出现次数加1；否则将字符添加到Map中，并将出现次数设置为1
            charCountMap.put(c, charCountMap.getOrDefault(c, 0) + 1);
        }
        
        // 将Map中的键值对转换为List，并根据出现次数进行降序排序
        List<Map.Entry<Character, Integer>> charCountList = new ArrayList<>(charCountMap.entrySet());
        charCountList.sort(Map.Entry.comparingByValue(Comparator.reverseOrder()));
        
        // 输出结果
        System.out.println("字符出现次数降序排列：");
        for (Map.Entry<Character, Integer> entry : charCountList) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
    }
}

请输入字符串：hello world
字符出现次数降序排列：
l : 3
o : 2
d : 1
e : 1
h : 1
r : 1
w : 1

TechWhizKid参考GPT回答：

import java.util.*;

public class Student {
    private Integer sid; // 学号
    private String name; // 姓名

    public Student(Integer sid, String name) {
        this.sid = sid;
        this.name = name;
    }

    public Integer getSid() {
        return sid;
    }

    public void setSid(Integer sid) {
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (sid != null ? !sid.equals(student.sid) : student.sid != null) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = sid != null ? sid.hashCode() : 0;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }
    @Override
    public String toString() {
        return "Student{" +
                "sid=" + sid +
                ", name='" + name + '\'' +
                '}';
    }

}

public class Course {
    private String cid; // 课程编号
    private String name; // 课程名称

    public Course(String cid, String name) {
        this.cid = cid;
        this.name = name;
    }

    public String getCid() {
        return cid;
    }

    public void setCid(String cid) {
        this.cid = cid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Course course = (Course) o;

        if (cid != null ? !cid.equals(course.cid) : course.cid != null) return false;
        return name != null ? name.equals(course.name) : course.name == null;
    }

    @Override
    public int hashCode() {
        int result = cid != null ? cid.hashCode() : 0;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }
}

import java.util.*;

public class CourseManagement {
    private Map<Course, List<Student>> courseStudents;

    public CourseManagement() {
        this.courseStudents = new HashMap<>();
    }

    public void addCourseStudents(Course course, List<Student> students) {
        courseStudents.put(course, students);
    }

    public Map<Course, List<Student>> getCourseStudents() {
        return courseStudents;
    }

    public Map<Course, Double> parseCourse() {
        Map<Course, Double> courseAverages = new HashMap<>();

        for (Map.Entry<Course, List<Student>> entry : courseStudents.entrySet()) {
            Course course = entry.getKey();
            List<Student> students = entry.getValue();

            int totalScore = 0;
            for (Student student : students) {
                // 假设每个学生的成绩通过控制台输入
                Scanner scanner = new Scanner(System.in);
                System.out.print("请输入学生 " + student.getName() + " 在课程 " + course.getName() + " 中的成绩: ");
                int score = scanner.nextInt();
                totalScore += score;
            }

            double averageScore = (double) totalScore / students.size();
            courseAverages.put(course, averageScore);
        }

        return courseAverages;
    }

    public Map<String, List<Student>> courseGroup() {
        Map<String, List<Student>> courseGroups = new HashMap<>();

        for (Map.Entry<Course, List<Student>> entry : courseStudents.entrySet()) {
            Course course = entry.getKey();
            List<Student> students = entry.getValue();

            for (Student student : students) {
                int score = getStudentScore(course, student);
                String group = getScoreGroup(score);

                List<Student> groupStudents = courseGroups.getOrDefault(group, new ArrayList<>());
                groupStudents.add(student);
                courseGroups.put(group, groupStudents);
            }
        }

        return courseGroups;
    }

    private int getStudentScore(Course course, Student student) {
        // 假设每个学生的成绩存储在一个单独的Map中
        Map<Course, Map<Student, Integer>> scoreList = new HashMap<>();
        // 填充scoreList Map中的实际成绩

        Map<Student, Integer> studentScores = scoreList.getOrDefault(course, new HashMap<>());
        return studentScores.getOrDefault(student, 0);
    }

    private String getScoreGroup(int score) {
        if (score >= 90 && score <= 100) {
            return "优秀";
        } else if (score >= 80 && score < 90) {
            return "良好";
        } else if (score >= 70 && score < 80) {
            return "中等";
        } else if (score >= 60 && score < 70) {
            return "及格";
        } else {
            return "不及格";
        }
    }

    public static void main(String[] args) {
        CourseManagement courseManagement = new CourseManagement();

        // 添加课程学生
        Course java = new Course("B0012", "Java");
        Course c = new Course("B0013", "C");
        Course webFront = new Course("B0014", "Web Front");

        Student s1 = new Student(1, "haoren");
        Student s2 = new Student(2, "lucy");
        Student s3 = new Student(3, "lily");
        Student s4 = new Student(4, "jerry");

        courseManagement.addCourseStudents(java, Arrays.asList(s1, s2, s3));
        courseManagement.addCourseStudents(c, Arrays.asList(s1, s3));
        courseManagement.addCourseStudents(webFront, Arrays.asList(s2, s3, s4));

        // 解析课程成绩
        Map<Course, Double> courseAverages = courseManagement.parseCourse();

        // 打印课程平均分
        for (Map.Entry<Course, Double> entry : courseAverages.entrySet()) {
            Course course = entry.getKey();
            double average = entry.getValue();
            System.out.println("课程: " + course.getName() + "，平均分: " + average);
        }

        // 按分数对学生进行分组
        Map<String, List<Student>> courseGroups = courseManagement.courseGroup();

        // 打印学生分组
        // 打印学生分组
        for (Map.Entry<String, List<Student>> entry : courseGroups.entrySet()) {
            String group = entry.getKey();
            List<Student> students = entry.getValue();
            System.out.println(group + " 组的学生: " + students.toString());
        }

    }
}

import java.util.*;

public class CharacterCount {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();

        Map<Character, Integer> frequencyMap = new TreeMap<>();

        for (char c : input.toCharArray()) {
            frequencyMap.put(c, frequencyMap.getOrDefault(c, 0) + 1);
        }

        List<Map.Entry<Character, Integer>> list = new ArrayList<>(frequencyMap.entrySet());

        // sort the list by value in descending order
        list.sort((o1, o2) -> o2.getValue().compareTo(o1.getValue()));

        for (Map.Entry<Character, Integer> entry : list) {
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
    }
}