键盘录入学生的语文，数学，英语成绩。按照总分排序从高到下写入文本中。

采用TreeMap集合。里面存储键为学生对象，值为总分。

采用TreeMap集合。里面存储键为学生对象，值为总分。学生对象要实现comparable接口。

伸手党，视频里貌似讲过这个吧 = =

最近一直在敲博客，实在不想敲代码了。。。

视频要认真看，代码要认真敲，懂

仅供参考，注释懒的写了

1. import java.io.*;
   
2. import java.util.*;
   
3. class Student implements Comparable
   
4. {
   
5.         private String name;
   
6.         private int math;
   
7.         private int cn;
   
8.         private int en;
   
9.         private int score;
   
10.         Student(String name,int math,int cn,int en)
    
11.         {
    
12.                 this.name = name;
    
13.                 this.math = math;
    
14.                 this.cn = cn;
    
15.                 this.en = en;
    
16.         }
    
17. 
    
18.         public int getScore()
    
19.         {
    
20.                 return math + cn + en ;
    
21.         }
    
22. 
    
23.         public String toString()
    
24.         {
    
25.                 return name+"\t"+math+"\t"+cn+"\t"+en;
    
26.         }
    
27.        
    
28.         public boolean equals(Object obj)
    
29.         {
    
30.                 if(!(obj instanceof Student))
    
31.                         throw new ClassCastException("不是学生对象");
    
32.                 Student s = (Student)obj;
    
33.                 return s.name.equals(this.name)&&s.getScore()==this.getScore();
    
34.         }
    
35.         public int compareTo(Object obj)
    
36.         {
    
37.                 Student s = (Student)obj;
    
38.                 int num = new Integer(s.getScore()).compareTo(new Integer(this.getScore()));
    
39.                 if (num==0)
    
40.                         return this.name.compareTo(s.name);
    
41.                 return num;
    
42.         }
    
43. }
    
44. 
    
45. class Stu
    
46. {
    
47.         public static void main(String[] args)
    
48.         {
    
49.                 inputInfo();
    
50.         }
    
51. 
    
52.         public static void inputInfo()
    
53.         {
    
54.                 TreeSet<Student> ts = new TreeSet<Student>();
    
55.                 BufferedReader bufr = null;
    
56.                 BufferedWriter bufw = null;
    
57.                 try
    
58.                 {
    
59.                         bufr = new BufferedReader(new InputStreamReader(System.in));
    
60.                         bufw = new BufferedWriter(new FileWriter("stud.txt"));
    
61. 
    
62.                         String len = null;
    
63.                         while ((len=bufr.readLine())!=null)
    
64.                         {
    
65.                                 if("over".equals(len))
    
66.                                         break;
    
67.                                 String[] s = len.split(",");
    
68.                                 ts.add(new Student(s[0],Integer.parseInt(s[1]),Integer.parseInt(s[2]),Integer.parseInt(s[3])));
    
69.                         }
    
70. 
    
71.                         Iterator<Student> it = ts.iterator();
    
72. 
    
73.                         int score = 0;
    
74.                         bufw.write("姓名\t数学\t语文\t英语\t总分");
    
75.                         bufw.newLine();
    
76.                         while (it.hasNext())
    
77.                         {
    
78.                                 Student s = it.next();
    
79.                                 score = s.getScore();
    
80.                                 bufw.write(s.toString()+"\t"+score);
    
81.                                 bufw.newLine();
    
82.                         }
    
83.                 }
    
84.                 catch (IOException e)
    
85.                 {
    
86.                         throw new RuntimeException("录入失败！");
    
87.                 }
    
88.                 finally
    
89.                 {
    
90.                         try
    
91.                         {
    
92.                                 if(bufw!=null)
    
93.                                         bufw.close();
    
94.                         }
    
95.                         catch (IOException e)
    
96.                         {
    
97.                                 throw new RuntimeException("关闭写入流失败！");
    
98.                         }
    
99. 
    
100.                         try
     
101.                         {
     
102.                                 if(bufr!=null)
     
103.                                         bufr.close();
     
104.                         }
     
105.                         catch (IOException e)
     
106.                         {
     
107.                                 throw new RuntimeException("关闭读取流失败！");
     
108.                         }
     
109.                 }
     
110.         }
     
111. }
     
112. 
     

复制代码

1. 这是我写的，你可以参考一下

复制代码

额，咋没了呢

1. package com.itheima;
   
2. 
   
3. import java.io.BufferedReader;
   
4. import java.io.BufferedWriter;
   
5. import java.io.FileOutputStream;
   
6. import java.io.IOException;
   
7. import java.io.InputStreamReader;
   
8. import java.io.OutputStreamWriter;
   
9. import java.util.ArrayList;
   
10. 
    
11. public class Text4 {
    
12. 
    
13.         /**
    
14.          * 第4题 有五个学生，每个学生有3门课（语文、数学、英语）的成绩，写一个程序接收从键盘输入学生的信息，
    
15.          * 输入格式为：name,30,30,30（姓名，三门课成绩），然后把输入的学生信息按总分从高到低的顺序写入到
    
16.          * 一个名称"stu.txt"文件中。要求：stu.txt文件的格式要比较直观，打开这个文件，就可以很清楚的看到学生的信息。
    
17.          * @param args
    
18.          * @throws IOException
    
19.          */
    
20.         public static void main(String[] args) throws IOException {
    
21.                 //创建ArrayList对象，用来存放学生对象
    
22.                 ArrayList<Student> list = new ArrayList<Student>();
    
23.                 list = getStudentsList();
    
24.                 //创建输出缓冲区，用来将得到的学生信息写入stu.txt文件中
    
25.                 BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("stu.txt")));
    
