文件IO流案例

你的名字 2024-04-08 10:40 93阅读 0赞

#### 一、递归遍历目录【应用】 ####

*  案例需求
    
    给定一个路径(E:\\itcast)，通过递归完成遍历该目录下所有内容，并把所有文件的绝对路径输出在控制台
 *  代码实现

public class DiGuiDemo02 {
        public static void main(String[] args) {
            //根据给定的路径创建一个File对象
    //        File srcFile = new File("E:\\itcast");
            File srcFile = new File("E:\\itheima");
    
            //调用方法
            getAllFilePath(srcFile);
        }
    
        //定义一个方法，用于获取给定目录下的所有内容，参数为第1步创建的File对象
        public static void getAllFilePath(File srcFile) {
            //获取给定的File目录下所有的文件或者目录的File数组
            File[] fileArray = srcFile.listFiles();
            //遍历该File数组，得到每一个File对象
            if(fileArray != null) {
                for(File file : fileArray) {
                    //判断该File对象是否是目录
                    if(file.isDirectory()) {
                        //是：递归调用
                        getAllFilePath(file);
                    } else {
                        //不是：获取绝对路径输出在控制台
                        System.out.println(file.getAbsolutePath());
                    }
                }
            }
        }
    }

#### 二、字节流复制文本文件【应用】 ####

*  案例需求
    
    把“E:\\itcast\\窗里窗外.txt”复制到模块目录下的“窗里窗外.txt”
 *  实现步骤
    
     *  复制文本文件，其实就把文本文件的内容从一个文件中读取出来(数据源)，然后写入到另一个文件中(目的地)
     *  数据源：
        
        E:\\itcast\\窗里窗外.txt --- 读数据 --- InputStream --- FileInputStream
     *  目的地：
        
        myByteStream\\窗里窗外.txt --- 写数据 --- OutputStream --- FileOutputStream
 *  代码实现

public class CopyTxtDemo {
        public static void main(String[] args) throws IOException {
            //根据数据源创建字节输入流对象
            FileInputStream fis = new FileInputStream("E:\\itcast\\窗里窗外.txt");
            //根据目的地创建字节输出流对象
            FileOutputStream fos = new FileOutputStream("myByteStream\\窗里窗外.txt");
    
            //读写数据，复制文本文件(一次读取一个字节，一次写入一个字节)
            int by;
            while ((by=fis.read())!=-1) {
                fos.write(by);
            }
    
            //释放资源
            fos.close();
            fis.close();
        }
    }

#### 三、字节流复制图片【应用】 ####

*  案例需求
    
    把“E:\\itcast\\mn.jpg”复制到模块目录下的“mn.jpg”
 *  实现步骤
    
     *  根据数据源创建字节输入流对象
     *  根据目的地创建字节输出流对象
     *  读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
     *  释放资源
 *  代码实现

public class CopyJpgDemo {
        public static void main(String[] args) throws IOException {
            //根据数据源创建字节输入流对象
            FileInputStream fis = new FileInputStream("E:\\itcast\\mn.jpg");
            //根据目的地创建字节输出流对象
            FileOutputStream fos = new FileOutputStream("myByteStream\\mn.jpg");
    
            //读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
            byte[] bys = new byte[1024];
            int len;
            while ((len=fis.read(bys))!=-1) {
                fos.write(bys,0,len);
            }
    
            //释放资源
            fos.close();
            fis.close();
        }
    }

#### 四、字节流复制视频【应用】 ####

*  案例需求
    
    把“E:\\itcast\\字节流复制图片.avi”复制到模块目录下的“字节流复制图片.avi”
 *  实现步骤
    
     *  根据数据源创建字节输入流对象
     *  根据目的地创建字节输出流对象
     *  读写数据，复制视频
     *  释放资源
 *  代码实现

public class CopyAviDemo {
        public static void main(String[] args) throws IOException {
            //记录开始时间
            long startTime = System.currentTimeMillis();
    
            //复制视频
    //        method1();
    //        method2();
    //        method3();
            method4();
    
            //记录结束时间
            long endTime = System.currentTimeMillis();
            System.out.println("共耗时：" + (endTime - startTime) + "毫秒");
        }
    
        //字节缓冲流一次读写一个字节数组
        public static void method4() throws IOException {
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\itcast\\字节流复制图片.avi"));
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\字节流复制图片.avi"));
    
            byte[] bys = new byte[1024];
            int len;
            while ((len=bis.read(bys))!=-1) {
                bos.write(bys,0,len);
            }
    
            bos.close();
            bis.close();
        }
    
