1. /*
   
2. 练习
   
3. 五个学生，每个学生有3门课程的成绩
   
4. 从键盘输入以上数据（姓名，三门课成绩）
   
5. 输入格式：如：zahngsan，30,40,60计算出总成绩
   
6. 并把学生的信息和计算出的总分数高低按顺序存放在磁盘文件stud.txt中
   
7. 
   
8. 1、描述学生对象
   
9. 2、定义一个可操作学生对象的工具类
   
10. 
    
11. 思路：
    
12. 1、通过获取键盘录入一行的数据，并将该行数据的信息取出，封装成学生对象
    
13. 2、因为学生对象很多，则需要存储，使用集合，因为要对学生总分排序
    
14.         所以可以使用TreeSet
    
15. 3、将集合中的信息写入到一个文件中
    
16. */
    
17. 
    
18. import java.io.*;
    
19. import java.util.*;
    
20. //定义学生类
    
21. class Student implements Comparable<Student>
    
22. {
    
23.         //定义私有属性
    
24.         private String name;
    
25.         private int ma,cn,en;
    
26.         private int sum;
    
27.         //构造Student函数，初始化
    
28.         Student(String name,int ma,int cn,int en)
    
29.         {
    
30.                 this.name = name;
    
31.                 this.ma = ma;
    
32.                 this.cn = cn;
    
33.                 this.en = en;
    
34.                 sum = ma+cn+en;
    
35.         }
    
36.         //覆写compareTo方法，按学生总成绩排序
    
37.         public int compareTo(Student s)
    
38.         {
    
39.                 int num = new Integer(this.sum).compareTo(new Integer(s.sum));
    
40.                 if(num==0)
    
41.                         return this.name.compareTo(s.name);
    
42.                 return num;
    
43.         }
    
44.         //获取学生信息
    
45.         public String getName()
    
46.         {
    
47.                 return name;
    
48.         }
    
49.         public int getSum()
    
50.         {
    
51.                 return sum;
    
52.         }
    
53.         //覆写hasdCode()和equals()方法，排除相同的两个学生
    
54.         public int hashCode()
    
55.         {
    
56.                 return name.hashCode() + sum*39;
    
57.         }
    
58.         public boolean equals(Object obj)
    
59.         {
    
60.                 if(obj instanceof Student)
    
61.                         throw new ClassCastException("类型不匹配");
    
62.                 Student s = (Student)obj;
    
63.                 return this.name.equals(s.name) && this.sum==s.sum;
    
64.         }
    
65.         //定义学生信息显示格式
    
66.         public String toString()
    
67.         {
    
68.                 return "student[" + name + "," + ma + "," + cn + "," + en + "]";
    
69.         }
    
70. }
    
71. //工具类，将键盘录入的输入存入集合，并将集合的元素写入文件中
    
72. class StudentInfoTool
    
