Java学习之IO流四

1.用代码实现以下需求
(1)定义学生类,包含姓名(String name),性别(String gender),年龄(int age)三个属性,生成空参有参构造,set和get方法,toString方法
(2)键盘录入6个学员信息(录入格式:张三,男,25),要求有两个相同的信息,将6个学员信息存入到ArrayList集合中
(3)将存有6个学员信息的ArrayList集合对象写入到D:\StudentInfo.txt文件中
(4)读取D:\StudentInfo.txt文件中的ArrayList对象
(5)对ArrayList集合中的6个学生对象进行去重并按照年龄从小到大的顺序排序
(6)将ArrayList集合中排序后的结果利用PrintWriter流写入到E:\StudentInfo.txt文件中(写入格式：张三-男-25)

/**
 * (1)定义学生类,包含姓名(String name),性别(String gender),年龄(int age)三个属性,
 * 生成空参有参构造,set和get方法,toString方法
 * @author vanguard
 * @param <T>
 *
 */
public class Student implements Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = 1234545434L;
    private String name;
    private String gender;
    private int age;
    
    public Student() {}

    public Student(String name, String gender, int age) {
        super();
        this.name = name;
        this.gender = gender;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((gender == null) ? 0 : gender.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (gender == null) {
            if (other.gender != null)
                return false;
        } else if (!gender.equals(other.gender))
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", gender=" + gender + ", age=" + age
                + "]";
    }
    
    
}

/**
 * 1.用代码实现以下需求
    (1)定义学生类,包含姓名(String name),性别(String gender),年龄(int age)三个属性,
        生成空参有参构造,set和get方法,toString方法
    (2)键盘录入6个学员信息(录入格式:张三,男,25),要求有两个相同的信息,
         将6个学员信息存入到ArrayList集合中
    (3)将存有6个学员信息的ArrayList集合对象写入到D:\StudentInfo.txt文件中
    (4)读取D:\StudentInfo.txt文件中的ArrayList对象
    (5)对ArrayList集合中的6个学生对象进行去重并按照年龄从小到大的顺序排序
    (6)将ArrayList集合中排序后的结果利用PrintWriter流写入到
        E:\StudentInfo.txt文件中(写入格式：张三-男-25)
 * @author vanguard
 *
 */
public class Demo01 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {    
        List<Student> list = new ArrayList<Student>();
//        list = addStudentInfo(list);
//        writeStudentInfo(list);
        list = readStudentInfo(list);
        list = sortStudent(list);
        writeStudentInfoToFile(list);
        
    }
    /**
     * 将ArrayList集合中排序后的结果利用PrintWriter流写入到
        E:\StudentInfo.txt文件中(写入格式：张三-男-25)
     * @param list
     * @throws IOException
     */
    private static void writeStudentInfoToFile(List<Student> list) throws IOException {
        PrintWriter pw = new PrintWriter(new File("StudentInfo.txt"));
        for(Student s : list) {
            pw.println(s.getName() + "-" + s.getGender() + "-" + s.getAge());
            pw.flush();
        }
        pw.close();
    }
    /**
     * 对ArrayList集合中的6个学生对象进行去重并按照年龄从小到大的顺序排序
     * @param list
     * @return
     */
    private static List<Student> sortStudent(List<Student> list) {
        //6个学生对象进行去重
        Set<Student> set = new HashSet<Student>();
        List<Student> stu = new ArrayList<Student>();
        set.addAll(list);
        //按照年龄从小到大的顺序排序
        TreeSet<Student> students = new TreeSet<Student>(new Comparator<Student>() {

            @Override
            public int compare(Student o1, Student o2) {
                
                return o1.getAge() < o2.getAge() ? -1 : 1;
            }
            
        });
        for(Student s : set) {
            students.add(s);
        }
        for(Student s : students) {
            stu.add(s);
        }
        return stu;
    }
    
    /**
     * 读取D:\StudentInfo.txt文件中的ArrayList对象
     * 对象的反序列化
     * @param list
     * @return
     * @throws IOException
     * @throws ClassNotFoundException
     */
    private static List<Student> readStudentInfo(List<Student> list) throws IOException, ClassNotFoundException {
        FileInputStream fis = new FileInputStream(new File("student.txt"));
        ObjectInputStream ois = new ObjectInputStream(fis);
        list = (List<Student>) ois.readObject();
        for(Student s : list) {
            System.out.println(s);
        }
        return list;
    }
    /**
     * 将存有6个学员信息的ArrayList集合对象写入到D:\StudentInfo.txt文件中
     * 对象的序列化
     * @param list
     * @throws IOException
     */
    private static void writeStudentInfo(List<Student> list) throws IOException {
        FileOutputStream fos = new FileOutputStream(new File("student.txt"));
        ObjectOutputStream os = new ObjectOutputStream(fos);
        os.writeObject(list);
        os.close();
        fos.close();
    }
    /**
     * 将学生信息添加到List集合中
     * 键盘录入6个学生信息
     * @param list
     * @return
     */
    private static List<Student> addStudentInfo(List<Student> list) {
        //键盘录入6个学员信息
        Scanner sc = new Scanner(System.in);
        for(int i = 0; i < 6; i++) {
            String personInfo = sc.next();
            String[] s = personInfo.split(",");
            Student student = new Student(s[0], s[1], Integer.parseInt(s[s.length-1]));
            list.add(student);
        }
        return list;
    }
}

