IO流案例，集合到文件数据排序、复制单级和多级文件夹及复制文件的异常处理

灰太狼 2024-04-07 15:27 59阅读 0赞

**目录**

一、集合到文件数据排序

二、复制单级文件夹

三、复制多级文件夹

四、复制文件的异常处理

基本做法：

JDK7版本改进：

JDK9版本改进：

--------------------

## 一、集合到文件数据排序 ##

需求：

键盘录入5个学生信息（姓名,语文成绩,数学成绩,英语成绩），要求按照成绩总分从高到低写入文本文件

格式：姓名,语文成绩,数学成绩,英语成绩 举例：小玲,98,97100

分析步骤：

> ○ 定义学生类
> 
> ○ 创建TreeSet集合，通过比较器进行排序
> 
> ○ 键盘录入学生数据
> 
> ○ 创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量
> 
> ○ 把学生对象添加到TreeSet集合
> 
> ○ 创建字符缓冲输出流对象
> 
> ○ 遍历集合，得到每一个学生对象
> 
> ○ 把学生对象的数据拼接指定格式的字符串
> 
> ○ 调用字符缓冲输出流对象的方法写数据
> 
> ○ 释放资源

代码实现：

学生类

public class Student {
        // 姓名
        private String name;
        // 语文成绩
        private int chinese;
        // 数学成绩
        private int math;
        // 英语成绩
        private int english;
        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;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getChinese() {
            return chinese;
        }
        public void setChinese(int chinese) {
            this.chinese = chinese;
        }
        public int getMath() {
            return math;
        }
        public void setMath(int math) {
            this.math = math;
        }
        public int getEnglish() {
            return english;
        }
        public void setEnglish(int english) {
            this.english = english;
        }
        public int getSum() {
            return this.chinese + this.math + this.english;
        }
    }

测试 类：

public class TreeSetToFileDemo {
        public static void main(String[] args) throws IOException {
            //创建TreeSet集合，通过比较器排序进行排序 
            TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
                @Override
                public int compare(Student s1, Student s2) {
                    //成绩总分从高到低 
                    int num = s2.getSum() - s1.getSum();
                    //次要条件 
                    int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
                    int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2;
                    int num4 = num3 == 0 ? s1.getName().compareTo(s2.getName()) :
                            num3;
                    return num4;
                }
            });
            //键盘录入学生数据 
            for (int i = 0; i < 5; i++) {
                Scanner sc = new Scanner(System.in);
                System.out.println("请录入第" + (i + 1) + "个学生信息：");
                System.out.println("姓名：");
                String name = sc.nextLine();
                System.out.println("语文成绩：");
                int chinese = sc.nextInt();
                System.out.println("数学成绩：");
                int math = sc.nextInt();
                System.out.println("英语成绩：");
                int english = sc.nextInt();
                //创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量 
                Student s = new Student();
                s.setName(name);
                s.setChinese(chinese);
                s.setMath(math);
                s.setEnglish(english);
                //把学生对象添加到TreeSet集合 
                ts.add(s);
            }
            //创建字符缓冲输出流对象 
            BufferedWriter bw = new BufferedWriter(new
                    FileWriter("myCharStream\\ts.txt"));
            //遍历集合，得到每一个学生对象 
            for (Student s : ts) {
                //把学生对象的数据拼接成指定格式的字符串 
                //格式：姓名,语文成绩,数学成绩,英语成绩 
                StringBuilder sb = new StringBuilder();          
    
                sb.append(s.getName()).append(",").append(s.getChinese()).append(",")
     .append(s.getMath()).append(",").append(s.getEnglish()).append(",").append(s.getSum());
                // 调用字符缓冲输出流对象的方法写数据 
                bw.write(sb.toString());
                bw.newLine();
                bw.flush();
            }
            //释放资源 
            bw.close();
        }
    }

## 二、复制单级文件夹 ##

需求：

把“E:\\itcast”这个文件夹复制到模块目录下

步骤分析：

> 1、创建数据源目录File对象，路径是E:\\itcast
> 
> 2、获取数据源目录File对象的名称
> 
> 3、创建目的地目录File对象，路径由（模块名+第2步获取的名称）组成
> 
> 4、判断第3步创建的File是否存在，如果不存在，就创建
> 
> 5、获取数据源目录下所有文件的File数组
> 
> 6、遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件
> 
> 7、获取数据源文件File对象的名称
> 
> 8、创建目的地文件File对象，路径由于（目的地目录+第7步获取的名称）组成
> 
> 9、复制文件
> 
> 由于不清楚数据源目录下的文件都是什么类型的，所以采用字节流复制文件
> 
> 采用参数为File的构造方法

代码实现：