73. {
    
74.         //无比较器的学生集合
    
75.         public static Set<Student> getStudents()
    
76.         {
    
77.                 return getStudents(null);
    
78.         }
    
79.         //具备比较器的学生集合
    
80.         public static Set<Student> getStudents(Comparator<Student> cmp)
    
81.         {
    
82.                 BufferedReader bufr = null;
    
83.                 Set<Student> stus = null;
    
84.                 try
    
85.                 {
    
86.                         //创建读取流对象缓冲区，键盘录入
    
87.                         bufr = new BufferedReader(new InputStreamReader(System.in));
    
88.                         String line = null;
    
89.                         //选择集合是否有比较器
    
90.                         if(cmp==null)
    
91.                                 stus = new TreeSet<Student>(cmp);
    
92.                         else
    
93.                                 stus = new TreeSet<Student>();
    
94.                         //循环读取键盘录入的数据
    
95.                         while((line=bufr.readLine())!=null)
    
96.                         {
    
97.                                 if("over".equals(line))
    
98.                                         break;
    
99.                                 //对读取的数据进行分割并存入集合
    
100.                                 String[] info = line.split(",");
     
101.                                 Student stu = new Student(info[0],Integer.parseInt(info[1]),
     
102.                                                                                                 Integer.parseInt(info[2]),
     
103.                                                                                                 Integer.parseInt(info[3]));
     
104.                                 stus.add(stu);
     
105.                         }
     
106.                 }
     
107.                 catch (IOException e)
     
108.                 {
     
109.                         throw new RuntimeException("学生信息读取失败");
     
110.                 }
     
111.                 //关闭流资源
     
112.                 finally
     
113.                 {
     
114.                         try
     
115.                         {
     
116.                                 if(bufr!=null)
     
117.                                         bufr.close();
     
118.                         }
     
119.                         catch (IOException e)
     
120.                         {
     
121.                                 throw new RuntimeException("读取流关闭失败");
     
122.                         }
     
123.                         return stus;
     
124.                 }
     
125.         }
     
126.         //将数据写入指定文件
     
127.         public static void write2File(Set<Student> stus,String fileName)
     
128.         {
     
129.                 BufferedWriter bufw = null;
     
130.                 try
     
131.                 {
     
132.                         //创建写入流对象
     
133.                         bufw = new BufferedWriter(new FileWriter(fileName));
     
134.                         //循环写入数据
     
135.                         for(Student stu : stus)
     
136.                         {
     
137.                                 bufw.write(stu.toString() + "\t");
     
138.                                 bufw.write(stu.getSum() + "");
     
139.                                 bufw.newLine();
     
140.                                 bufw.flush();
     
141.                         }
     
142.                 }
     
143.                 catch (IOException e)
     
144.                 {
     
145.                         throw new RuntimeException("读取流关闭失败");
     
146.                 }
     
147.                 //关闭流资源
     
148.                 finally
     
149.                 {
     
150.                         try
     
151.                         {
     
152.                                 if(bufw!=null)
     
153.                                         bufw.close();
     
154.                         }
     
155.                         catch (IOException e)
     
156.                         {
     
157.                                 throw new RuntimeException("写入流关闭失败");
     
158.                         }
     
159.                 }
     
160.         }
     
161. }
     
162. 
     
163. class Demo
     
164. {
     
165.         public static void main(String[] args)
     
166.         {
     
167.                 //反转比较器，将成绩从大到小排
     
168.                 Comparator<Student> cmp = Collections.reverseOrder();
     
169.                 //将录入的学生信息存入集合
     
170.                 Set<Student> stus = StudentInfoTool.getStudents(cmp);
     
171.                 //将信息写入指定文件中
     
172.                 StudentInfoTool.write2File(stus,"sudentinfo.txt");
     
173.         }
     
174. }
     

复制代码

结果如图：

我怎么和老师的对比，都没找到原因，为什么对不齐，而且还没反转比较器。
解决的好的奖励越高

public static Set<Student> getStudents(Comparator<Student> cmp)
        {
                BufferedReader bufr = null;
                Set<Student> stus = null;
                try
                {
                        //创建读取流对象缓冲区，键盘录入
                        bufr = new BufferedReader(new InputStreamReader(System.in));
                        String line = null;
                        //选择集合是否有比较器
                        if(cmp==null)//这里写反
                                stus = new TreeSet<Student>(cmp);//
                        else
                                stus = new TreeSet<Student>();
                        //循环读取键盘录入的数据
                        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);
                        }
                }