        //字节缓冲流一次读写一个字节
        public static void method3() throws IOException {
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\itcast\\字节流复制图片.avi"));
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\字节流复制图片.avi"));
    
            int by;
            while ((by=bis.read())!=-1) {
                bos.write(by);
            }
    
            bos.close();
            bis.close();
        }
    
    
        //基本字节流一次读写一个字节数组
        public static void method2() throws IOException {
            //E:\\itcast\\字节流复制图片.avi
            //模块目录下的 字节流复制图片.avi
            FileInputStream fis = new FileInputStream("E:\\itcast\\字节流复制图片.avi");
            FileOutputStream fos = new FileOutputStream("myByteStream\\字节流复制图片.avi");
    
            byte[] bys = new byte[1024];
            int len;
            while ((len=fis.read(bys))!=-1) {
                fos.write(bys,0,len);
            }
    
            fos.close();
            fis.close();
        }
    
        //基本字节流一次读写一个字节
        public static void method1() throws IOException {
            //E:\\itcast\\字节流复制图片.avi
            //模块目录下的 字节流复制图片.avi
            FileInputStream fis = new FileInputStream("E:\\itcast\\字节流复制图片.avi");
            FileOutputStream fos = new FileOutputStream("myByteStream\\字节流复制图片.avi");
    
            int by;
            while ((by=fis.read())!=-1) {
                fos.write(by);
            }
    
            fos.close();
            fis.close();
        }
    }

#### 五、字符流复制Java文件【应用】 ####

*  案例需求
    
    把模块目录下的“ConversionStreamDemo.java” 复制到模块目录下的“Copy.java”
 *  实现步骤
    
     *  根据数据源创建字符输入流对象
     *  根据目的地创建字符输出流对象
     *  读写数据，复制文件
     *  释放资源
 *  代码实现

public class CopyJavaDemo01 {
        public static void main(String[] args) throws IOException {
            //根据数据源创建字符输入流对象
            InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\ConversionStreamDemo.java"));
            //根据目的地创建字符输出流对象
            OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\Copy.java"));
    
            //读写数据，复制文件
            //一次读写一个字符数据
    //        int ch;
    //        while ((ch=isr.read())!=-1) {
    //            osw.write(ch);
    //        }
    
            //一次读写一个字符数组数据
            char[] chs = new char[1024];
            int len;
            while ((len=isr.read(chs))!=-1) {
                osw.write(chs,0,len);
            }
    
            //释放资源
            osw.close();
            isr.close();
        }
    }

#### 字符流复制Java文件改进版【应用】 ####

*  案例需求
    
    使用便捷流对象，把模块目录下的“ConversionStreamDemo.java” 复制到模块目录下的“Copy.java”
 *  实现步骤
    
     *  根据数据源创建字符输入流对象
     *  根据目的地创建字符输出流对象
     *  读写数据，复制文件
     *  释放资源
 *  代码实现

public class CopyJavaDemo02 {
        public static void main(String[] args) throws IOException {
            //根据数据源创建字符输入流对象
            FileReader fr = new FileReader("myCharStream\\ConversionStreamDemo.java");
            //根据目的地创建字符输出流对象
            FileWriter fw = new FileWriter("myCharStream\\Copy.java");
    
            //读写数据，复制文件
    //        int ch;
    //        while ((ch=fr.read())!=-1) {
    //            fw.write(ch);
    //        }
    
            char[] chs = new char[1024];
            int len;
            while ((len=fr.read(chs))!=-1) {
                fw.write(chs,0,len);
            }
    
            //释放资源
            fw.close();
            fr.close();
        }
    }

#### 六、字符缓冲流复制Java文件【应用】 ####

*  案例需求
    
    把模块目录下的ConversionStreamDemo.java 复制到模块目录下的 Copy.java
 *  实现步骤
    
     *  根据数据源创建字符缓冲输入流对象
     *  根据目的地创建字符缓冲输出流对象
     *  读写数据，复制文件，使用字符缓冲流特有功能实现
     *  释放资源
 *  代码实现

