Java笔记(20)：IO流(02)

/*
 * 递归：方法定义中调用方法本身的现象
 * 
 * 方法的嵌套调用，这不是递归。
 * Math.max(Math.max(a,b),c);
 * 
 * public void show(int n) {
 *         if(n <= 0) {
 *             System.exit(0);
 *         }
 *         System.out.println(n);
 *         show(--n);
 * }
 * 
 * 注意事项：
 *         A:递归一定要有出口，否则就是死递归
 *         B:递归的次数不能太多，否则就内存溢出
 *         C:构造方法不能递归使用
 */

 1 package cn.itcast_02;
 2 
 3 /*
 4  * 需求：请用代码实现求5的阶乘。
 5  * 下面的知识要知道：
 6  *         5! = 1*2*3*4*5
 7  *         5! = 5*4!
 8  * 
 9  * 有几种方案实现呢?
10  *         A:循环实现
11  *         B:递归实现
12  *             a:做递归要写一个方法
13  *             b:出口条件
14  *             c:规律
15  */
16 public class DiGuiDemo {
17     public static void main(String[] args) {
18         int jc = 1;
19         for (int x = 2; x <= 5; x++) {
20             jc *= x;
21         }
22         System.out.println("5的阶乘是：" + jc);
23         
24         System.out.println("5的阶乘是："+jieCheng(5));
25     }
26     
27     /*
28      * 做递归要写一个方法:
29      *         返回值类型：int
30      *         参数列表：int n
31      * 出口条件:
32      *         if(n == 1) {return 1;}
33      * 规律:
34      *         if(n != 1) {return n*方法名(n-1);}
35      */
36     public static int jieCheng(int n){
37         if(n==1){
38             return 1;
39         }else {
40             return n*jieCheng(n-1);
41         }
42     }
43 }

 1 package cn.itcast_02;
 2 
 3 /*
 4  * 有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？
 5  * 分析：我们要想办法找规律
 6  *             兔子对数
 7  * 第一个月：     1
 8  * 第二个月：    1
 9  * 第三个月：    2
10  * 第四个月：    3    
11  * 第五个月：    5
12  * 第六个月：    8
13  * ...
14  * 
15  * 由此可见兔子对象的数据是：
16  *         1,1,2,3,5,8...
17  * 规则：
18  *         A:从第三项开始，每一项是前两项之和
19  *         B:而且说明前两项是已知的
20  * 
21  * 如何实现这个程序呢?
22  *         A:数组实现
23  *         B:变量的变化实现
24  *         C:递归实现
25  * 
26  * 假如相邻的两个月的兔子对数是a,b
27  * 第一个相邻的数据：a=1,b=1
28  * 第二个相邻的数据：a=1,b=2
29  * 第三个相邻的数据：a=2,b=3
30  * 第四个相邻的数据：a=3,b=5
31  * 看到了：下一次的a是以前的b，下一次是以前的a+b    
32  */
33 public class DiGuiDemo2 {
34     public static void main(String[] args) {
35         // 定义一个数组
36         int[] arr = new int[20];
37         arr[0] = 1;
38         arr[1] = 1;
39         // arr[2] = arr[0] + arr[1];
40         // arr[3] = arr[1] + arr[2];
41         // ...
42         for (int x = 2; x < arr.length; x++) {
43             arr[x] = arr[x - 2] + arr[x - 1];
44         }
45         System.out.println(arr[19]);// 6765
46         System.out.println("----------------");
47 
48         int a = 1;
49         int b = 1;
50         for (int x = 0; x < 18; x++) {
51             // 临时变量存储上一次的a
52             int temp = a;
53             a = b;
54             b = temp + b;
55         }
56         System.out.println(b);
57         System.out.println("----------------");
58 
59         System.out.println(fib(20));
60     }
61 
62     /*
63      * 方法： 返回值类型：int 参数列表：int n 出口条件： 第一个月是1，第二个月是1 规律： 从第三个月开始，每一个月是前两个月之和
64      */
65     public static int fib(int n) {
66         if (n == 1 || n == 2) {
67             return 1;
68         } else {
69             return fib(n - 1) + fib(n - 2);
70         }
71     }
72 }

 1 package cn.itcast_03;
 2 
 3 import java.io.File;
 4 
 5 /*
 6  * 需求：请大家把E:\JavaSE目录下所有的java结尾的文件的绝对路径给输出在控制台。
 7  * 
 8  * 分析：
 9  *         A:封装目录
10  *         B:获取该目录下所有的文件或者文件夹的File数组
11  *         C:遍历该File数组，得到每一个File对象
12  *         D:判断该File对象是否是文件夹
13  *             是：回到B
14  *             否：继续判断是否以.java结尾
15  *                 是：就输出该文件的绝对路径
16  *                 否：不搭理它
17  */
18 public class FilePathDemo {
19     public static void main(String[] args) {
20         // 封装目录
21         File srcFolder = new File("E:\\JavaSE");
22 
23         // 递归功能实现
24         getAllJavaFilePaths(srcFolder);
25     }
26 
27     private static void getAllJavaFilePaths(File srcFolder) {
28         // 获取该目录下所有的文件或者文件夹的File数组
29         File[] fileArray = srcFolder.listFiles();
30 
31         // 遍历该File数组，得到每一个File对象
32         for (File file : fileArray) {
33             // 判断该File对象是否是文件夹
34             if (file.isDirectory()) {
35                 getAllJavaFilePaths(file);
36             } else {
37                 // 继续判断是否以.java结尾
38                 if (file.getName().endsWith(".java")) {
39                     // 就输出该文件的绝对路径
40                     System.out.println(file.getAbsolutePath());
41                 }
42             }
43         }
44     }
45 }

 1 package cn.itcast_03;
 2 
 3 import java.io.File;
 4 
 5 /*
 6  * 需求：递归删除带内容的目录
 7  * 
 8  * 目录我已经给定：demo
 9  * 
10  * 分析：
11  *         A:封装目录
12  *         B:获取该目录下的所有文件或者文件夹的File数组
13  *         C:遍历该File数组，得到每一个File对象
14  *         D:判断该File对象是否是文件夹
15  *             是：回到B
16  *             否：就删除
17  */
18 public class FileDeleteDemo {
19     public static void main(String[] args) {
20         // 封装目录
21         File srcFolder = new File("demo");
22         // 递归实现
23         deleteFolder(srcFolder);
24     }
25 
26     private static void deleteFolder(File srcFolder) {
27         // 获取该目录下的所有文件或者文件夹的File数组
28         File[] fileArray = srcFolder.listFiles();
29 
30         if (fileArray != null) {
31             // 遍历该File数组，得到每一个File对象
32             for (File file : fileArray) {
33                 // 判断该File对象是否是文件夹
34                 if (file.isDirectory()) {
35                     deleteFolder(file);
36                 } else {
37                     System.out.println(file.getName() + "---" + file.delete());
38                 }
39             }
40 
41             System.out
42                     .println(srcFolder.getName() + "---" + srcFolder.delete());
43         }
44     }
45 }

 1 package cn.itcast_01;
 2 
 3 import java.io.File;
 4 import java.io.FileNotFoundException;
 5 import java.io.FileOutputStream;
 6 import java.io.IOException;
 7 
 8 /*
 9  * IO流的分类：
10  *         流向：
11  *             输入流    读取数据
12  *             输出流 写出数据
13  *         数据类型：
14  *             字节流
15  *                 字节输入流    读取数据    InputStream
16  *                 字节输出流    写出数据    OutputStream
17  *             字符流
18  *                 字符输入流    读取数据    Reader
19  *                 字符输出流    写出数据    Writer
20  * 
21  *         注意：一般我们在探讨IO流的时候，如果没有明确说明按哪种分类来说，默认情况下是按照数据类型来分的。
22  * 
23  * 需求：我要往一个文本文件中输入一句话："hello,io"
24  * 
25  * 分析：
26  *         A:这个操作最好是采用字符流来做，但是呢，字符流是在字节流之后才出现的，所以，今天我先讲解字节流如何操作。
27  *         B:由于我是要往文件中写一句话，所以我们要采用字节输出流。
28  * 
29  * 通过上面的分析后我们知道要使用：OutputStream
30  * 但是通过查看API，我们发现该流对象是一个抽象类，不能实例化。
31  * 所以，我们要找一个具体的子类。
32  * 而我们要找的子类是什么名字的呢?这个时候，很简单，我们回想一下，我们是不是要往文件中写东西。
33  * 文件是哪个单词：File
34  * 然后用的是字节输出流，联起来就是：FileOutputStream
35  * 注意：每种基类的子类都是以父类名作为后缀名。
36  *         XxxOutputStream
37  *         XxxInputStream
38  *         XxxReader
39  *         XxxWriter
40  * 查看FileOutputStream的构造方法：
41  *         FileOutputStream(File file) 
42  *        FileOutputStream(String name)
43  *
44  * 字节输出流操作步骤：
45  *         A:创建字节输出流对象
46  *         B:写数据
47  *         C:释放资源
48  */
49 public class FileOutputStreamDemo {
50     public static void main(String[] args) throws IOException {
51         // 创建字节输出流对象
52         // FileOutputStream(File file)
53         // File file = new File("fos.txt");
54         // FileOutputStream fos = new FileOutputStream(file);
55         // FileOutputStream(String name)
56         FileOutputStream fos = new FileOutputStream("fos.txt");
57         /*
58          * 创建字节输出流对象了做了几件事情：
59          * A:调用系统功能去创建文件
60          * B:创建fos对象
61          * C:把fos对象指向这个文件
62          */
63         
64         //写数据
65         fos.write("hello,IO".getBytes());
66         fos.write("java".getBytes());
67         
68         //释放资源
69         //关闭此文件输出流并释放与此流有关的所有系统资源。
70         fos.close();
71         /*
72          * 为什么一定要close()呢?
73          * A:让流对象变成垃圾，这样就可以被垃圾回收器回收了
74          * B:通知系统去释放跟该文件相关的资源
75          */
76         //java.io.IOException: Stream Closed
77         //fos.write("java".getBytes());
78     }
79 }

 1 package cn.itcast_01;
 2 
 3 import java.io.FileOutputStream;
 4 import java.io.IOException;
 5 
 6 /*
 7  * 字节输出流操作步骤：
 8  * A:创建字节输出流对象
 9  * B:调用write()方法
10  * C:释放资源
11  * 
12  * public void write(int b):写一个字节
13  * public void write(byte[] b):写一个字节数组
14  * public void write(byte[] b,int off,int len):写一个字节数组的一部分
15  */
16 public class FileOutputStreamDemo2 {
17     public static void main(String[] args) throws IOException {
18         // 创建字节输出流对象
19         // OutputStream os = new FileOutputStream("fos2.txt"); // 多态
20         FileOutputStream fos = new FileOutputStream("fos2.txt");
21 
22         // 调用write()方法
23         //fos.write(97); //97 -- 底层二进制数据    -- 通过记事本打开 -- 找97对应的字符值 -- a
24         // fos.write(57);
25         // fos.write(55);
26         
27         //public void write(byte[] b):写一个字节数组
28         byte[] bys={97,98,99,100,101};
29         fos.write(bys);
30         
31         //public void write(byte[] b,int off,int len):写一个字节数组的一部分
32         fos.write(bys,1,3);
33         
34         //释放资源
35         fos.close();
36     }
37 }

 1 package cn.itcast_01;
 2 
 3 import java.io.FileOutputStream;
 4 import java.io.IOException;
 5 
 6 /*
 7  * 如何实现数据的换行?
 8  *         为什么现在没有换行呢?因为你值写了字节数据，并没有写入换行符号。
 9  *         如何实现呢?写入换行符号即可呗。
10  *         刚才我们看到了有写文本文件打开是可以的，通过windows自带的那个不行，为什么呢?
11  *         因为不同的系统针对不同的换行符号识别是不一样的?
12  *         windows:\r\n
13  *         linux:\n
14  *         Mac:\r
15  *         而一些常见的个高级记事本，是可以识别任意换行符号的。
16  * 
17  * 如何实现数据的追加写入?
18  *         用构造方法带第二个参数是true的情况即可
19  */
20 public class FileOutputStreamDemo3 {
21     public static void main(String[] args) throws IOException {
22         // 创建字节输出流对象
23         // FileOutputStream fos = new FileOutputStream("fos3.txt");
24         // 创建一个向具有指定 name 的文件中写入数据的输出文件流。如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。
25         FileOutputStream fos = new FileOutputStream("fos3.txt", true);
26 
27         // 写数据
28         for (int x = 0; x < 10; x++) {
29             fos.write(("hello" + x).getBytes());
30             fos.write("\r\n".getBytes());
31         }
32 
33         // 释放资源
34         fos.close();
35     }
36 }

 1 package cn.itcast_01;
 2 
 3 import java.io.FileNotFoundException;
 4 import java.io.FileOutputStream;
 5 import java.io.IOException;
 6 
 7 /*
 8  * 加入异常处理的字节输出流操作
 9  */
