/*
有五个学生，每个学生有3门课的成绩，
从键盘输入以上数据（包括姓名，三门课成绩），
输入的格式：如：zhagnsan，30，40，60计算出总成绩，
并把学生的信息和计算出的总分数高低顺序存放在磁盘文件"stud.txt"中。

1，描述学生对象。
2，定义一个可操作学生对象的工具类。

思想：
1，通过获取键盘录入一行数据，并将该行中的信息取出封装成学生对象。
2，因为学生有很多，那么就需要存储，使用到集合。因为要对学生的总分排序。
        所以可以使用TreeSet。
3，将集合的信息写入到一个文件中。


*/

import java.io.*;
import java.util.*;

class Student implements Comparable<Student>
{
        private String name;
        private int ma,cn,en;
        private int sum;

        Student(String name,int ma,int cn,int en)
        {
                this.name = name;
                this.ma = ma;
                this.cn = cn;
                this.en = en;
                sum = ma + cn + en;
        }


        public int compareTo(Student s)
        {
                int num = new Integer(this.sum).compareTo(new Integer(s.sum));
                if(num==0)
                        return this.name.compareTo(s.name);
                return num;
        }



        public String getName()
        {
                return name;
        }
        public int getSum()
        {
                return sum;
        }

        public int hashCode()
        {
                return name.hashCode()+sum*78;

        }
        public boolean equals(Object obj)
        {
                if(!(obj instanceof Student))
                        throw new ClassCastException("类型不匹配");
                Student s = (Student)obj;

                return this.name.equals(s.name) && this.sum==s.sum;
        }

        public String toString()
        {
                return "student["+name+", "+ma+", "+cn+", "+en+"]";
        }
}

class StudentInfoTool
{
        public static Set<Student> getStudents()throws IOException
        {
                return getStudents(null);
        }

        public static Set<Student> getStudents(Comparator<Student> cmp)throws IOException
        {
                BufferedReader bufr =
                        new BufferedReader(new InputStreamReader(System.in));

                String line = null;
               
                Set<Student> stus  = null;
                if(cmp==null)
                        stus = new TreeSet<Student>();
                else
                        stus = new TreeSet<Student>(cmp);
                while((line=bufr.readLine())!=null)
                {
                        if("over".equals(line))
                                break;
                        
                        String[] info = line.split(",");
                        
                        Student stu = new Student(info[0],Integer.parseInt(info[1]),
                                                                                Integer.parseInt(info[2]),
                                                                                Integer.parseInt(info[3]));

                        
                        stus.add(stu);
                }

                bufr.close();

                return stus;
        }

        public static void write2File(Set<Student> stus)throws IOException
        {
                BufferedWriter bufw = new BufferedWriter(new FileWriter("stuinfo.txt"));

                for(Student stu : stus)
                {
                        bufw.write(stu.toString()+"\t");
                        bufw.write(stu.getSum()+"");
                        bufw.newLine();
                        bufw.flush();
                }

                bufw.close();

        }
}



class StudentInfoTest
{
        public static void main(String[] args) throws IOException
        {

                Comparator<Student> cmp = Collections.reverseOrder();

                Set<Student> stus = StudentInfoTool.getStudents(cmp);

                StudentInfoTool.write2File(stus);
        }
}
代码中我只看到了实现comparable的比较方式，并没有看到comparator这个比较器方法， 为什么他最后创建comparator 这个对象反转后就能得到学生成绩的排序呢

代码中实现comparable的比较方式，使学生元素具备了比较性，并没有编写comparator这个比较器方法， 他是用Collections类中的静态方法方法 reverseOrder()来返回的一个比较器，进行的逆转，
public static <T> Comparator<T> reverseOrder()返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。（自然顺序是通过对象自身的 compareTo 方法强行排序的。）此方法允许使用单个语句，以逆自然顺序对实现了 Comparable 接口的对象 collection（或数组）进行排序（或维护）

我妄自猜测一下楼主应该是main函数里面的第一句话没有理解，一共三句话，后面两句话我目测楼主是理解的~~

我们来看看这句话的本质，看源码




我们来看看这个内部类的源码



综上所述，Comparator<Student> cmp = Collections.reverseOrder();这句话就是拿到一个反向比较器（Comparator），（这个比较器最后被TreeSet使用了）

有什么不懂的楼主继续问。。。。

冯伟超 发表于 2012-12-18 23:11
TreeSet的的原理是二叉树，它对集合中元素的排序，默认的的就是二叉树的原理，实际上就是比较，及对元素排 ...

你说的我都懂，  我说的是代码上明明没有comparator的 定义的比较方式啊 值有个comparable实现了， 为什么他还能逆转comparator，   

TreeSet的的原理是二叉树，它对集合中元素的排序，默认的的就是二叉树的原理，实际上就是比较，及对元素排序默认的就是使用比较的，但是如果你想要按照你想要的规则进行排序，那么你得自己写一个方法来实现了。
正因为有这正需求java中提供了两种方法：一种是继承Compareable类来复写它的方法来定义自己的想要的方法；第二个就是实现接口Comparator接口。如果两种方式都存在，会优先考虑使用的是接口中的方法。

匿名者 发表于 2012-12-18 21:51
public int compareTo(Student s)
        {
                int num = new Integer(this.sum).compareTo ...

这里 不是comparable 这个接口比较的么？？   但是他逆转的结果是comparator比较器啊

public int compareTo(Student s)
        {
                int num = new Integer(this.sum).compareTo(new Integer(s.sum));
                if(num==0)
                        return this.name.compareTo(s.name);
                return num;
        }
这里不是吗？sum 进行比较了啊，也进行类型转换了。。