package com.itheima;

import static java.lang.Integer.parseInt;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Scanner;
import java.util.TreeSet;

public class Test4 {

        /**
         * 有五个学生，每个学生有3门课（语文、数学、英语）的成绩，写一个程序接收从键盘输入学生的信息，
         * 输入格式为：name,30,30,30（姓名，三门课成绩），然后把输入的学生信息按总分从高到低的顺序写入到一个名称"stu.txt"文件中。
         * 要求：stu.txt文件的格式要比较直观，打开这个文件，就可以很清楚的看到学生的信息。
         * @throws IOException
         */
        public static void main(String[] args) throws IOException {
                    BufferedReader bd = new BufferedReader(new InputStreamReader(System.in));
                    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter("stu.txt"));
                    System.out.println("请输入学生成绩格式是:姓名,语文成绩,数学成绩,英语成绩");
                    //创建TreeSet集合对象,在TreeSet的构造函数中传入比较器,按照总分比较
                    TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {

                            @Override
                            public int compare(Student s1, Student s2) {
                                    int num = s2.getSum() - s1.getSum();
                                    return num == 0 ? 2 : num;
                            }
                    });
                    //录入五个学生,所以以集合中的学生个数为判断条件,如果size是小于5就进行存储
                    while(ts.size() < 5) {
                            //将录入的字符串切割,用逗号切割,会返回一个字符串数组,将字符串数组中从二个元素转换成int数,
                            String line = bd.readLine();
                            String[] arr = line.split(",");
                            int chinese = Integer.parseInt(arr[1]);
                            int math = Integer.parseInt(arr[2]);
                            int english = Integer.parseInt(arr[3]);
                            //将转换后的结果封装成Student对象,将Student添加到TreeSet集合中
                            ts.add(new Student(arr[0], chinese, math, english));
                    }
                   
                    //遍历TreeSet集合打印每一个Student对象
                    for (Student s : ts) {
                            System.out.println(s);                            
                    }
        }
               
}
class Student {
        private String name;
        private int chinese;
        private int math;
        private int english;
        private int sum;
       
        public Student() {
                super();
               
        }
        public Student(String name, int chinese, int math, int english) {
                super();
                this.name = name;
                this.chinese = chinese;
                this.math = math;
                this.english = english;
                this.sum = this.chinese + this.math + this.english;
        }
        public int getSum() {
                return sum;
        }
       
        public String toString() {
                return name + "," + chinese + "," + math + "," + english + "," + sum;
        }
       
}

还是不懂 还是不懂。。。。

我也没看懂，表示过来学习一下~

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.TreeSet;

public class Test
{

        /**
         * 有五个学生，每个学生有3门课（语文、数学、英语）的成绩，写一个程序接收从键盘输入学生的信息，
         * 输入格式为：name,30,30,30（姓名，三门课成绩），然后把输入的学生信息按总分从高到低的顺序写入到一个名称"stu.txt"文件中。
         * 要求：stu.txt文件的格式要比较直观，打开这个文件，就可以很清楚的看到学生的信息。
         *
         * @throws IOException
         */
        public static void main(String[] args) throws IOException
        {
                BufferedReader bd = new BufferedReader(new InputStreamReader(System.in));
                 BufferedWriter bw = new BufferedWriter(new FileWriter("stu.txt"));
                //System.out.println("请输入学生成绩格式是:姓名,语文成绩,数学成绩,英语成绩");
                // 创建TreeSet集合对象,在TreeSet的构造函数中传入比较器,按照总分比较
                TreeSet<Student> ts = new TreeSet<Student>();
                // 录入五个学生,所以以集合中的学生个数为判断条件,如果size是小于5就进行存储
                while (ts.size() < 5)
                {
                        // 将录入的字符串切割,用逗号切割,会返回一个字符串数组,将字符串数组中从二个元素转换成int数,
                        String line = bd.readLine();
                        String[] arr = line.split(",");
                        int chinese = Integer.parseInt(arr[1]);
                        int math = Integer.parseInt(arr[2]);
                        int english = Integer.parseInt(arr[3]);
                        // 将转换后的结果封装成Student对象,将Student添加到TreeSet集合中
                        ts.add(new Student(arr[0], chinese, math, english));
                }

                // 遍历TreeSet集合打印每一个Student对象
                for (Student s : ts)
                {
                        //System.out.println(s);
                        bw.write(s.toString());
                        bw.newLine();
                }
                bd.close();
                bw.close();
        }

}

class Student  implements Comparable
{
        private String name;
        private int chinese;
        private int math;
        private int english;
        private int sum;

        public Student(String name, int chinese, int math, int english)
        {
                this.name = name;
                this.chinese = chinese;
                this.math = math;
                this.english = english;
                sum = chinese + math + english;
        }

        public int getSum()
        {
                return sum;
        }

        public String toString()
        {
                return name + "," + chinese + "," + math + "," + english + "," + sum;
        }
       