10 public class FileOutputStreamDemo4 {
11     public static void main(String[] args) {
12         // 分开做异常处理
13         // FileOutputStream fos = null;
14         // try {
15         // fos = new FileOutputStream("fos4.txt");
16         // } catch (FileNotFoundException e) {
17         // e.printStackTrace();
18         // }
19         //
20         // try {
21         // fos.write("java".getBytes());
22         // } catch (IOException e) {
23         // e.printStackTrace();
24         // }
25         //
26         // try {
27         // fos.close();
28         // } catch (IOException e) {
29         // e.printStackTrace();
30         // }
31 
32         // 一起做异常处理
33         // try {
34         // FileOutputStream fos = new FileOutputStream("fos4.txt");
35         // fos.write("java".getBytes());
36         // fos.close();
37         // } catch (FileNotFoundException e) {
38         // e.printStackTrace();
39         // } catch (IOException e) {
40         // e.printStackTrace();
41         // }
42 
43         // 改进版
44         // 为了在finally里面能够看到该对象就必须定义到外面，为了访问不出问题，还必须给初始化值
45         FileOutputStream fos = null;
46         try {
47             // fos = new FileOutputStream("z:\\fos4.txt");
48             fos = new FileOutputStream("fos4.txt");
49             fos.write("java".getBytes());
50         } catch (FileNotFoundException e) {
51             e.printStackTrace();
52         } catch (IOException e) {
53             e.printStackTrace();
54         } finally {
55             // 如果fos不是null，才需要close()
56             if (fos != null) {
57                 // 为了保证close()一定会执行，就放到这里了
58                 try {
59                     fos.close();
60                 } catch (IOException e) {
61                     e.printStackTrace();
62                 }
63             }
64         }
65     }
66 }

 1 package cn.itcast_02;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.IOException;
 5 
 6 /*
 7  * 字节输入流操作步骤：
 8  * A:创建字节输入流对象
 9  * B:调用read()方法读取数据，并把数据显示在控制台
10  * C:释放资源
11  * 
12  * 读取数据的方式：
13  * A:int read():一次读取一个字节
14  * B:int read(byte[] b):一次读取一个字节数组
15  */
16 public class FileInputStreamDemo {
17     public static void main(String[] args) throws IOException {
18         // FileInputStream(String name)
19         // FileInputStream fis = new FileInputStream("fis.txt");
20         FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");
21 
22         // // 调用read()方法读取数据，并把数据显示在控制台
23         // // 第一次读取
24         // int by = fis.read();
25         // System.out.println(by);
26         // System.out.println((char) by);
27         //
28         // // 第二次读取
29         // by = fis.read();
30         // System.out.println(by);
31         // System.out.println((char) by);
32         //
33         // // 第三次读取
34         // by = fis.read();
35         // System.out.println(by);
36         // System.out.println((char) by);
37         // // 我们发现代码的重复度很高，所以我们要用循环改进
38         // // 而用循环，最麻烦的事情是如何控制循环判断条件呢?
39         // // 第四次读取
40         // by = fis.read();
41         // System.out.println(by);
42         // // 第五次读取
43         // by = fis.read();
44         // System.out.println(by);
45         // //通过测试，我们知道如果你读取的数据是-1，就说明已经读取到文件的末尾了
46 
47         // 用循环改进
48         // int by = fis.read();
49         // while (by != -1) {
50         // System.out.print((char) by);
51         // by = fis.read();
52         // }
53 
54         // 最终版代码
55         int by = 0;
56         // 读取，赋值，判断
57         while ((by = fis.read()) != -1) {
58             System.out.print((char) by);
59         }
60 
61         // 释放资源
62         fis.close();
63     }
64 }

 1 package cn.itcast_03;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.FileOutputStream;
 5 import java.io.IOException;
 6 
 7 /*
 8  * 复制文本文件。
 9  * 
10  * 数据源：从哪里来
11  * a.txt    --    读取数据    --    FileInputStream    
12  * 
13  * 目的地：到哪里去
14  * b.txt    --    写数据        --    FileOutputStream
15  * 
16  * java.io.FileNotFoundException: a.txt (系统找不到指定的文件。)
17  * 
18  * 这一次复制中文没有出现任何问题，为什么呢?
19  * 上一次我们出现问题的原因在于我们每次获取到一个字节数据，就把该字节数据转换为了字符数据，然后输出到控制台。
20  * 而这一次呢?确实通过IO流读取数据，写到文本文件，你读取一个字节，我就写入一个字节，你没有做任何的转换。
21  * 它会自己做转换。
22  */
23 public class CopyFileDemo {
24     public static void main(String[] args) throws IOException {
25         // 封装数据源
26         FileInputStream fis = new FileInputStream("a.txt");
27         // 封装目的地
28         FileOutputStream fos = new FileOutputStream("b.txt");
29 
30         int by = 0;
31         while ((by = fis.read()) != -1) {
32             fos.write(by);
33         }
34 
35         // 释放资源(先关谁都行)
36         fos.close();
37         fis.close();
38     }
39 }

 1 package cn.itcast_03;
 2 
 3 import java.util.Arrays;
 4 
 5 /*
 6  * 计算机是如何识别什么时候该把两个字节转换为一个中文呢?
 7  * 在计算机中中文的存储分两个字节：
 8  *         第一个字节肯定是负数。
 9  *         第二个字节常见的是负数，可能有正数。但是没影响。
10  */
11 public class StringDemo {
12     public static void main(String[] args) {
13         // String s = "abcde";
14         // // [97, 98, 99, 100, 101]
15 
16         String s = "我爱你烨儿";
17         // [-50, -46, -80, -82, -60, -29, -20, -57, -74, -7]
18 
19         byte[] bys = s.getBytes();
20         System.out.println(Arrays.toString(bys));
21     }
22 }

 1 package cn.itcast_03;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.FileOutputStream;
 5 import java.io.IOException;
 6 
 7 /*
 8  * 需求：把e:\\林青霞.jpg内容复制到当前项目目录下的mn.jpg中
 9  * 
10  * 数据源：
11  *         e:\\林青霞.jpg    --读取数据--FileInputStream
12  * 目的地：
13  *         mn.jpg--写出数据--FileOutputStream
14  */
15 public class CopyImageDemo {
16     public static void main(String[] args) throws IOException {
17         // 封装数据源
18         FileInputStream fis = new FileInputStream("e:\\林青霞.jpg");
19         // 封装目的地
20         FileOutputStream fos = new FileOutputStream("mn.jpg");
21 
22         // 复制数据
23         int by = 0;
24         while ((by = fis.read()) != -1) {
25             fos.write(by);
26         }
27 
28         // 释放资源
29         fos.close();
30         fis.close();
31     }
32 }

 1 package cn.itcast_03;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.FileOutputStream;
 5 import java.io.IOException;
 6 
 7 /*
 8  * 需求：把e:\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中
 9  * 
10  * 数据源：
11  *         e:\\哥有老婆.mp4--读取数据--FileInputStream
12  * 目的地：
13  *         copy.mp4--写出数据--FileOutputStream
14  */
15 public class CopyMp4Demo {
16     public static void main(String[] args) throws IOException {
17         // 封装数据源
18         FileInputStream fis = new FileInputStream("e:\\哥有老婆.mp4");
19         // 封装目的地
20         FileOutputStream fos = new FileOutputStream("copy.mp4");
21 
22         // 复制数据
23         int by = 0;
24         while ((by = fis.read()) != -1) {
25             fos.write(by);
26         }
27 
28         // 释放资源
29         fos.close();
30         fis.close();
31     }
32 }

 1 package cn.itcast_02;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.IOException;
 5 
 6 /*
 7  * 一次读取一个字节数组：int read(byte[] b)
 8  * 返回值其实是实际读取的字节个数。
 9  */