public class CopyFolderDemo {
        public static void main(String[] args) throws IOException {
            //创建数据源目录File对象，路径是E:\\itcast 
            File srcFolder = new File("E:\\itcast");
    
            //获取数据源目录File对象的名称(itcast) 
            String srcFolderName = srcFolder.getName();
    
            //创建目的地目录File对象，路径名是模块名+itcast组成(myCharStream\\itcast) 
            File destFolder = new File("myCharStream",srcFolderName);
    
            //判断目的地目录对应的File是否存在，如果不存在，就创建 
            if(!destFolder.exists()) {
                destFolder.mkdir();
            }
    
            //获取数据源目录下所有文件的File数组 
            File[] listFiles = srcFolder.listFiles();
    
            //遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件 
            for(File srcFile : listFiles) {
                //数据源文件：E:\\itcast\\mn.jpg 
                //获取数据源文件File对象的名称(mn.jpg) 
                String srcFileName = srcFile.getName();
                //创建目的地文件File对象，路径名是目的地目录+mn.jpg组成
                //(myCharStream\\itcast\\mn.jpg)
                File destFile = new File(destFolder,srcFileName);
                //复制文件 
                copyFile(srcFile,destFile);
            }
        }
    
        private static void copyFile(File srcFile, File destFile) throws IOException {
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));
    
            byte[] bys = new byte[1024];
            int len;
            while ((len=bis.read(bys))!=-1) {
                bos.write(bys,0,len);
            }
    
            bos.close();
            bis.close();
        }
    }

## 三、复制多级文件夹 ##

需求：

把“E:\\itcast”这个文件夹复制到 F盘目录下

步骤分析：

> 1、创建数据源File对象，路径是E:\\itcast
> 
> 2、创建目的地File对象，路径是F:\\
> 
> 3、写方法实现文件夹的复制，参数为数据源File对象和目的地File对象
> 
> 4、判断数据源File是否是文件
> 
> 是文件：直接复制，用字节流
> 
> 不是文件：在目的地下创建该目录，遍历获取该目录下所有文件的File数组，得到每一个File对象
> 
> 回到3继续(递归)

代码实现：

public class CopyFoldersDemo {
        public static void main(String[] args) throws IOException {
            //创建数据源File对象，路径是E:\\itcast 
            File srcFile = new File("E:\\itcast");
            //创建目的地File对象，路径是F:\\ 
            File destFile = new File("F:\\");
    
            //写方法实现文件夹的复制，参数为数据源File对象和目的地File对象 
            copyFolder(srcFile,destFile);
        }
    
        //复制文件夹 
        private static void copyFolder(File srcFile, File destFile) throws IOException {
            //判断数据源File是否是目录 
            if(srcFile.isDirectory()) {
                //在目的地下创建和数据源File名称一样的目录 
                String srcFileName = srcFile.getName();
                File newFolder = new File(destFile,srcFileName); //F:\\itcast 
                if(!newFolder.exists()) {
                    newFolder.mkdir();
                }
    
                //获取数据源File下所有文件或者目录的File数组 
                File[] fileArray = srcFile.listFiles();
    
                //遍历该File数组，得到每一个File对象 
                for(File file : fileArray) {
                    //把该File作为数据源File对象，递归调用复制文件夹的方法 
                    copyFolder(file,newFolder);
                }
            } else {
                //说明是文件，直接复制，用字节流 
                File newFile = new File(destFile,srcFile.getName());
                copyFile(srcFile,newFile);
            }
        }
    
        //字节缓冲流复制文件 
        private static void copyFile(File srcFile, File destFile) throws IOException {
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));
    
            byte[] bys = new byte[1024];
            int len;
            while ((len = bis.read(bys)) != -1) {
                bos.write(bys, 0, len);
            }
    
            bos.close();
            bis.close();
        }
    }

## 四、复制文件的异常处理 ##

### 基本做法： ###

public class CopyFileDemo {
        public static void main(String[] args) {
        }
        //try...catch...finally 
        private static void method2() {
            FileReader fr = null;
            FileWriter fw = null;
            try {
                fr = new FileReader("fr.txt");
                fw = new FileWriter("fw.txt");
                char[] chs = new char[1024];
                int len;
                while ((len = fr.read()) != -1) {
                    fw.write(chs, 0, len);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if(fw!=null) {
                    try {
                        fw.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(fr!=null) {
                    try {
                        fr.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        //抛出处理 
        private static void method1() throws IOException {
            FileReader fr = new FileReader("fr.txt");
            FileWriter fw = new FileWriter("fw.txt");
            char[] chs = new char[1024];
            int len;
            while ((len = fr.read()) != -1) {
                fw.write(chs, 0, len);
            }
            fw.close();
            fr.close();
        }
    }

### JDK7版本改进： ###

public class CopyFileDemo {
        public static void main(String[] args) {
        }
        //JDK7的改进方案 
        private static void method3() {
            try(FileReader fr = new FileReader("fr.txt");
                FileWriter fw = new FileWriter("fw.txt");){
                char[] chs = new char[1024];
                int len;
                while ((len = fr.read()) != -1) {
                    fw.write(chs, 0, len);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

### JDK9版本改进： ###

public class CopyFileDemo {
        public static void main(String[] args) {
        }
        //JDK9的改进方案 
        private static void method4() throws IOException {
            FileReader fr = new FileReader("fr.txt");
            FileWriter fw = new FileWriter("fw.txt");
            try(fr;fw){
                char[] chs = new char[1024];
                int len;
                while ((len = fr.read()) != -1) {
                    fw.write(chs, 0, len);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }