Java 在类中创建的对象中查找最大值

有人能解释一下我是如何从我在主类中创建的所有对象中获得最高价值的吗

在这个例子中，我在我的主类中创建了两个students对象，并添加了一些课程名称和成绩

我制作了两个静态数组来存储来自不同对象的信息，但它不会返回级别最高的对象

如何存储创建的学生对象的最高分数

public class CMate {
    private static String[] studentName = new String[2];
    private static int[][] gradeAssigned = new int[2][3];
    private static int higGrade = 0;
    private String name;
    private int cpr;
    private String[] courseName = new String[3];
    private int[] grade = new int[3];
    private int numberOfCourse;
    private int numberOfGrades;
    private static int counter = 0;

    CMate(String name, int cpr) {
        // building constructor
        System.out.println("Creating object nr " + counter);
        this.name = name;
        this.cpr = cpr;
        // insert name into array   
        studentName[counter] = name;
        for (int i = 0; i < numberOfCourse; i++) {
            gradeAssigned[counter][i] = grade[i];
        }
        counter++;
    }

    public void addcourseName(String nameOfCourse) {
        courseName[numberOfCourse] = nameOfCourse;
        numberOfCourse++;
    }

    public void addGrade(int gradeNr) {
        grade[numberOfGrades] = gradeNr;
        numberOfGrades++;
    }

    public String getName() {
        return name;
    }

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

    public int getCpr() {
        return cpr;
    }

    public void setCpr(int cpr) {
        this.cpr = cpr;
    }

    public String[] getCourseName() {
        return courseName;
    }

    public void setCourseName(String[] courseName) {
        this.courseName = courseName;
    }

    public int[] getGrade() {
        return grade;
    }

    public void setGrade(int[] grade) {
        this.grade = grade;
    }

    public String toString() {
        String studentInfo = "";
        System.out.println("------------------------------\n student " + name + " CPR " + cpr);

        for (int i = 0; i < numberOfCourse; i++) {
            studentInfo += " Course " + courseName[i] + "Grade  " + grade[i];
        }
        return studentInfo;
    }

    public double averageGrade() {
        double total = 0;

        for (int i = 0; i < numberOfGrades; i++) {
            total += grade[i];
        }
        return (total / numberOfGrades);
    }

    public void higestGrade() {
        for (int i = 0; i < studentName.length; i++) {
            if (grade[i] > higGrade) {
                higGrade = grade[i];
            }
        }
    }

    public void higestObjectGrade() {
        System.out.println(higGrade);
    }
}

公共类CMate{
私有静态字符串[]studentName=新字符串[2]；
私有静态int[]gradeAssigned=新int[2][3]；
私有静态int higGrade=0；
私有字符串名称；
私人心肺复苏术；
私有字符串[]courseName=新字符串[3]；
私有整数[]等级=新整数[3]；
私人国际课程；
私人综合职系;；
专用静态整数计数器=0；
CMate（字符串名，int cpr）{
//建筑建造师
System.out.println（“创建对象编号”+计数器）；
this.name=名称；
这个.cpr=cpr；
//在数组中插入名称
学生姓名[计数器]=姓名；
for（int i=0；i高等级）{
高等级=等级[i]；
}
}
}
public void higestObjectGrade（）{
系统输出打印LN（高级）；
}
}

我不完全理解您的代码，但这里有一个简化版本，包括一个用于保存所有学生的静态字段和一个用于返回最高分数的静态函数：

class Student {

  public final static List<Student> allCreatedStudents = new ArrayList<Student>();

  String name;
  int[] grades = new int[3];

  public Student(String name){
    this.name = name;
    allCreatedStudents.add(this); // Every time a student is created, he is recorded in the static list
  }

  public void setGrade(int grade, int index){
    this.grades[index] = grade;
  }

  public static int getHighestGrade(){
    int highestGrade = 0;
    for(Student s : allCreatedStudents){  // Loop through all students
      for(int i=0; i<s.grades.length; i++){  // Loop through all grades
        if(s.grades[i]>highestGrade)
          highestGrade = s.grades[i];
      }
    }
    return highestGrade;
  }

}

班级学生{
公共最终静态列表allCreatedStudents=new ArrayList（）；
字符串名；
int[]等级=新int[3]；
公立学生（字符串名称）{
this.name=名称；
allCreatedStudents.add（this）；//每次创建学生时，他都会记录在静态列表中
}
公共void setGrade（int grade，int index）{
这个。等级[指数]=等级；
}
公共静态int getHighestGrade（）{
int最高等级=0；
对于（学生s:allCreatedStudents）{//遍历所有学生
对于（int i=0；ihighestGrade）
最高等级=标准等级[i]；
}
}
返回最高等级；
}
}

可能重复，但我想在创建的所有对象（学生）中找到分配的最高等级；排序后，数组的值按升序/降序排列。它将是第0个或第n个元素。执行以下操作，循环分配的数组。。将变量maxFound=grade分配给[0][0]（第一个元素）。。。在循环中检查是否有大于maxFound的值，然后从@Rangerguy的代码中更新它。可以假设他不知道java.util.Collection是否为。所以我觉得他更能理解坚持阵列