| 1. 字节缓冲流 点击此处返回总目录 1.1 字节输入流缓冲流
1.2 字节输出流缓冲流 1.3 总结：使用字节流进行文件复制的四种方式对比 2. 字符缓冲流 2.1 字符输入流缓冲流 2.2 字符输出流缓冲流 2.3 使用字符流缓冲流进行文件复制 前面学习了字节流和字符流，当读取数据量大的文件时，读取的速度会很慢，影响了程序的效率。因此，Java提供了一套缓冲流，用来提高IO流的读写速度。 Java提供给我们了四个缓冲流： BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter 这四个流可以提高读写效率。 1. 字节缓冲流 字节缓冲流有两个： 字节输出流缓冲流 BufferedOutputStream 写入数据到流中 字节输入流缓冲流 BufferedInputStream 读取流中的数据 1.1 BufferedOutputStream 字节输出流的缓冲流 作用：提高原有输出流的写入效率 如何提高效率的？ 通过设置这种流，应用程序可以将各个字节写入底层输出流中，等凑够了多个一次性调用底层的系统，而不必针对每次字节写入调用底层系统。 继承关系： java.lang.Object java.io.OutputStream java.io.FilterOutputStream java.io.BufferedOutputStream 继承自OutputStream，所以是一个字节输出流。方法都是write。 构造方法： BufferedOutputStream(OutputStream out) //可以传递任意的字节输出流。传递的是哪个字节流，就对哪个字节流提高效率。 BufferedOutputStream(OutputStream out, int size) 使用跟字节输出流没什么区别，但是效率比较快。 例1：
| package cn.itcast.demo07; import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException; public class Test {
public static void main(String[] args) throws IOException{
FileOutputStream fos = new FileOutputStream("e:\\a.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
byte[] b ="hello".getBytes();
bos.write(b);
bos.close();
}
} |
1.2 BufferedInputStream 字节输入流的缓冲流 与字节输出流缓冲流相似。 继承自InputStream。 构造方法中可以传入任意的字节输入流，传递的是谁，就提高谁的效率。 直接看使用吧~ 例1：
| package cn.itcast.demo08; import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException; public class Test {
public static void main(String[] args) throws IOException{
BufferedInputStream bis = new
BufferedInputStream(new FileInputStream("e:\\a.txt")); //直接使用匿名的了。
byte[] b = new byte[1024];
int len = 0;
while((len = bis.read(b))!=-1){
System.out.print(new String(b,0,len));
}
bis.close();
}
} |
1.3 总结：使用字节流进行文件复制的四种方式对比 目前一共学习了，四种使用字节流进行文件复制的方式，分别是： 方式1：字节流，单个字节复制 方式2：字节流，使用字节数组进行复制 方式3：字节流缓冲流，单个字节进行复制 方式4：字节流缓冲流，使用字节数组进行复制
| package cn.itcast.demo09; import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException; public class Test {
public static void main(String[] args) throws IOException{
long begin = System.currentTimeMillis();
copy_4("e:\\a.exe","f:\\a.exe");
long end = System.currentTimeMillis();
System.out.println(end - begin);
}
//字节流，单个字节
public static void copy_1(String from ,String to) throws IOException{
FileInputStream fis = new FileInputStream(from);
FileOutputStream fos = new FileOutputStream(to);
int b = 0;
while((b = fis.read())!=-1){
fos.write(b);
}
}
//字节流，字节数组
public static void copy_2(String from, String to) throws IOException{
FileInputStream fis = new FileInputStream(from);
FileOutputStream fos = new FileOutputStream(to);
int len = 0;
byte[] b = new byte[1024];
while((len = fis.read(b))!=-1){
fos.write(b,0,len);
}
}
//字节流缓冲流，单个字节
public static void copy_3(String from, String to) throws IOException{
BufferedInputStream bis = new
BufferedInputStream(new FileInputStream(from));
BufferedOutputStream bos = new
BufferedOutputStream(new FileOutputStream(to));
int b = 0;
while((b = bis.read())!=-1){
bos.write(b);
}
}
//字节流缓冲流，字节数组
public static void copy_4(String from, String to) throws IOException{
BufferedInputStream bis = new
BufferedInputStream(new FileInputStream(from));
BufferedOutputStream bos = new
BufferedOutputStream(new FileOutputStream(to));
int len = 0;
byte[] b = new byte[1024];
while((len = bis.read(b))!=-1){
bos.write(b,0,len);
}
} } |
复制181兆的文件，实验结果如下： 方式一 好久好久，不想跑了都。 方式二 3540毫秒，3秒半，还可以 方式三 10282毫秒，10秒左右 方式四 1181毫秒，1秒多就完了。 带缓存的比不带缓存的快。数组的比单个字节的快。 所以，如果要复制文件。一定要用数组的方式，即方式二、四。 2. 字符缓冲流 字符缓冲流有两个： 字符输出流缓冲流 BufferedWriter 字符输入流缓冲流 BufferedReader 2.1 BufferedWriter java.lang.Object java.io.Writer java.io.BufferedWriter 构造方法： BufferedWriter(Writer w) //可以传任意的字符输出流，传谁就高效谁 特有方法： void newLine() //写换行。前面在字节输出流的时候讲过write()方法中加入"\r\n"来换行。但是这个类中提供了独特的 方法。 //使用的时候推荐使用newLine()。因为这个方法具有平台无关性。即，跨越操作系统平台。 //在windows操作系统下，换行符号是\r\n，而在Linux下，换行符是\n。所以使用\r\n只能在windows 下面使用。使用newLine()方法，可以避开操作系统的差异。 例1：
| package cn.itcast.demo10; import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException; public class Test {
public static void main(String[] args) throws IOException {
FileWriter fw = new FileWriter("d:\\aa.txt");
BufferedWriter bw = new BufferedWriter(fw);
bw.write(100);
bw.newLine();
bw.flush();
bw.write("你好".toCharArray());
bw.newLine();
bw.flush();
bw.write("大家好");
bw.flush();
bw.close();
}
} |
2.2 BufferedReader 字符输入流缓冲流 java.lang.Object java.io.Reader java.io.BufferedReader 构造方法： BufferedReader(Reader r) //可以传任意的字符输入流，传谁就高效谁 特有方法： String readLine() //读取文本行。只返回了一行的有效字符，并不包含换行符。当读取到末尾时，返回null。【例2】 例1：
| package cn.itcast.demo11; import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException; public class Test {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("e:\\aaa.txt"));
char[] ch = new char[1024];
int len = 0;
while((len = br.read(ch))!=-1){
System.out.print(new String(ch,0,len));
}
}
} |
例2：
| package cn.itcast.demo11; import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException; public class Test {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("e:\\aaa.txt"));
char[] ch = new char[1024];
int len = 0;
while((len = br.read(ch))!=-1){
System.out.print(new String(ch,0,len));
}
}
} |
2.3 使用字符流缓冲流进行文件复制 要求：读一行，写一行。
| package cn.itcast.demo13; import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException; public class Test {
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new FileReader("e:\\aaa.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("e:\\bbb.txt"));
String line = null;
while((line = br.readLine())!=null){
bw.write(line);
bw.newLine(); //因为readLine()没有读出换行符来，所以应当写一个换行。
bw.flush();
}
bw.close();
br.close();
} } |
说明： 比较最后的文件发现不完全一致。因为bbb.txt比aaa.txt最后多了一个空行。但是因为是文本文件，所以最后多一个空行，没有什么影响。 |