26.                 for(int i = 0; i < list.size(); i ++) {
    
27.                         String str = list.get(i).toString();
    
28.                         bufw.write(str);
    
29.                         bufw.newLine();
    
30.                         bufw.flush();
    
31.                 }
    
32.                 bufw.close();
    
33.         }
    
34.         //定义方法，对存放学生的ArrayList按照学生总成绩排序
    
35.         public static void sort(ArrayList<Student> list) {
    
36.                 Student temp = null;
    
37.                 for(int i = 0; i < list.size()-1; i ++) {
    
38.                         for(int j = i+1; j < list.size(); j ++) {
    
39.                                 if(list.get(i).getSum() < list.get(j).getSum()) {
    
40.                                         temp = list.get(i);
    
41.                                         list.set(i, list.get(j));
    
42.                                         list.set(j, temp);
    
43.                                 }
    
44.                                 System.out.println(""+i+j);
    
45.                         }
    
46.                 }
    
47.         }
    
48.         //定义方法，将键盘输入的学生对象存储到ArrayList列表中，并返回该列表
    
49.         public static ArrayList<Student> getStudentsList() throws IOException {
    
50.                 System.out.println("请按照格式输入学生信息：注意学生成绩精确到小数点后一位");
    
51.                 System.out.println("格式：学生名,语文成绩,数学成绩,英语成绩；其中,为英文,");
    
52.                 //创建ArrayList对象，用来存放学生对象
    
53.                 ArrayList<Student> list = new ArrayList<Student>();
    
54.                 //创建输入缓冲区，用来就收键盘输入的学生信息
    
55.                 BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
    
56.                 String line = null;
    
57.                 //定义正则规则，用来限制输入的学生信息的格式
    
58.                 String str = "((\\w+)|([\\u4e00-\\u9fa5]+))(,((\\d{1,3})|(\\d{1,2}\\.\\d{1}))){3}";
    
59.                 while((line = bufr.readLine()) != null) {
    
60.                         if("over".equals(line)) {
    
61.                                 break;
    
62.                         }
    
63.                         if(!line.matches(str)) {
    
64.                                 System.out.println("对不起，您输入的格式不正确，请重新输入！");
    
65.                         }else {
    
66.                                 //通过split方法，将学生的信息提取处理
    
67.                                 String name = line.split(",")[0];
    
68.                                 double chineseScore = Double.parseDouble(line.split(",")[1]);
    
69.                                 double mathsScore = Double.parseDouble(line.split(",")[2]);
    
70.                                 double englishScore = Double.parseDouble(line.split(",")[3]);
    
71.                                 //创建与输入信息对应的学生对象
    
72.                                 Student stu = new Student(name, chineseScore, mathsScore, englishScore);
    
73.                                 //将学生对象添加到list中
    
74.                                 list.add(stu);
    
75.                         }
    
76.                 }
    
77.                 bufr.close();
    
78.                 sort(list);//对list按照学生成绩进行排序
    
79.                 return list;
    
80.         }
    
81. }
    
82. /*
    
83. * 定义学生类
    
84. */
    
85. class Student {
    
86.         //定义学生类属性
    
87.         private String name;//学生姓名
    
88.         private double chineseScore;//语文成绩
    
89.         private double mathsScore;//数学成绩
    
90.         private double englishScore;//英语成绩
    
91.         //定义构造函数
    
92.         public Student(String name, double chineseScore, double mathsScore,
    
93.                         double englishScore) {
    
94.                 this.name = name;
    
95.                 this.chineseScore = chineseScore;
    
96.                 this.mathsScore = mathsScore;
    
97.                 this.englishScore = englishScore;
    
98.         }
    
99.         //定义对学生类属性进行操作的方法
    
100.         public String getName() {
     
101.                 return name;
     
102.         }
     
103.         public void setName(String name) {
     
104.                 this.name = name;
     
105.         }
     
106.         public double getChineseScore() {
     
107.                 return chineseScore;
     
108.         }
     
109.         public void setChineseScore(int chineseScore) {
     
110.                 this.chineseScore = chineseScore;
     
111.         }
     
112.         public double getMathsScore() {
     
113.                 return mathsScore;
     
114.         }
     
115.         public void setMathsScore(int mathsScore) {
     
116.                 this.mathsScore = mathsScore;
     
117.         }
     
118.         public double getEnglishScore() {
     
119.                 return englishScore;
     
120.         }
     
121.         public void setEnglishScore(int englishScore) {
     
122.                 this.englishScore = englishScore;
     
123.         }
     
124.         //定义方法，获得该学生的总成绩。
     
125.         public double getSum() {
     
126.                 return chineseScore + mathsScore + englishScore;
     
127.         }
     
128.         //用重写的方式，自定义toString方法
     
129.         @Override
     
130.         public String toString() {
     
131.                 return name + ", \t" + chineseScore + ", \t" + mathsScore + ", \t" + englishScore;
     
132.         }
     
133. }

复制代码

liu951753xz 发表于 2014-10-17 23:40
视频要认真看，代码要认真敲，懂

问你一个问题，继承Thread类，与是先Runnablejie接口哪个更好，占用资源最少？

liu951753xz 发表于 2014-10-17 23:40
视频要认真看，代码要认真敲，懂

还有一个也不懂，这个也不是敲代码的问题，线程同步时，比如转账操作，为什么两个线程操作时会产生钱总数的误差错误，比如转出两百，转入两百，变化的仍是两百，最后总数却有误差，明明总数是一个变量，只是存的时候被中断了，却产生了误差，意思是操作的是一个变量，怎么会这样，求指教，谢谢。ps：这个不是伸手党，只是个疑惑而已。

学习一下。