我怎么给学生按分数高低排序啊。代码应该怎么加。我真的迷糊了。

class  Student
{
        private String name;
        private int age;
        private int  list;
       
        Student(String name,int age,int  list)
        {
                this.name = name;
                this.age = age;
                this.list = list;

                getinfo();
        }
        public void getinfo()
        {
                System.out.println("name="+name+"   age="+age+"    list="+list);
               
        }

}
class Studentinfo
{
        public static void main(String[] args)
        {
                Student s1 = new Student("xiaohua",23,66);
                Student s2 = new Student("xiaojun",20,85);
                Student s3 = new Student("xiaoli",20,35);
                Student s4 = new Student("xiaoming",20,78);
                Student s5 = new Student("xiaolan",20,100);

        }
}

你这个可以用comparator或者comparable时行排序

直接丢TreeSet集合里面不就行了么

就是把数字取出来，进行排序，排序方法有很多。可以参见毕老师视频中的的冒泡和选择排序。

1. // 利用快速排序，根据学生成绩大小顺序排序
   
2.         public static Student[] sortedStu(Student[] stus, int low, int high) {
   
3. 
   
4.                 Student s = stus[low];
   
5.                 int i = low;
   
6.                 int j = high;
   
7.                 while (i < j) {
   
8. 
   
9.                         // j向前遍历，查找大于s的值
   
10.                         while (i < j && (stus[j].getScore() <= s.getScore())) {
    
11.                                 j--;
    
12.                         }
    
13.                         if (i < j) {
    
14.                                 stus[i++] = stus[j];
    
15.                         }
    
16. 
    
17.                         // i向后遍历，查找小于s的值
    
18.                         while (i < j && (stus[i].getScore() >= s.getScore())) {
    
19.                                 i++;
    
20.                         }
    
21.                         if (i < j) {
    
22.                                 stus[j--] = stus[i];
    
23.                         }
    
24.                 }
    
25. 
    
26.                 stus[i] = s;
    
27. 
    
28.                 // 递归，对左子序列做划分
    
29.                 if (low < i - 1) {
    
30.                         sortedStu(stus, low, i - 1);
    
31.                 }
    
32.                 // 递归，对右子序列做划分
    
33.                 if (high > i + 1) {
    
34.                         sortedStu(stus, i + 1, high);
    
35.                 }
    
36. 
    
37.                 return stus;
    
38.         }
    

复制代码

上面指出了排序代码我就不多说了
说下排序的知识好了

在数据结构的规范中，排序分了很多种，
1插入排序
        直接插入排序
        希尔排序
2交换排序
        冒泡排序
        快速排序
3选择排序
        直接选择排序
        堆排序
4归并排序
5分配排序
        箱排序
        基数排序

我觉得这么多排序还是要了解一下，
一楼回答的是直接选择排序
其次你还要应该要理解冒泡排序，快速排序这两种


快速排序是基于比较的内部排序中被很多人认为的最好方法
献上当年学数据结构时的快速排序代码：
帮忙了解下这个排序

C实现

1. #include<stdio.h>
   
2. void QuickSort(int *a,int low,int high);
   
3. int Findpos(int *a,int low,int high);
   
4. int main(void){
   
5.         int i =0;
   
6.         int a[6] = {5,6,58,99,0,12};
   
7.         QuickSort(a,0,5);
   
8.         for(;i<6;i++){
   
9.                 printf("%d ",a[i]);
   
10.         }
    
11.         printf("\n");
    
12.         return 0;
    
13. }
    
14. 
    
15. void QuickSort(int *a,int low,int high){
    
16.         int pos;
    
17.         if(low < high){
    
18.                 pos = Findpos(a,low,high);
    
19.                 QuickSort(a,low,pos-1);
    
20.                 QuickSort(a,pos+1,high);
    
21.         }
    
22. }
    
23. 
    
24. int Findpos(int *a,int low,int high){
    
25.         int val = a[low];
    
26.         while(low < high){
    
27.                 while(low < high && a[high]>=val)
    
28.                         --high;
    
29.                 a[low] = a[high];
    
30.                 while(low < high && a[low] <= val)
    
31.                         ++low;
    
32.                 a[high] = a[low];
    
33.         }
    
34.         a[low] = val;
    
35.         return high;
    
36. }

复制代码

元素Student实现Comparable接口，重写compareTo()方法，存储于TreeSet集合

1. 
   
2. import java.util.TreeSet;
   
3. import java.util.Iterator;
   
4. import java.util.Comparator;
   
5. 
   
6. 
   
7. class Student implements Comparable
   
8. {
   
9.   private String name;
   
10.   private int age;
    
11.   private int list;
    
12.   Student(String name, int age, int list)
    
13.   {
    
14.           this.name=name;
    
15.           this.age=age;
    
16.           this.list=list;               
    
17.   }  
    
18.   public void getinfo()
    
19.   {
    
20.     System.out.println("name="+name+"   age="+age+"    list="+list);
    
21.   }
    
22.    
    
23.   public int compareTo(Object obj)
    
24.   {
    
25.                   if(!(obj instanceof Student))
    
26.                           throw new RuntimeException("不是学生对象");
    
27.                   Student o = (Student)obj;
    
28.                   if(this.list==o.list)
    
29.                           return this.name.compareTo(o.name);
    
30.                   else if(this.list>o.list)
    
31.                           return 1;
    
32.                   else
    
33.                           return -1;
    
34.   }
    
35.   public String toString()
    
36.   {
    
37.                   return this.name+"-"+this.age+"-"+this.list;       
    
38.   }
    
39. }
    
40. 
    
41. class Test
    
42. {
    
43.         public static void main(String[] args)
    
44.         {
    
45.                 TreeSet<Student> ts = new TreeSet<Student>();
    
46.                
    
47.                 Student s1 = new Student("xiaohua",23,66);
    
48.     Student s2 = new Student("xiaojun",20,85);
    
49.     Student s3 = new Student("xiaoli",20,35);
    
50.     Student s4 = new Student("xiaoming",20,78);
    
51.     Student s5 = new Student("xiaolan",20,100);
    
52. 
    
53.                 ts.add(s1);
    
54.                 ts.add(s2);
    
55.                 ts.add(s3);
    
56.                 ts.add(s4);
    
57.                 ts.add(s5);
    
58.                
    
59.                 Iterator<Student>it = ts.iterator();
    
60.                 while(it.hasNext())
    
61.                 {
    
62.                         System.out.println(it.next());       
    
63.                 }
    
64.         }
    
65. }

复制代码

代码仅供参考，关键是理解排序的过程，建议你把学生对象存放到数组中，这样操作起来比较方便：
Student[] stu = new Student[5];//创建数组对象
        stu[0] = new Student("张三", 19, 88);
        stu[1] = new Student("李四", 21, 79);
        stu[2] = new Student("王五", 28, 90);
        stu[3] = new Student("张六", 17, 91);
        stu[4] = new Student("陈七", 23, 99);
for (int i = 1; i < stu.length; i++) {//采用冒泡法排序，外层循环表示总循环趟数
            for (int j = 0; j < stu.length - i; j++) {//内层循环表示每趟循环次数
                if (stu[j].getScore() > stu[j + 1].getScore()) {
                    Student s = null;
                    s = stu[j];
                    stu[j] = stu[j + 1];
                    stu[j + 1] = s;
                }
            }