        public int compareTo(Object obj)
        {
               
                if(!(obj instanceof Student))
                        throw new RuntimeException("不是学生对象");
                Student s = (Student)obj;

                if(this.sum<s.sum)
                        return 1;
                if(this.sum==s.sum)
                {
                        return s.name.compareTo(this.name);
                }
                return -1;
        }
}

希望能帮到你。

//遍历TreeSet集合打印每一个Student对象

1. BufferedWriter br=new BufferedWriter(FileWriter("stu.txt"));
   
2. for(Student s:stu)
   
3. {
   
4.         br.write(s.toString());
   
5.         br.newLine();
   
6.         br.flush();
   
7. }
   
8. br.close();

复制代码

你试一下

比方说你的程序编译好后叫1.exe
在命令行输入
1.exe >result.txt

运行之后，控制台的东西就保存到result.txt里

1. import java.io.*;
   
2. import java.util.*;
   
3. 
   
4. public class test
   
5. {
   
6. 
   
7.         /**
   
8.          * 有五个学生，每个学生有3门课（语文、数学、英语）的成绩，写一个程序接收从键盘输入学生的信息，
   
9.          * 输入格式为：name,30,30,30（姓名，三门课成绩），然后把输入的学生信息按总分从高到低的顺序写入到一个名称"stu.txt"文件中。
   
10.          * 要求：stu.txt文件的格式要比较直观，打开这个文件，就可以很清楚的看到学生的信息。
    
11.          *
    
12.          * @throws IOException
    
13.          */
    
14.         public static void main(String[] args) throws Exception
    
15.         {
    
16.                 BufferedReader bd = new BufferedReader(new InputStreamReader(System.in));
    
17.                  BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\stus.txt"));
    
18.                 //System.out.println("请输入学生成绩格式是:姓名,语文成绩,数学成绩,英语成绩");
    
19.                 // 创建TreeSet集合对象,在TreeSet的构造函数中传入比较器,按照总分比较
    
20.                 TreeSet<Student> ts = new TreeSet<Student>();
    
21.                 // 录入五个学生,所以以集合中的学生个数为判断条件,如果size是小于5就进行存储
    
22.                 while (ts.size() < 5)
    
23.                 {
    
24.                         // 将录入的字符串切割,用逗号切割,会返回一个字符串数组,
    
25.                                                 //将字符串数组中从二个元素转换成int数,第一个是姓名
    
26.                         String line = bd.readLine();
    
27.                         String[] arr = line.split(",");
    
28.                         int chinese = Integer.parseInt(arr[1]);
    
29.                         int math = Integer.parseInt(arr[2]);
    
30.                         int english = Integer.parseInt(arr[3]);
    
31.                         // 将转换后的结果封装成Student对象,将Student添加到TreeSet集合中
    
32.                         ts.add(new Student(arr[0], chinese, math, english));
    
33.                 }
    
34. 
    
35.                 // 遍历TreeSet集合打印每一个Student对象
    
36.                 for (Student s : ts)
    
37.                 {
    
38.                         //System.out.println(s);
    
39.                         bw.write(s.toString());
    
40.                         bw.newLine();
    
41.                 }
    
42.                 bd.close();
    
43.                 bw.close();
    
44.         }
    
45. 
    
46. }
    
47. 
    
48. class Student  implements Comparable
    
49. {
    
50.         private String name;
    
51.         private int chinese;
    
52.         private int math;
    
53.         private int english;
    
54.         private int sum;
    
55. 
    
56.         public Student(String name, int chinese, int math, int english)
    
57.         {
    
58.                 this.name = name;
    
59.                 this.chinese = chinese;
    
60.                 this.math = math;
    
61.                 this.english = english;
    
62.                 sum = chinese + math + english;
    
63.         }
    
64. 
    
65.         public int getSum()
    
66.         {
    
67.             return sum;
    
68.         }
    
69. 
    
70.         public String toString()
    
71.         {
    
72.             return "["+name + "," + chinese + "," + math + "," + english + "," + sum+"]";
    
73.         }
    
74.       
    
75.         public int compareTo(Object obj)
    
76.         {
    
77.                
    
78.                 if(!(obj instanceof Student))
    
79.                         throw new RuntimeException("不是学生对象");
    
80.                 Student s = (Student)obj;
    
81. 
    
82.                 if(this.sum<s.sum)
    
83.                         return 1;
    
84.                 if(this.sum==s.sum)
    
85.                 {
    
86.                     return s.name.compareTo(this.name);
    
87.                 }
    
88.                 return -1;
    
89.         }
    
90. }
    

复制代码

结果：
[j,99,99,99,297]
[i,100,90,90,280]
[n,90,96,85,271]
[y,89,79,98,266]
[h,88,88,88,264]

1. /**
   
2. * 有五个学生，每个学生有3门课（语文、数学、英语）的成绩，写一个程序接收从键盘输入学生的信息，
   
3. * 输入格式为：name,30,30,30（姓名，三门课成绩），然后把输入的学生信息按总分从高到低的顺序写入到一个名称"stu.txt"文件中。
   
4. * 要求：stu.txt文件的格式要比较直观，打开这个文件，就可以很清楚的看到学生的信息。
   
5. */
   