public class CopyJavaDemo01 {
        public static void main(String[] args) throws IOException {
            //根据数据源创建字符缓冲输入流对象
            BufferedReader br = new BufferedReader(new FileReader("myCharStream\\ConversionStreamDemo.java"));
            //根据目的地创建字符缓冲输出流对象
            BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\Copy.java"));
    
            //读写数据，复制文件
            //一次读写一个字符数据
    //        int ch;
    //        while ((ch=br.read())!=-1) {
    //            bw.write(ch);
    //        }
    
            //一次读写一个字符数组数据
            char[] chs = new char[1024];
            int len;
            while ((len=br.read(chs))!=-1) {
                bw.write(chs,0,len);
            }
    
            //释放资源
            bw.close();
            br.close();
        }
    }

#### 字符缓冲流特有功能复制Java文件【应用】 ####

*  案例需求
    
    使用特有功能把模块目录下的ConversionStreamDemo.java 复制到模块目录下的 Copy.java
 *  实现步骤
    
     *  根据数据源创建字符缓冲输入流对象
     *  根据目的地创建字符缓冲输出流对象
     *  读写数据，复制文件，使用字符缓冲流特有功能实现
     *  释放资源
 *  代码实现

public class CopyJavaDemo02 {
        public static void main(String[] args) throws IOException {
            //根据数据源创建字符缓冲输入流对象
            BufferedReader br = new BufferedReader(new FileReader("myCharStream\\ConversionStreamDemo.java"));
            //根据目的地创建字符缓冲输出流对象
            BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\Copy.java"));
    
            //读写数据，复制文件
            //使用字符缓冲流特有功能实现
            String line;
            while ((line=br.readLine())!=null) {
                bw.write(line);
                bw.newLine();
                bw.flush();
            }
    
            //释放资源
            bw.close();
            br.close();
        }
    }

#### 七、集合到文件【应用】 ####

*  案例需求
    
    把文本文件中的数据读取到集合中，并遍历集合。要求：文件中每一行数据是一个集合元素
 *  实现步骤
    
     *  创建字符缓冲输入流对象
     *  创建ArrayList集合对象
     *  调用字符缓冲输入流对象的方法读数据
     *  把读取到的字符串数据存储到集合中
     *  释放资源
     *  遍历集合
 *  代码实现

public class TxtToArrayListDemo {
        public static void main(String[] args) throws IOException {
            //创建字符缓冲输入流对象
            BufferedReader br = new BufferedReader(new FileReader("myCharStream\\array.txt"));
    
            //创建ArrayList集合对象
            ArrayList<String> array = new ArrayList<String>();
    
            //调用字符缓冲输入流对象的方法读数据
            String line;
            while ((line=br.readLine())!=null) {
                //把读取到的字符串数据存储到集合中
                array.add(line);
            }
            //释放资源
            br.close();
            //遍历集合
            for(String s : array) {
                System.out.println(s);
            }
        }
    }

#### 文件到集合【应用】 ####

*  案例需求
    
    把ArrayList集合中的字符串数据写入到文本文件。要求：每一个字符串元素作为文件中的一行数据
 *  实现步骤
    
     *  创建ArrayList集合
     *  往集合中存储字符串元素
     *  创建字符缓冲输出流对象
     *  遍历集合，得到每一个字符串数据
     *  调用字符缓冲输出流对象的方法写数据
     *  释放资源
 *  代码实现

public class ArrayListToTxtDemo {
        public static void main(String[] args) throws IOException {
            //创建ArrayList集合
            ArrayList<String> array = new ArrayList<String>();
    
            //往集合中存储字符串元素
            array.add("hello");
            array.add("world");
            array.add("java");
    
            //创建字符缓冲输出流对象
            BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\array.txt"));
    
            //遍历集合，得到每一个字符串数据
            for(String s : array) {
                //调用字符缓冲输出流对象的方法写数据
                bw.write(s);
                bw.newLine();
                bw.flush();
            }
    
            //释放资源
            bw.close();
        }
    }

#### 点名器【应用】 ####

*  案例需求
    
    我有一个文件里面存储了班级同学的姓名，每一个姓名占一行，要求通过程序实现随点名器
 *  实现步骤
    
     *  创建字符缓冲输入流对象
     *  创建ArrayList集合对象
     *  调用字符缓冲输入流对象的方法读数据
     *  把读取到的字符串数据存储到集合中
     *  释放资源
     *  使用Random产生一个随机数，随机数的范围在：\[0,集合的长度)
     *  把第6步产生的随机数作为索引到ArrayList集合中获取值
     *  把第7步得到的数据输出在控制台
 *  代码实现

