一、缓冲区类
缓冲区类又被称为高效类，其能提高查找的效率
（1）字节缓冲区的类
写数据：BufferedOutputStream
读数据:BufferedInputStream
1、缓冲区的方法
FileOutputStream(path[File])
BufferedOutputStream(OutputStream out) //字节缓冲区仅仅是提供缓冲区的，为高效而设计的，真正的读写操 作还是要靠最基本的流对象去实现
例1：
package com.hwua.IO;
import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class BufferedOutputStreamDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
BufferedOutputStream bos = null; //创建缓冲区
try {
bos = new BufferedOutputStream(
new FileOutputStream("fos.txt")); //将字节流存入到缓冲区中
bos.write("hello".getBytes()); //写入文件的内容
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
if(bos!=null){
try {
bos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
2、缓冲区的BufferedInputStream
BufferedInputStream是用于读数据的
例2：
package com.hwua.IO;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class BufferedInputStreamDemo {
public static void main(String[] args) throws IOException {
BufferedInputStream bis2= new BufferedInputStream(new FileInputStream("fos.txt")); //创建缓冲区，将字符流传入缓冲区中，用对象去操作字符
byte[] bs = new byte[1024];
int len2 = 0;
while((len2=bis2.read(bs))!=-1){ //读取缓冲区中的文件
System.out.println(new String(bs,0,len2)); //输出以每个字节的数组
}
bis2.close();
}
}
3.字节缓冲区中复制文件
例3: 将一个大文件进行赋值，对比用基本字节流数组的方式和高效字节流数组的方式进行对比，哪个速度更快
package com.bufferedOutPutStream;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyFile {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
String a=new String("E:/icecrow");
String b=new String("D:/icecrow");
long start=System.currentTimeMillis();
show(a,b);
long end=System.currentTimeMillis();
System.out.println("耗时"+(end-start));
}
public static void show(String str1,String str2) throws IOException{ //定义方法
FileInputStream f=new FileInputStream("st1"); //将文件放入字节流，用对象调用
FileOutputStream f1=new FileOutputStream("str2");
byte[] b=new byte[1024];
int len=0;
//边读边写
while((len=f.read(b))!=-1){
f1.write(b,0,len);
}
f.close();
f1.close();
//上述相当于从装有砖的车上，一个个拿下来
}
public static void show1(String str1,String str2) throws IOException{
BufferedInputStream b=new BufferedInputStream(new FileInputStream(str1)); //将字节流放入缓冲区中，用对象调用
BufferedOutputStream b1=new BufferedOutputStream(new FileOutputStream(str2));
byte[] by=new byte[1024];
int len=0;
//边读边写
while((len=b.read(by))!=-1){
b1.write(by,0,len);
}
b.close();
b1.close();
//上述相当于把砖放入框子中，然后通过框去搬砖，更搞笑
}
}
二、字符流
字符流是有字节流加上编码表而组成的，字符流的实质是操作字节流
(1) 字符输出流的方法
OutputStreamWriter: 写入数据
OutputStreamWriter(OutputStream out);
创建一个使用默认字符编码的OutputStreamWriter。
OutputStreamWriter(OutputStream out, Charset cs)
创建一个使用给定字符集的OutputStreamWriter。
字符流 = 字节流+编码表
例4：
package com.hwua.IO;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class OutputStreamWriterDemo {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//默认编码 GBK
OutputStreamWriter osw = new OutputStreamWriter(
new FileOutputStream("osw.txt"),"UTF-8"); //创建一个使用给定字符集，如果没有明确编码表，则是创建默认的
osw.write("中国啦啦啦啦");
osw.close();
}
}
（2）字符输入流
InputStreamReader：
InputStreamReader(InputStream in)
创建一个使用默认字符集的InputStreamReader。
InputStreamReader(InputStream in, String charsetName):用指定的编码读取数据
例5：
1.输出单个的
package com.hwua.IO;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
public class InputStreamReaderDemo {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//默认还是GBK
InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"),"UTF-8"); //把字节流放入到字符流，通过对象调用
//字符流等于字节流+编码 ，默认编码是GBK
int ch =0;
while((ch=isr.read())!=-1){
System.out.print((char)ch); //输出文件单个的元素
}
isr.close();
}
}
例5：
用数组输出
package com.bufferedOutPutStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
public class InputStreamReadDemo {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
InputStreamReader isr=new InputStreamReader(new FileInputStream("b.txt"),"Utf-8");
char[] ch=new char[1024]; //定义一个字符数组
int len=0;
while((len=isr.read(ch))!=-1){ //读取文件中对象
System.out.println(new String(ch,0,len)); //每次输出一个字符串
}
isr.close();
}
}
（3） FileWriter和FileReader
转换流(InputStreamReadr/OutputStreamWriter)的名称有点长，所以，Java就提供了子类供我们使用
OutputStreamWriter = FileOutputStream + 编码(GBK);
FileWriter = FileOutputStream + 编码(GBK);
InputStreamReadr = FileInputStream + 编码(GBK);
FileReader = FileInputStream + 编码(GBK);
例6
下面是文件复制的例子
数据源：
osw.txt --读取 – 字符转换流–InputStreamReadr–FileReader
目的地：
ocw.txt --写出 --字符转换流 --OutputStreamWriter --FileWriter
package com.hwua.IO;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriterAndFileReaderDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
FileReader fr =null;
FileWriter fw =null;
try {
fr = new FileReader("osw.txt");//默认编码不是跟随系统，是跟随编译器的编码格式
fw = new FileWriter("ocw.txt");
char[] chs = new char[1024];
int len= 0;
while((len = fr.read(chs))!=-1){
fw.write(chs, 0, len);
fw.flush();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
if(fr!=null){
try {
fr.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(fw!=null){
try {
fw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
（4）缓冲流的定义
缓冲流是为了增强文件的读写能力，java提供BufferedReader和BufferedWriter满足这些需求
1.缓冲区类又被称为高效类，其类为BufferedReader(输入流)、BufferedWriter（输出流）
BufferedReader：用于读取数据
BufferedWriter：用于写入数据
例7：
BufferedWriter的例子
package com.hwua.IO;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
ublic class BufferedWriterDemo {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt")); //把FileWriter传入缓冲区中
bw.write("我爱学习");
bw.write("11");
bw.write("学习也爱我");
bw.flush();
bw.close();
}
}
例8：
BufferedReader的例子
BufferedReader:
从字符输入流读取文本，缓冲各个字符，从而实现字符、数据和行的高效读取。
可以指定缓冲区的大小，或者接受默认的大小，在大多数情况下，默认值就够了。
package com.hwua.IO;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class BufferedReaderDemo {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
BufferedReader br = new BufferedReader(new FileReader("bw.txt")); //把FileReader传入缓冲区中,实现高效读取
char[] chs = new char[1024];
int len =0;
while((len = br.read(chs))!=-1){
System.out.println(new String(chs,0,len));
}
br.close();
}
}
（5）
字符缓冲流的特殊方法：
BufferedWriter:
newLine():换行
BufferedReader:
readLine()：一次性读一行数据
包含该行内容的字符串，不包含任何终止符，如果已达到流末尾，则返回null
作业：用BufferedWriter和BufferedReader 对文本文件进行复制 用换行和读行的操作
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedDemo {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//write();
read();
}
public static void read() throws IOException{
BufferedReader br= new BufferedReader(new FileReader("bw.txt"));
String str = null;
while((str = br.readLine())!=null){
System.out.println(str);
}
br.close();
}
public static void write() throws IOException{
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
bw.write("你好啊啊啊啊啊");
bw.newLine();//新启一行（换行意思） bw.writer("\n")
bw.write("你好啊啊啊啊啊");
bw.write("你好啊啊啊啊啊");
bw.newLine();
bw.write("你好啊啊啊啊啊");
bw.newLine();
bw.write("你好啊啊啊啊啊");
bw.close();
}
}