2.用代码实现以下需求：
(1)已知配置文件config.properties中有三个键值对
name=zhangsan
score=80
address=beijing
(2)使用IO字节流对象和Properties类结合使用,将配置文件中的score键的值修改为100

/**
 * 2.用代码实现以下需求：
    (1)已知配置文件config.properties中有三个键值对
           name=zhangsan
           score=80
           address=beijing
    (2)使用IO字节流对象和Properties类结合使用,将配置文件中的score键的值修改为100
 * @author vanguard
 *
 */
public class Demo02 {
    public static void main(String[] args) throws IOException {
        Properties prop = new Properties();
        //创建字符输入流对象
        FileReader fr = new FileReader("config.properties");
        //流对象读取文件中的键值对,保存到集合
        prop.load(fr);
        //修改键为score的值为100
        prop.setProperty("score", "100");
        //创建字符输出流对象
        FileWriter fw = new FileWriter("config.properties");
        //接收所有的字符的输出流,将集合中的键值对,写回文件中保存
        prop.store(fw, "");
        //释放资源
        fw.close();
        fr.close();
    }
}

3.获取指定目录及子目录下所有txt文件的个数，并将这些txt文件复制到D盘下任意目录

/**
 * 3.获取指定目录及子目录下所有txt文件的个数，并将这些txt文件复制到D盘下任意目录
 * @author vanguard
 *
 */
public class Demo03 {
    public static void main(String[] args) {
        File src = new File("d:\TortoiseSVN");
        File dest = new File("d:\txt");
        //定义文件个数
        int count = 0;
        try {
            count = fileNum(src, dest, count);
        } catch (IOException e) {
            
            e.printStackTrace();
        }
        System.out.println("txt文件的个数为：" + count);
    }
    
    /**
     * 统计指定目录及子目录下所有txt文件的个数
     * @param src
     * @throws IOException 
     */
    private static int fileNum(File src, File dest, int count) throws IOException {
        //遍历目录下的文件及目录
        for(File f : src.listFiles()) {
            if(f.isDirectory()) {
                count = fileNum(f, dest, count);
            } else {
                //如果是文件，且以.txt结尾，文件个数加1，调用复制文件方法
                if(f.getName().endsWith(".txt")) {
                    count++;
                    copyFile(f, new File(dest, f.getName()));
                }
            }
        }
        return count;
    }

    /**
     * 复制文件
     * @param src
     * @param dest
     * @throws IOException
     */
    private static void copyFile(File src, File dest) throws IOException {
        //定义字符输入流缓冲流对象
        BufferedReader br = new BufferedReader(new FileReader(src));
        //打印流对象
        PrintWriter pw = new PrintWriter(new FileWriter(dest));
        //定义读取字符串
        String line = null;
        while(null != (line = br.readLine())) {
            pw.println(line);
            
        }
        //释放资源
        br.close();
        pw.close();
    }
}