6. 
   
7. /**
   
8. * 1.先录入信息；
   
9. * 2.进行排序；
   
10. * 3.输出到文件中。
    
11. */
    
12. package com.itheima.problem;
    
13. 
    
14. import  java.io.*;
    
15. import  java.util.*;
    
16. 
    
17. 
    
18. class Student  implements Comparable<Object>{
    
19.          String studentName;
    
20.          float  chineseReport;
    
21.          float  mathReport;
    
22.          float  englishReport;
    
23.          float  sumScore;
    
24.    
    
25.         public Student() {         
    
26.        
    
27.         }
    
28.        
    
29.         public static Student  StudentFactory(String s){
    
30.                 System.out.println(s);
    
31.                 String[] data;
    
32.                 Student sd = new Student();
    
33.         data = s.split(",");
    
34.         
    
35.         for(int i=0;i<data.length;i++){
    
36.                 System.out.println(data[i]);
    
37.         }
    
38.         
    
39.         sd.studentName = data[0];
    
40.         sd.chineseReport = Float.parseFloat(data[1]);
    
41.         sd.mathReport = Float.parseFloat(data[2]);
    
42.             sd.englishReport = Float.parseFloat(data[3]);
    
43.             sd.sumScore = Float.parseFloat(data[1])
    
44.                             +Float.parseFloat(data[2])+
    
45.                             Float.parseFloat(data[3]);
    
46.            
    
47.             return sd;
    
48.         }
    
49.        
    
50.         @Override
    
51.         public String toString() {
    
52.                 return studentName + " " + chineseReport + " "
    
53.                                 + mathReport + " " + englishReport + " " + sumScore;
    
54.         }
    
55.        
    
56.         public int compareTo(Object o)
    
57.         {      
    
58.            if(!(o instanceof Student))
    
59.                    throw new RuntimeException("不是学生对象");
    
60.           
    
61.            Student s = (Student)o;
    
62.            if(this.sumScore<s.sumScore){
    
63.                    return 1;   
    
64.            }   
    
65.            else if(this.sumScore==s.sumScore)
    
66.            {
    
67.                    return this.studentName.compareTo(s.studentName);
    
68.            }
    
69.           
    
70.            return -1;
    
71.         }
    
72. }
    
73. 
    
74. public  class  Test1{
    
75.         public static void main(String[] args)
    
76.                         throws IOException {
    
77.                 String dataInfor ;
    
78.                 Student sd;
    
79.                 List<Student>   stuArray =  new  ArrayList<Student>();
    
80.                
    
81.                 //Input Datas
    
82.             System.out.println("请输入学生成绩格式是:姓名,语文成绩,数学成绩,英语成绩:");
    
83.         while(true){
    
84.                     BufferedReader bd = new BufferedReader(new InputStreamReader(System.in));
    
85.                     if((dataInfor = bd.readLine())!=null)        {
    
86.                             if(dataInfor.equals("end")){
    
87.                                     System.out.println("End Input!");
    
88.                                     break;
    
89.                             }   
    
90.                     }
    
91.                     
    
92.                     sd = Student.StudentFactory(dataInfor);
    
93.                     System.out.println(sd);
    
94.                     stuArray.add(sd);  
    
95.         }
    
96.         
    
97.         //sort
    
98.         Collections.sort(stuArray);
    
99.         System.out.println(stuArray);
    
100. 
     
101.         //output file
     
102.             PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("stu.txt")));
     
103.             ListIterator< Student> it = stuArray.listIterator();
     
104.             while(it.hasNext()){
     
105.                     pw.println(it.next());
     
106.             }
     
107.             pw.close();
     
108.         }
     
109. }

复制代码

vincent 40.0 40.0 40.0 120.0
lsq 30.0 30.0 30.0 90.0
tszy 20.0 20.0 20.0 60.0

哦，额滴神啊，转了一大圈，竟然没几个会的，给不了什么答案，好失败。。。

也想学习一下

我都晕了

个人觉得8楼的比9楼的至少可读性好一点，8楼的很清晰，9楼的说真的我看不下去。

今天整理笔记的时候刚整理到这个问题 System.out.println();是可以定向输入到文件的 代码如下所示
希望能帮到你

1. //重定向
   
2. System.setOut(new PrintStream(new BufferedOutputStream(new FileOutputStream(new File("D:/test/system.txt"))),true)); //设置输出到文件,true表示输出后自动刷新
   
3. String str = "aaa";
   
4. System.out.println(str);
   
5. //回到控制台
   
6. System.setOut(new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.out)),true));//设置回到控制台
   
7. System.out.println("回到控制台");
   

复制代码

得到键盘的数据。
1.Map<name,student> map    student 属性{name,成绩1，成绩2，成绩3，总分}
2.意思就是 通过 Map集合 的key 总分   取出 student 对象，得到信息后，存放入文本
3.存入List 中  进行排序 。  每条数据 存放文本

tansuozhey 发表于 2015-11-20 09:34

我默默的赞一个