1. /*
   
2. 有五个学生，每个学生有3门课的成绩，
   
3. 从键盘输入以上数据（包括姓名，三门课成绩），
   
4. 输入的格式：如：zhagnsan，30，40，60计算出总成绩，
   
5. 并把学生的信息和计算出的总分数高低顺序存放在磁盘文件"stud.txt"中。
   
6. */
   
7. import java.io.*;
   
8. import java.util.*;
   
9. class Student implements Comparable<Student>
   
10. {
    
11. private String name;
    
12. private int ma,cn,en;
    
13. private int sum;
    
14. 
    
15. Student(String name,int ma,int cn,int en)
    
16. {
    
17. this.name = name;
    
18. this.ma = ma;
    
19. this.cn = cn;
    
20. this.en = en;
    
21. sum = ma + cn + en;
    
22. }
    
23. 
    
24. public int compareTo(Student s)
    
25. {
    
26. int num = new Integer(this.sum).compareTo(new Integer(s.sum));
    
27. if(num==0)
    
28. return this.name.compareTo(s.name);
    
29. return num;
    
30. }
    
31. 
    
32. public String getName()
    
33. {
    
34. return name;
    
35. }
    
36. public int getSum()
    
37. {
    
38. return sum;
    
39. }
    
40. 
    
41. public int hashCode()
    
42. {
    
43. return name.hashCode()+sum*78;
    
44. 
    
45. }
    
46. public boolean equals(Object obj)
    
47. {
    
48. if(!(obj instanceof Student))
    
49. throw new ClassCastException("类型不匹配");
    
50. Student s = (Student)obj;
    
51. 
    
52. return this.name.equals(s.name) && this.sum==s.sum;
    
53. }
    
54. 
    
55. public String toString()
    
56. {
    
57. return "student["+name+", "+ma+", "+cn+", "+en+"]";
    
58. }
    
59. }
    
60. 
    
61. class StudentInfoTool
    
62. {
    
63. public static Set<Student> getStudents()throws IOException
    
64. {
    
65. return getStudents(null);
    
66. }
    
67. 
    
68. public static Set<Student> getStudents(Comparator<Student> cmp)throws IOException
    
69. {
    
70. BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
    
71. 
    
72. String line = null;
    
73. Set<Student> stus = null;
    
74. if(cmp==null)
    
75. stus = new TreeSet<Student>();
    
76. else
    
77. stus = new TreeSet<Student>(cmp);
    
78. while((line=bufr.readLine())!=null)
    
79. {
    
80. if("over".equals(line))
    
81. break;
    
82. 
    
83. String[] info = line.split(",");
    
84. 
    
85. Student stu = new Student(info[0],Integer.parseInt(info[1]),
    
86. Integer.parseInt(info[2]),Integer.parseInt(info[3]));
    
87. stus.add(stu);
    
88. }
    
89. bufr.close();
    
90. return stus;
    
91. }
    
92. 
    
93. public static void write2File(Set<Student> stus)throws IOException
    
94. {
    
95. BufferedWriter bufw = new BufferedWriter(new FileWriter("stuinfo.txt"));
    
96. for(Student stu : stus)
    
97. {
    
98. bufw.write(stu.toString()+"\t");
    
99. bufw.write(stu.getSum()+"");
    
100. bufw.newLine();
     
101. bufw.flush();
     
102. }
     
103. bufw.close();
     
104. }
     
105. }
     
106. 
     
107. class StudentInfoTest
     
108. {
     
109. public static void main(String[] args) throws IOException
     
110. {
     
111. 
     
112. Comparator<Student> cmp = Collections.reverseOrder();
     
113. 
     
114. Set<Student> stus = StudentInfoTool.getStudents(cmp);
     
115. 
     
116. StudentInfoTool.write2File(stus);
     
117. }
     
118. }

复制代码