public class CallNameDemo {
        public static void main(String[] args) throws IOException {
            //创建字符缓冲输入流对象
            BufferedReader br = new BufferedReader(new FileReader("myCharStream\\names.txt"));
    
            //创建ArrayList集合对象
            ArrayList<String> array = new ArrayList<String>();
    
            //调用字符缓冲输入流对象的方法读数据
            String line;
            while ((line=br.readLine())!=null) {
                //把读取到的字符串数据存储到集合中
                array.add(line);
            }
    
            //释放资源
            br.close();
    
            //使用Random产生一个随机数，随机数的范围在：[0,集合的长度)
            Random r = new Random();
            int index = r.nextInt(array.size());
    
            //把第6步产生的随机数作为索引到ArrayList集合中获取值
            String name = array.get(index);
    
            //把第7步得到的数据输出在控制台
            System.out.println("幸运者是：" + name);
        }
    }

#### 集合到文件改进版【应用】 ####

*  案例需求
    
    把ArrayList集合中的学生数据写入到文本文件。要求：每一个学生对象的数据作为文件中的一行数据 格式：学号,姓名,年龄,居住地 举例：itheima001,林青霞,30,西安
 *  实现步骤
    
     *  定义学生类
     *  创建ArrayList集合
     *  创建学生对象
     *  把学生对象添加到集合中
     *  创建字符缓冲输出流对象
     *  遍历集合，得到每一个学生对象
     *  把学生对象的数据拼接成指定格式的字符串
     *  调用字符缓冲输出流对象的方法写数据
     *  释放资源
 *  代码实现
    
     *  学生类

public class Student {
        private String sid;
        private String name;
        private int age;
        private String address;
    
        public Student() {
        }
    
        public Student(String sid, String name, int age, String address) {
            this.sid = sid;
            this.name = name;
            this.age = age;
            this.address = address;
        }
    
        public String getSid() {
            return sid;
        }
    
        public void setSid(String sid) {
            this.sid = sid;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    }

测试类

public class ArrayListToFileDemo {
        public static void main(String[] args) throws IOException {
            //创建ArrayList集合
            ArrayList<Student> array = new ArrayList<Student>();
    
            //创建学生对象
            Student s1 = new Student("itheima001", "林青霞", 30, "西安");
            Student s2 = new Student("itheima002", "张曼玉", 35, "武汉");
            Student s3 = new Student("itheima003", "王祖贤", 33, "郑州");
    
            //把学生对象添加到集合中
            array.add(s1);
            array.add(s2);
            array.add(s3);
    
            //创建字符缓冲输出流对象
            BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\students.txt"));
    
            //遍历集合，得到每一个学生对象
            for (Student s : array) {
                //把学生对象的数据拼接成指定格式的字符串
                StringBuilder sb = new StringBuilder();
                sb.append(s.getSid()).append(",").append(s.getName()).append(",").append(s.getAge()).append(",").append(s.getAddress());
    
                //调用字符缓冲输出流对象的方法写数据
                bw.write(sb.toString());
                bw.newLine();
                bw.flush();
            }
    
            //释放资源
            bw.close();
        }
    }

#### 文件到集合改进版【应用】 ####

*  案例需求
    
    把文本文件中的数据读取到集合中，并遍历集合。要求：文件中每一行数据是一个学生对象的成员变量值 举例：itheima001,林青霞,30,西安
 *  实现步骤
    
     *  定义学生类
     *  创建字符缓冲输入流对象
     *  创建ArrayList集合对象
     *  调用字符缓冲输入流对象的方法读数据
     *  把读取到的字符串数据用split()进行分割，得到一个字符串数组
     *  创建学生对象
     *  把字符串数组中的每一个元素取出来对应的赋值给学生对象的成员变量值
     *  把学生对象添加到集合
     *  释放资源
     *  遍历集合
 *  代码实现
    
     *  学生类
        
