1、字节缓冲区
（1）写入数据到流中，字节缓冲输出流 BufferedOutputStream；
（2）读取流中的数据，字节缓冲输入流 BufferedInputStream；
（3）它们的内部都包含了一个缓冲区，通过缓冲区读写，就可以提高了IO流的读写速度。
2、字节缓冲输出流BufferedOutputStream
通过字节缓冲流，进行文件的读写操作，写数据到文件的操作 。
1 import java.io.BufferedOutputStream; 2 import java.io.FileOutputStream; 3 import java.io.IOException; 4 5 public class BufferedOutputStreamDemo01 { 6 public static void main(String[] args) throws IOException { 7 8 // 写数据到文件的方法 9 write(); 10 } 11 12 /* 13 * 写数据到文件的方法 1,创建流 2，写数据 3，关闭流 14 */ 15 private static void write() throws IOException { 16 // 创建基本的字节输出流 17 FileOutputStream fileOut = new FileOutputStream("d:\\abc.txt"); 18 // 使用高效的流，把基本的流进行封装，实现速度的提升 19 BufferedOutputStream out = new BufferedOutputStream(fileOut); 20 // 2，写数据 21 out.write("I Love You".getBytes()); 22 // 3，关闭流 23 out.close(); 24 } 25 }
3、字节缓冲输入流 BufferedInputStream
完成读取文件中数据的操作。
1 /* 2 * 从文件中读取数据 3 * 1,创建缓冲流对象 4 * 2，读数据，打印 5 * 3，关闭 6 */ 7 private static void read() throws IOException { 8 //1,创建缓冲流对象 9 FileInputStream fileIn = new FileInputStream("d:\\abc.txt"); 10 //把基本的流包装成高效的流 11 BufferedInputStream in = new BufferedInputStream(fileIn); 12 //2，读数据 13 int ch = -1; 14 while ( (ch = in.read()) != -1 ) { 15 //打印 16 System.out.print((char)ch); 17 } 18 //3，关闭 19 in.close(); 20 }
4、使用基本的流与高效的流完成复制文件
测试视频链接：测试视频 密码：obki
1 import java.io.BufferedInputStream; 2 import java.io.BufferedOutputStream; 3 import java.io.FileInputStream; 4 import java.io.FileOutputStream; 5 import java.io.IOException; 6 7 /* 8 * 需求：将d:\\test.mp4文件进行复制 9 * 采用4种方式复制 10 * 方式1： 采用基本的流，一次一个字节的方式复制 共耗时 67564毫秒 11 * 方式2： 采用基本的流，一个多个字节的方式赋值 共耗时 109毫秒 12 * 方式3： 采用高效的流，一次一个字节的方式复制 共耗时 936毫秒 13 * 方式4： 采用高效的流，一个多个字节的方式赋值 共耗时 43毫秒 14 * 15 * 数据源： d:\\test.mp4 16 * 目的地1: d:\\copy1.mp4 17 * 目的地2: d:\\copy2.mp4 18 * 目的地3: d:\\copy3.mp4 19 * 目的地4: d:\\copy4.mp4 20 * 21 * 实现的步骤： 22 * 1，指定数据源 23 * 2，指定目的地 24 * 3，读数据 25 * 4，写数据 26 * 5，关闭流 27 * 28 */ 29 public class CopyAVI { 30 public static void main(String[] args) throws IOException { 31 // 开始计时 32 long start = System.currentTimeMillis(); 33 // 方式1： 采用基本的流，一次一个字节的方式复制 34 // method1("d:\\test.mp4", "d:\\copy1.mp4"); 35 // 方式2： 采用基本的流，一个多个字节的方式赋值 36 // method2("d:\\test.mp4", "d:\\copy2.mp4"); 37 // 方式3： 采用高效的流，一次一个字节的方式复制 38 // method3("d:\\test.mp4", "d:\\copy3.mp4"); 39 // 方式4： 采用高效的流，一个多个字节的方式赋值 40 method4("d:\\test.mp4", "d:\\copy4.mp4"); 41 42 // 结束计时 43 long end = System.currentTimeMillis(); 44 // 打印耗时多少毫秒 45 System.out.println("共耗时 " + (end - start) + "毫秒"); 46 } 47 48 // 方式4： 采用高效的流，一个多个字节的方式赋值 49 private static void method4(String src, String dest) throws IOException { 50 // 1，指定数据源 51 BufferedInputStream in = new BufferedInputStream(new FileInputStream( 52 src)); 53 // 2，指定目的地 54 BufferedOutputStream out = new BufferedOutputStream( 55 new FileOutputStream(dest)); 56 // 3，读数据 57 byte[] buffer = new byte[1024]; 58 int len = -1; 59 while ((len = in.read(buffer)) != -1) { 60 // 4,写数据 61 out.write(buffer, 0, len); 62 } 63 // 5，关闭流 64 in.close(); 65 out.close(); 66 } 67 68 // 方式3： 采用高效的流，一次一个字节的方式复制 69 private static void method3(String src, String dest) throws IOException { 70 // 1，指定数据源 71 BufferedInputStream in = new BufferedInputStream(new FileInputStream( 72 src)); 73 // 2，指定目的地 74 BufferedOutputStream out = new BufferedOutputStream( 75 new FileOutputStream(dest)); 76 // 3，读数据 77 int ch = -1; 78 while ((ch = in.read()) != -1) { 79 // 4，写数据 80 out.write(ch); 81 } 82 // 5，关闭流 83 in.close(); 84 out.close(); 85 } 86 87 // 方式2： 采用基本的流，一个多个字节的方式赋值 88 private static void method2(String src, String dest) throws IOException { 89 // 1，指定数据源 90 FileInputStream in = new FileInputStream(src); 91 // 2，指定目的地 92 FileOutputStream out = new FileOutputStream(dest); 93 // 3，读数据 94 byte[] buffer = new byte[1024]; 95 int len = -1; 96 while ((len = in.read(buffer)) != -1) { 97 // 4，写数据 98 out.write(buffer, 0, len); 99 } 100 // 5，关闭流 101 in.close(); 102 out.close(); 103 } 104 105 // 方式1： 采用基本的流，一次一个字节的方式复制 106 private static void method1(String src, String dest) throws IOException { 107 // 1，指定数据源 108 FileInputStream in = new FileInputStream(src); 109 // 2，指定目的地 110 FileOutputStream out = new FileOutputStream(dest); 111 // 3，读数据 112 int ch = -1; 113 while ((ch = in.read()) != -1) { 114 // 4，写数据 115 out.write(ch); 116 } 117 // 5，关闭流 118 in.close(); 119 out.close(); 120 } 121 }
5、字符缓冲区
（1）字符缓冲输入流 BufferedReader；
（2）字符缓冲输出流 BufferedWriter；
（3）完成文本数据的高效的写入与读取的操作。
6、字符缓冲输出流 BufferedWriter
（1）将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入；
（2）方法：void newLine() 根据当前的系统，写入一个换行符。
1 /* 2 * BufferedWriter 字符缓冲输出流 3 * 方法 4 * public void newLine()写入一个行分隔符 5 * 6 * 需求： 通过缓冲输出流写入数据到文件 7 * 分析： 8 * 1，创建流对象 9 * 2，写数据 10 * 3，关闭流 11 * 12 */ 13 public class BufferedWriterDemo { 14 public static void main(String[] args) throws IOException { 15 //创建流 16 //基本字符输出流 17 FileWriter fileOut = new FileWriter("d:\\Java\\file.txt"); 18 //把基本的流进行包装 19 BufferedWriter out = new BufferedWriter(fileOut); 20 //2，写数据 21 for (int i=0; i<5; i++) { 22 out.write("hello"); 23 out.newLine(); 24 } 25 //3,关闭流 26 out.close(); 27 } 28 }
7、字符缓冲输入流 BufferedReader
（1）从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取；
（2）public String readLine() 读取一个文本行，包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null。
1 /* 2 * BufferedReader 字符缓冲输入流 3 * 4 * 方法： 5 * String readLine() 6 * 需求：从文件中读取数据，并显示数据 7 */ 8 public class BufferedReaderDemo { 9 public static void main(String[] args) throws IOException { 10 //1,创建流 11 BufferedReader in = new BufferedReader(new FileReader("d:\\Java\\file.txt")); 12 //2，读数据 13 //一次一个字符 14 //一次一个字符数组 15 //一次读取文本中一行的字符串内容 16 String line = null; 17 while( (line = in.readLine()) != null ){ 18 System.out.println(line); 19 } 20 21 //3,关闭流 22 in.close(); 23 } 24 }
8、使用字符缓冲流完成文本文件的复制
1 import java.io.BufferedReader; 2 import java.io.BufferedWriter; 3 import java.io.FileReader; 4 import java.io.FileWriter; 5 import java.io.IOException; 6 7 /* 8 * 采用高效的字符缓冲流，完成文本文件的赋值 9 * 10 * 数据源:d:\\Java\\file.txt 11 * 目的地:d:\\Java\\copyFile.txt 12 * 13 * 分析： 14 * 1，指定数据源， 是数据源中读数据，采用输入流 15 * 2,指定目的地，是把数据写入目的地，采用输出流 16 * 3,读数据 17 * 4，写数据 18 * 5，关闭流 19 */ 20 public class CopyTextFile { 21 public static void main(String[] args) throws IOException { 22 // 1，指定数据源， 是数据源中读数据，采用输入流 23 BufferedReader in = new BufferedReader(new FileReader( 24 "d:\\Java\\file.txt")); 25 // 2,指定目的地，是把数据写入目的地，采用输出流 26 BufferedWriter out = new BufferedWriter(new FileWriter( 27 "d:\\Java\\copyFile.txt")); 28 // 3,读数据 29 String line = null; 30 while ((line = in.readLine()) != null) { 31 // 4，写数据 32 out.write(line); 33 // 写入换行符号 34 out.newLine(); 35 } 36 // 5，关闭流 37 out.close(); 38 in.close(); 39 } 40 }
完成文本数据的高效的写入与读取的操作