1. /*
   
2. 有五个学生，每个学生有3门课的成绩，
   
3. 从键盘输入以上数据（包括姓名，三门课成绩），
   
4. 输入的格式：如：zhagnsan，30，40，60计算出总成绩，
   
5. 并把学生的信息和计算出的总分数高低顺序存放在磁盘文件"stud.txt"中。
   
6. */
   
7. import java.io.*;
   
8. import java.util.*;
   
9. //这个是学生类，有实现Comparable接口，可以进行比较
   
10. class Student implements Comparable<Student>
    
11. {
    
12. private String name;//这个就不用加了吧
    
13. private int ma,cn,en;
    
14. private int sum;
    
15. 
    
16. Student(String name,int ma,int cn,int en)
    
17. {
    
18. this.name = name;//构造方法
    
19. this.ma = ma;
    
20. this.cn = cn;
    
21. this.en = en;
    
22. sum = ma + cn + en;//算出总分
    
23. }
    
24. 
    
25. public int compareTo(Student s)
    
26. {
    
27. int num = new Integer(this.sum).compareTo(new Integer(s.sum));
    
28. if(num==0)//先比较总分，总分相同再比较名字的字母顺序
    
29. return this.name.compareTo(s.name);
    
30. return num;
    
31. }
    
32. 
    
33. public String getName()
    
34. {
    
35. return name;
    
36. }
    
37. public int getSum()
    
38. {
    
39. return sum;
    
40. }
    
41. 
    
42. public int hashCode()
    
43. {//计算hashCode值
    
44. return name.hashCode()+sum*78;
    
45. 
    
46. }
    
47. public boolean equals(Object obj)
    
48. {
    
49. if(!(obj instanceof Student))
    
50. throw new ClassCastException("类型不匹配");
    
51. Student s = (Student)obj;
    
52. 
    
53. return this.name.equals(s.name) && this.sum==s.sum;
    
54. }
    
55. 
    
56. public String toString()
    
57. {
    
58. return "student["+name+", "+ma+", "+cn+", "+en+"]";
    
59. }
    
60. }
    
61. 
    
62. class StudentInfoTool//
    
63. {
    
64. public static Set<Student> getStudents()throws IOException
    
65. {
    
66. return getStudents(null);
    
67. }
    
68. 
    
69. public static Set<Student> getStudents(Comparator<Student> cmp)throws IOException
    
70. {
    
71. BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
    
72. 
    
73. String line = null;
    
74. Set<Student> stus = null;
    
75. if(cmp==null)
    
76. stus = new TreeSet<Student>();
    
77. else
    
78. stus = new TreeSet<Student>(cmp);
    
79. while((line=bufr.readLine())!=null)
    
80. {
    
81. if("over".equals(line))
    
82. break;
    
83. 
    
84. String[] info = line.split(",");
    
85. 
    
86. Student stu = new Student(info[0],Integer.parseInt(info[1]),
    
87. Integer.parseInt(info[2]),Integer.parseInt(info[3]));
    
88. stus.add(stu);
    
89. }
    
90. bufr.close();
    
91. return stus;
    
92. }
    
93. 
    
94. public static void write2File(Set<Student> stus)throws IOException
    
95. {
    
96. BufferedWriter bufw = new BufferedWriter(new FileWriter("stuinfo.txt"));
    
97. for(Student stu : stus)
    
98. {
    
99. bufw.write(stu.toString()+"\t");
    
100. bufw.write(stu.getSum()+"");
     
101. bufw.newLine();
     
102. bufw.flush();
     
103. }
     
104. bufw.close();
     
105. }
     
106. }
     
107. 
     
108. class StudentInfoTest
     
109. {
     
110. public static void main(String[] args) throws IOException
     
111. {
     
112. 
     
113. Comparator<Student> cmp = Collections.reverseOrder();
     
114. 
     
115. Set<Student> stus = StudentInfoTool.getStudents(cmp);
     
116. 
     
117. StudentInfoTool.write2File(stus);
     
118. }
     
119. }
     

复制代码

就加了这点，想睡觉了

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

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