10 public class FileInputStreamDemo2 {
11     public static void main(String[] args) throws IOException {
12         // 创建字节输入流对象
13         // FileInputStream fis = new FileInputStream("fis2.txt");
14         FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");
15 
16         // 读取数据
17         // 定义一个字节数组
18         // 第一次读取
19         // byte[] bys = new byte[5];
20         // int len = fis.read(bys);
21         // // System.out.println(len);
22         // // System.out.println(new String(bys));
23         // // System.out.println(new String(bys, 0, len));
24         // System.out.print(new String(bys, 0, len));
25         //
26         // // 第二次读取
27         // len = fis.read(bys);
28         // // System.out.println(len);
29         // // System.out.println(new String(bys));
30         // // System.out.println(new String(bys, 0, len));
31         // System.out.print(new String(bys, 0, len));
32         //
33         // // 第三次读取
34         // len = fis.read(bys);
35         // // System.out.println(len);
36         // // System.out.println(new String(bys));
37         // // System.out.println(new String(bys, 0, len));
38         // System.out.print(new String(bys, 0, len));
39         //
40         // // 第四次读取
41         // len = fis.read(bys);
42         // // System.out.println(len);
43         // // System.out.println(new String(bys, 0, len));
44         // System.out.print(new String(bys, 0, len));
45         // // 代码重复了，用循环改进
46         // // 但是，我不知道结束条件
47         // // len = fis.read(bys);
48         // // System.out.println(len);
49         // // len = fis.read(bys);
50         // // System.out.println(len);
51         // // 如果读取到的实际长度是-1，就说明没有数据了
52 
53         // byte[] bys = new byte[115]; // 0
54         // int len = 0;
55         // while ((len = fis.read(bys)) != -1) {
56         // System.out.print(new String(bys, 0, len));
57         // // System.out.print(new String(bys)); //千万要带上len的使用
58         // }
59 
60         // 最终版代码
61         // 数组的长度一般是1024或者1024的整数倍
62         byte[] bys = new byte[1024];
63         int len = 0;
64         while ((len = fis.read(bys)) != -1) {
65             System.out.print(new String(bys, 0, len));
66         }
67 
68         // 释放资源
69         fis.close();
70     }
71 }

 1 package cn.itcast_04;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.FileOutputStream;
 5 import java.io.IOException;
 6 
 7 /*
 8  * 需求：把c:\\a.txt内容复制到d:\\b.txt中
 9  * 
10  * 数据源：
11  *         c:\\a.txt    --    读取数据    --    FileInputStream
12  * 目的地：
13  *         d:\\b.txt    --    写出数据    --    FileOutputStream
14  */
15 public class CopyFileDemo {
16     public static void main(String[] args) throws IOException {
17         // 封装数据源
18         FileInputStream fis = new FileInputStream("c:\\a.txt");
19         FileOutputStream fos = new FileOutputStream("d:\\b.txt");
20 
21         // 复制数据
22         byte[] bys = new byte[1024];
23         int len = 0;
24         while ((len = fis.read(bys)) != -1) {
25             fos.write(bys, 0, len);
26         }
27 
28         // 释放资源
29         fos.close();
30         fis.close();
31     }
32 }

 1 package cn.itcast_04;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.FileOutputStream;
 5 import java.io.IOException;
 6 
 7 /*
 8  * 需求：把e:\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中
 9  * 
10  * 数据源：
11  *         e:\\哥有老婆.mp4--读取数据--FileInputStream
12  * 目的地：
13  *         copy.mp4--写出数据--FileOutputStream
14  */
15 public class CopyMp4Demo {
16     public static void main(String[] args) throws IOException {
17         // 封装数据源
18         FileInputStream fis = new FileInputStream("e:\\哥有老婆.mp4");
19         // 封装目的地
20         FileOutputStream fos = new FileOutputStream("copy.mp4");
21 
22         // 复制数据
23         byte[] bys = new byte[1024];
24         int len = 0;
25         while ((len = fis.read(bys)) != -1) {
26             fos.write(bys, 0, len);
27         }
28 
29         // 释放资源
30         fos.close();
31         fis.close();
32     }
33 }

 1 package cn.itcast_05;
 2 
 3 import java.io.BufferedOutputStream;
 4 import java.io.FileOutputStream;
 5 import java.io.IOException;
 6 
 7 /*
 8  * 通过定义数组的方式确实比以前一次读取一个字节的方式快很多，所以，看来有一个缓冲区还是非常好的。
 9  * 既然是这样的话，那么，java开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。
10  * 这种类被称为：缓冲区类(高效类)
11  * 写数据：BufferedOutputStream
12  * 读数据：BufferedInputStream
13  * 
14  * 构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。
15  * 
16  * 为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?
17  * 原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。
18  */
19 public class BufferedOutputStreamDemo {
20     public static void main(String[] args) throws IOException {
21         // BufferedOutputStream(OutputStream out)
22         // FileOutputStream fos = new FileOutputStream("bos.txt");
23         // BufferedOutputStream bos = new BufferedOutputStream(fos);
24         // 简单写法
25         BufferedOutputStream bos = new BufferedOutputStream(
26                 new FileOutputStream("bos.txt"));
27 
28         // 写数据
29         bos.write("hello".getBytes());
30 
31         // 释放资源
32         bos.close();
33     }
34 }

 1 package cn.itcast_05;
 2 
 3 import java.io.BufferedInputStream;
 4 import java.io.FileInputStream;
 5 import java.io.IOException;
 6 
 7 /*
 8  * 注意：虽然我们有两种方式可以读取，但是，请注意，这两种方式针对同一个对象在一个代码中只能使用一个。
 9  */