        同上
     *  测试类

public class FileToArrayListDemo {
        public static void main(String[] args) throws IOException {
            //创建字符缓冲输入流对象
            BufferedReader br = new BufferedReader(new FileReader("myCharStream\\students.txt"));
    
            //创建ArrayList集合对象
            ArrayList<Student> array = new ArrayList<Student>();
    
            //调用字符缓冲输入流对象的方法读数据
            String line;
            while ((line = br.readLine()) != null) {
                //把读取到的字符串数据用split()进行分割，得到一个字符串数组
                String[] strArray = line.split(",");
    
                //创建学生对象
                Student s = new Student();
                //把字符串数组中的每一个元素取出来对应的赋值给学生对象的成员变量值
                //itheima001,林青霞,30,西安
                s.setSid(strArray[0]);
                s.setName(strArray[1]);
                s.setAge(Integer.parseInt(strArray[2]));
                s.setAddress(strArray[3]);
    
                //把学生对象添加到集合
                array.add(s);
            }
    
            //释放资源
            br.close();
    
            //遍历集合
            for (Student s : array) {
                System.out.println(s.getSid() + "," + s.getName() + "," + s.getAge() + "," + s.getAddress());
            }
        }
    }

#### 八、IO流案例 ####

#### 集合到文件数据排序改进版【应用】 ####

案例需求

*  键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)。要求按照成绩总分从高到低写入文本文件
 *  格式：姓名,语文成绩,数学成绩,英语成绩 举例：林青霞,98,99,100

分析步骤

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

代码实现

*  学生类

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();
            }
        }
    }

#### 九、复制Java文件打印流改进版【应用】 ####

*  案例需求
    
     *  把模块目录下的PrintStreamDemo.java 复制到模块目录下的 Copy.java
 *  分析步骤
    
     *  根据数据源创建字符输入流对象
     *  根据目的地创建字符输出流对象
     *  读写数据，复制文件
     *  释放资源
 *  代码实现

public class CopyJavaDemo {
        public static void main(String[] args) throws IOException {
            /*
            //根据数据源创建字符输入流对象
            BufferedReader br = new BufferedReader(new FileReader("myOtherStream\\PrintStreamDemo.java"));
            //根据目的地创建字符输出流对象
            BufferedWriter bw = new BufferedWriter(new FileWriter("myOtherStream\\Copy.java"));
    
            //读写数据，复制文件
            String line;
            while ((line=br.readLine())!=null) {
                bw.write(line);
                bw.newLine();
                bw.flush();
            }
    
            //释放资源
            bw.close();
            br.close();
            */
    
            //根据数据源创建字符输入流对象
            BufferedReader br = new BufferedReader(new FileReader("myOtherStream\\PrintStreamDemo.java"));
            //根据目的地创建字符输出流对象
            PrintWriter pw = new PrintWriter(new FileWriter("myOtherStream\\Copy.java"),true);
    
            //读写数据，复制文件
            String line;
            while ((line=br.readLine())!=null) {
                pw.println(line);
            }
    
            //释放资源
            pw.close();
            br.close();
        }
    }

#### 十、游戏次数案例【应用】 ####

*  案例需求
    
     *  实现猜数字小游戏只能试玩3次，如果还想玩，提示：游戏试玩已结束，想玩请充值(www.itcast.cn)
 *  分析步骤
    
    1.  写一个游戏类，里面有一个猜数字的小游戏
    2.  写一个测试类，测试类中有main()方法，main()方法中写如下代码：
        
        从文件中读取数据到Properties集合，用load()方法实现
        
            文件已经存在：game.txt
            
                里面有一个数据值：count=0
        
        通过Properties集合获取到玩游戏的次数
        
        判断次数是否到到3次了
        
            如果到了，给出提示：游戏试玩已结束，想玩请充值(www.itcast.cn)
            
                如果不到3次：
            
                    次数+1，重新写回文件，用Properties的store()方法实现玩游戏
 *  代码实现

public class PropertiesTest {
        public static void main(String[] args) throws IOException {
            //从文件中读取数据到Properties集合，用load()方法实现
            Properties prop = new Properties();
    
            FileReader fr = new FileReader("myOtherStream\\game.txt");
            prop.load(fr);
            fr.close();
    
            //通过Properties集合获取到玩游戏的次数
            String count = prop.getProperty("count");
            int number = Integer.parseInt(count);
    
            //判断次数是否到到3次了
            if(number >= 3) {
                //如果到了，给出提示：游戏试玩已结束，想玩请充值(www.itcast.cn)
                System.out.println("游戏试玩已结束，想玩请充值(www.itcast.cn)");
            } else {
                //玩游戏
                GuessNumber.start();
    
                //次数+1，重新写回文件，用Properties的store()方法实现
                number++;
                prop.setProperty("count",String.valueOf(number));
                FileWriter fw = new FileWriter("myOtherStream\\game.txt");
                prop.store(fw,null);
                fw.close();
            }
        }
    }