/**
*
* 这是一个用来描述学生信息的类
* 继承了Comparable接口后，就可以在许多地方调用比较器的地方被默认调用用于排序等比较操作了
* 比如在TreeSet中的排序
*/
class Student implements Comparable<Student>
{
        /**
         * 学生的姓名
         */
        private String name;

        /**
         * 这个就分别是数学、语文、英语的成绩
         */
        private int ma,cn,en;

        /**
         * 这个是总成绩
         */
        private int sum;

        /**
         * 构造器，不多说哈，你懂的
         * @param name
         * @param ma
         * @param cn
         * @param en
         */
        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;
        }

        /**
         * compareTo方法是上面类声明实现Comparable接口要实现的方法
         */
        @Override
        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;
        }

        /**
         * （访问器，没啥可说的）
         * @return
         */
        public String getName()
        {
                return name;
        }
        
        /**
         * （访问器，没啥可说的）
         * @return
         */
        public int getSum()
        {
                return sum;
        }

        /**
         * 这个方法覆盖了公共父类Object类的hashCode()方法
         * 常见应用在与哈希表有关的容器中，被调用。常与equals(Object obj)方法同事被覆盖重写
         * 默认情况下，通过内存地址映射算出来的值
         * 例如：HashMap、HashSet等
         */
        public int hashCode()
        {
                return name.hashCode()+sum*78;
        }
        
        /**
         * 这个方法覆盖了公共父类Object类的equals(Object obj)方法。
         * 用于比较两个对象是否相等。
         * 默认情况下，以内存地址映射进行比较。
         *
         */
        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;
        }
        
        /**
         * 这个方法覆盖了公共父类Object类的toString()方法
         * 常用语打印对象相关的参数值
         * 默认打印的值与类和HashCode有关
         */
        public String toString()
        {
        return "student["+name+", "+ma+", "+cn+", "+en+"]";
        }
}

/**
* 这事一个维护学生信息的工具类
* 可以看出，这个类中，全都是静态方法，应用中不需要被生成对象
* @author CBY
*
*/
class StudentInfoTool
{
        /**
         * 这个方法用于获取所有学生信息（本质是调用方法getStudents(Comparator<Student> cmp)）
         * @return
         * @throws IOException
         */
        public static Set<Student> getStudents()throws IOException
        {
                return getStudents(null);
        }

        /**
         * 这个方法用于从键盘输入获取学生信息
         * 因为返回的对象是一个TreeSet类实例
         * Set中的数据有顺序，且不重复。
         * 所以，可以理解为什么上面Student类定义的要继承Comparable接口
         * @param cmp 这个一个比较器接口，在代码中可以看出：
         *                     如果入参是一个比较器对象，则按比较器的规则排列和比较学生信息
         *                     如果入参是一个null，则按Student的compareTo方法来排序和比较学生信息
         * @return
         * @throws IOException
         */
        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;
               
                //如果没有入参比较器，则要求TreeSet按Student的compareTo方法来排序和比较学生信息
                if(cmp==null)
                        stus = new TreeSet<Student>();
                //如果入参比较器，则要求TreeSet按比较器中定义的规则来排序和比较学生信息
                else
                        stus = new TreeSet<Student>(cmp);
               
                //逐行读取键盘中录入的学生信息（直到读到"over"字符串为止）
                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;
        }

        /**
         * 将信息写入到文件中
         * @param stus
         * @throws IOException
         */
        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();
        }
}

/**
* 这是一个验证类
* @author CBY
*
*/
class StudentInfoTest
{
        public static void main(String[] args) throws IOException
        {
                //这边定义了一个比较器（将Student的compareTo的规则进行反向返回，也就是倒序排列）
                Comparator<Student> cmp = Collections.reverseOrder();
               
                //获取学生信息
                Set<Student> stus = StudentInfoTool.getStudents(cmp);
               
                //将获取到的学生信息输出到文件中。
                StudentInfoTool.write2File(stus);
        }
}