10 public class BufferedInputStreamDemo {
11     public static void main(String[] args) throws IOException {
12         // BufferedInputStream(InputStream in)
13         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
14                 "bos.txt"));
15 
16         // 读取数据
17         // int by = 0;
18         // while ((by = bis.read()) != -1) {
19         // System.out.print((char) by);
20         // }
21         // System.out.println("---------");
22 
23         byte[] bys = new byte[1024];
24         int len = 0;
25         while ((len = bis.read(bys)) != -1) {
26             System.out.print(new String(bys, 0, len));
27         }
28 
29         // 释放资源
30         bis.close();
31     }
32 }

 1 package cn.itcast_06;
 2 
 3 import java.io.BufferedInputStream;
 4 import java.io.BufferedOutputStream;
 5 import java.io.FileInputStream;
 6 import java.io.FileOutputStream;
 7 import java.io.IOException;
 8 
 9 /*
10  * 需求：把e:\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中
11  * 
12  * 字节流四种方式复制文件：
13  * 基本字节流一次读写一个字节：    共耗时：117235毫秒
14  * 基本字节流一次读写一个字节数组： 共耗时：156毫秒
15  * 高效字节流一次读写一个字节： 共耗时：1141毫秒
16  * 高效字节流一次读写一个字节数组： 共耗时：47毫秒
17  */
18 public class CopyMp4Demo {
19     public static void main(String[] args) throws IOException {
20         long start = System.currentTimeMillis();
21         // method1("e:\\哥有老婆.mp4", "copy1.mp4");
22         // method2("e:\\哥有老婆.mp4", "copy2.mp4");
23         // method3("e:\\哥有老婆.mp4", "copy3.mp4");
24         method4("e:\\哥有老婆.mp4", "copy4.mp4");
25         long end = System.currentTimeMillis();
26         System.out.println("共耗时：" + (end - start) + "毫秒");
27     }
28 
29     // 高效字节流一次读写一个字节数组：
30     public static void method4(String srcString, String destString)
31             throws IOException {
32         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
33                 srcString));
34         BufferedOutputStream bos = new BufferedOutputStream(
35                 new FileOutputStream(destString));
36 
37         byte[] bys = new byte[1024];
38         int len = 0;
39         while ((len = bis.read(bys)) != -1) {
40             bos.write(bys, 0, len);
41         }
42 
43         bos.close();
44         bis.close();
45     }
46 
47     // 高效字节流一次读写一个字节：
48     public static void method3(String srcString, String destString)
49             throws IOException {
50         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
51                 srcString));
52         BufferedOutputStream bos = new BufferedOutputStream(
53                 new FileOutputStream(destString));
54 
55         int by = 0;
56         while ((by = bis.read()) != -1) {
57             bos.write(by);
58 
59         }
60 
61         bos.close();
62         bis.close();
63     }
64 
65     // 基本字节流一次读写一个字节数组
66     public static void method2(String srcString, String destString)
67             throws IOException {
68         FileInputStream fis = new FileInputStream(srcString);
69         FileOutputStream fos = new FileOutputStream(destString);
70 
71         byte[] bys = new byte[1024];
72         int len = 0;
73         while ((len = fis.read(bys)) != -1) {
74             fos.write(bys, 0, len);
75         }
76 
77         fos.close();
78         fis.close();
79     }
80 
81     // 基本字节流一次读写一个字节
82     public static void method1(String srcString, String destString)
83             throws IOException {
84         FileInputStream fis = new FileInputStream(srcString);
85         FileOutputStream fos = new FileOutputStream(destString);
86 
87         int by = 0;
88         while ((by = fis.read()) != -1) {
89             fos.write(by);
90         }
91 
92         fos.close();
93         fis.close();
94     }
95 }