IO流--练习

学生类

ackage cn.itcast.domain;

public class Student implements Comparable<Student>{

    private String name;
    private int cn,en,ma;
    private int sum;
    public Student() {
        super();
    }
    public Student(String name, int cn, int en, int ma) {
        super();
        this.name = name;
        this.cn = cn;
        this.en = en;
        this.ma = ma;
        this.sum = cn + en + ma;

    }



    @Override
    public int compareTo(Student o) {
        int temp = this.sum - o.sum;

        return temp==0?this.name.compareTo(o.name):temp;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + cn;
        result = prime * result + sum;
        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 (cn != other.cn)
            return false;
        if (sum != other.sum)
            return false;
        return true;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getCn() {
        return cn;
    }

    public void setCn(int cn) {
        this.cn = cn;
    }
    public int getEn() {
        return en;
    }
    public void setEn(int en) {
        this.en = en;
    }
    public int getMa() {
        return ma;
    }
    public void setMa(int ma) {
        this.ma = ma;
    }
    public int getSum() {
        return sum;
    }
    public void setSum(int sum) {
        this.sum = sum;
    }



    @Override
    public String toString() {
        return "Student [name=" + name + ", sum=" + sum + "]";
    }


}

删除一个带有内容的目录

public class Test2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // 2，请删除一个带有内容的目录。
        /*
         * 思路: 1，删除一个带有内容的目录原理；必须从里往外删。 2，到底有多级目录不确定，递归。
         */
        File dir = new File("E:\\test");

        // System.out.println(dir.delete());

        removeDir(dir);

    }

    /**
     * 删除一个目录。
     */
    public static void removeDir(File dir) {

        // 1,列出当前目录下的文件以及文件夹File[]
        File[] files = dir.listFiles();//如果目录是系统级文件夹，java没有访问权限，那么会返回null数组。最好加入判断。
        if (files != null) {
            // if(files.length == 0){
            // dir.delete();
            // return;
            // }

            for (File file : files) {

                // 2,对遍历到的file对象判断是否是目录。
                if (file.isDirectory()) {
                    removeDir(file);
                } else {
                    System.out.println(file + ":" + file.delete());// 删除文件。用打印语句验证是否删除成功，是否出现了误删操作。
                }
            }
        }
        System.out.println(dir + ":" + dir.delete());

    }
}

将学生对象(姓名，语文分数，数学分数，英语分数，总分)按照总分从高到低排序，★★★★★

并将姓名和从高到低总分写入文件中。

import cn.itcast.domain.Student;

public class Test4 {

    private static final String LINE_SEPARATOR = System.getProperty("line.separator");

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
//      4，将学生对象(姓名，语文分数，数学分数，英语分数，总分)按照总分从高到低排序，
//      并将姓名和从高到低总分写入文件中。
        /*
         * 思路：
         * 1，描述学生。
         * 2，既然要按照总分从高到低排序，学生多要存储集合，TreeSet。
         * 3，将信息具体的信息保存到文件中。
         *      操作文件,持久化存储，涉及了IO技术。而且是将数据存储到文件中。所以写入。输出流。
         * 
         */
        Set<Student> set = new TreeSet<Student>(Collections.reverseOrder());

        set.add(new Student("李四",20,20,20));
        set.add(new Student("旺财",10,10,20));
        set.add(new Student("小明",60,30,70));
        set.add(new Student("小红",80,90,80));
        set.add(new Student("小强",20,70,20));

        File dir = new File("tempfile");
        if(!dir.exists()){
            dir.mkdir();
        }
        File destFile = new File(dir,"student_info.txt");
        write2File(set,destFile);




    }

    public static void write2File(Set<Student> set, File destFile) throws IOException {

        //1, 创建输出流对象和目的文件关联。并创建目的文件。OutputStream操作文件 FileOutputStream。
        FileOutputStream fos = null;
        try{
            fos = new FileOutputStream(destFile);
            //2,遍历集合中的对象数据。将数据写入到指定文件中。

            for(Student stu : set){
                String info = stu.getName()+"\t"+stu.getSum()+LINE_SEPARATOR;
                //3,将数据写入到文件中。
                fos.write(info.getBytes());
            }
        }finally{
            if(fos!=null){

                //关闭资源。
                try {
                    fos.close();
                } catch (IOException e) {
                    throw new RuntimeException("系统资源关闭失败");
                }
            }
        }

    }

}

文件后缀名过滤器

public class FileFilterBySuffix implements FileFilter {

    private String suffix;

    public FileFilterBySuffix(String suffix) {
        super();
        this.suffix = suffix;
    }

    @Override
    public boolean accept(File pathname) {

        return pathname.getName().endsWith(suffix);
    }

}

建立一个java文件清单列表。★★★★★

public class Test5 {

    private static final String LINE_SEPARATOR = SeparatorTool.LINE_SEPARATOR;

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
//      5，获取指定目录下所有的.java文件(包含子目录中的)，
//      并将这些java文件的绝路路径写入到一个文件中。
//      建立一个java文件清单列表。
        /*
         * 思路：
         * 1，一看到包含子目录，必须递归。
         * 2，写数据到文件，输出流。
         * 3，继续分析，发现只要.java ，需要过滤器。
         * 4，满足过滤的条件的文件有可能非常多，先进行存储。
         */
        //被遍历的目录。
        File dir = new File("E:\\Java_Code");

        //明确一个过滤器。
        FileFilter filter = new FileFilterBySuffix(".java");


        //符合过滤器条件的文件有很多，最好先存储起来，然后在进行操作。
        List<File> list = new ArrayList<File>();
        //获取指定文件清单。
        getFileList(dir,filter,list);
//      System.out.println(list.size());

        File destFile = new File(dir,"javalist.txt");
        write2File(list,destFile);
    }

    /**
     * 将集合中的数据的绝对路径写入到文件中。
     * @param list
     * @param destFile
     * @throws IOException 
     */
    public static void write2File(List<File> list, File destFile) throws IOException {
        FileOutputStream fos = null;
        BufferedOutputStream bufos = null;
        try{
            fos = new FileOutputStream(destFile);
            bufos = new BufferedOutputStream(fos);

            for(File file : list){
                String info = file.getAbsolutePath()+LINE_SEPARATOR;
                bufos.write(info.getBytes());
                bufos.flush();//每写一个绝对路径就刷新一次。
            }
        }finally{
            if(bufos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    throw new RuntimeException("关闭失败");
                }
            }
        }

    }

    /**
     * 根据指定的过滤器在指定目录下获取所有的符合过滤条件的文件，并存储到list集合中。
     * @param dir
     * @param filter
     * @param list
     */
    public static void getFileList(File dir,FileFilter filter,List<File> list) {

        File[] files = dir.listFiles();

        for(File file : files){

            if(file.isDirectory()){
                getFileList(file,filter,list);
            }else{
                //如果是文件，传递到过滤器中去过滤。将满足条件存储起来。
                if(filter.accept(file)){
                    list.add(file);
                }
            }
        }

    }


}