谢洋 发表于 2013-3-7 11:09
public static Set getStudents(Comparator cmp)
        {
                BufferedReader bufr = null;

太感谢了，我看了半天，都有点晕了，不过为什么对不齐呢？

黄玉昆 发表于 2013-3-7 11:23
太感谢了，我看了半天，都有点晕了，不过为什么对不齐呢？

用制表符 对齐的话得在制表符可控之内

对齐与制表符有关：每八个字节位为一个制表位
从打印的每行的首个字字母算起到制表符结束这段长度，也就是总成绩的前的字符个数必定是八个字节(制表位长度)的倍数.
下面是我改写学生信息的测试结果：
student[da,78,94,88]        260
111111111111111111111111       //  到成绩位处是24个1(即3个制表符长度)
student[zixisfsdf,88,64,97]        249
11111111111111111111111111111111  //   到成绩位处是32个1(即4个制表符长度)
student[xiaosssssss,55,68,99]        222
student[wusedfdfd,54,85,67]        206
student[zhaw,25,40,60]        125

楼上很详细  呵呵
替谢洋求个技术分啊     呵呵  {:soso_e113:}

谢洋 发表于 2013-3-7 11:35
对齐与制表符有关：每八个字节位为一个制表位
从打印的每行的首个字字母算起到制表符结束这段长度，也就是 ...

那为什么我用毕老师的源代码运行，结果却和我的不一样，他的就能对齐，源码如下：

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

复制代码

谢洋 发表于 2013-3-7 11:35
对齐与制表符有关：每八个字节位为一个制表位
从打印的每行的首个字字母算起到制表符结束这段长度，也就是 ...

应该不是制表符的问题吧

黄玉昆 发表于 2013-3-7 11:51
应该不是制表符的问题吧

我运行了下毕老师的程序 一样的  数据相差过大 也无法实现整体对齐

张向辉 发表于 2013-3-7 12:19
我运行了下毕老师的程序 一样的  数据相差过大 也无法实现整体对齐

这是毕老师代码运行后的结果，难道是我的电脑出了问题？这道题折磨了我一上午，还是想不通。看来我得好好检查一下了

{:soso_e103:}这些代码离我还比较远

黄玉昆 发表于 2013-3-7 11:51
应该不是制表符的问题吧

这是毕老是测的结果：的确是都对齐，
student[lisi, 90, 90, 90] 270
                              到"]"这里是25位，与制表符还是有关的
原因毕比老师的代码跟我们写的有点不一样:学生的toString（）方法
public String toString()//这是毕老师的代码黄色部分有一个空格,有这两空格后，长度超过24位，需增加一个制表位
        {
                return "student["+name+", "+ma+", "+cn+", "+en+"]";
        }
      public String toString()//这是你写的，黄色部分没有空格
        {
                return "student[" + name + "," + ma + "," + cn + "," + en + "]";
        }
student[suanba, 60, 60, 60] 180
student[zhouqi, 50, 50, 50] 150
student[zhansan, 40, 20, 90] 150
student[zhaoliu, 30, 40, 60] 130
student[wnagwu, 10, 20, 10] 40

黄玉昆 发表于 2013-3-7 12:56
这是毕老师代码运行后的结果，难道是我的电脑出了问题？这道题折磨了我一上午，还是想不通。看来我得好 ...

这些数据都在24到32之间  所以是对齐的
你的不能对齐是因为 你数据里没有空格  其长度没有控制在24到32一个制表符间隔中

粘贴错了  是toString方法里  你的输出中没有添加空格，其输出长度和毕老师的输出长度是不一样的

喔喔 谢洋已经回答了  回答晚了

谢洋 发表于 2013-3-7 13:13
这是毕老是测的结果：的确是都对齐，
student[lisi, 90, 90, 90] 270
                              到" ...

可是有一点就不太好了，确实是对齐了，但是在文本中每个后面都会有个空格，我想在切的时候用逗号和空格切，就出问题了，运行后输入一个，回车后就结束程序了。这让我很郁闷

这个还没有看到啊，不会

哎，来晚了，确实是toString方法的问题，这么小的细节也能造成错误，真心错不起啊，
toString()
return "student["+name+", "+ma+", "+cn+", "+en+"]";

黄玉昆 发表于 2013-3-7 13:28
可是有一点就不太好了，确实是对齐了，但是在文本中每个后面都会有个空格，我想在切的时候用逗号和空格切 ...

我想你的输入格式有问题：如下
while((line=bufr.readLine())!=null)
                {
                        if("over".equals(line))
                                break;
                        
                        String[] info = line.split(", ");//版主，我想你输入的格式是：lisi,34,55,69这样子，","后面没有空格,
                                                            //在切割时，当找不到逗号加空格", "这个表达式，就会抛异常
                        
                        Student stu = new Student(info[0],Integer.parseInt(info[1]),
                                                                                Integer.parseInt(info[2]),
                                                                                Integer.parseInt(info[3]));
                        
                        stus.add(stu);
                }

谢洋 发表于 2013-3-7 14:04
我想你的输入格式有问题：如下
while((line=bufr.readLine())!=null)
                {

嗯啊，我得向你学习了，我这学的都糊涂了，完全懵了