PrintWriter、BufferedWriter以及BufferredReader基本使用详解
目录
1、PrintWriter的使用
--1.1、构造函数
--1.2、常用的方法
----1.2.1、将字符串写到文件中
2、BufferedWriter的使用
--2.1、构造方法
--2.2、常用的方法
----2.2.1、将字符串写入到文件中
3、BufferedReader的使用
--3.1、构造函数
--3.2、常用的方法
----3.2.1、从文件中读取文本数据
4、使用PrintWriter/BufferedReader实现文件的复制
1、PrintWriter的使用
PrintWriter:是具有自动行刷新的缓冲字符输出流，这是一个高级流。所谓的自动行刷新，意思就是说：在构造函数中指定autoFlush的值为true时，则 println()、printf() 或 format() 方法将自动刷新输出缓冲区(自动调用flush()方法)，但是,自动行刷新无疑会增加写出次数而降低写出效率。
1.1、构造函数
//使用指定文件创建不具有自动行刷新的新 PrintWriter
public PrintWriter(File file);
//创建具有指定文件和字符集且不带自动刷行新的新 PrintWriter
public PrintWriter(File file,String csn);
//根据现有的 OutputStream 创建不带自动行刷新的新 PrintWriter
public PrintWriter(OutputStream out);
//通过现有的 OutputStream 创建新的 PrintWriter(具有自动行刷新)
public PrintWriter(OutputStream out,boolean autoFlush);
//创建具有指定文件名称且不带自动行刷新的新 PrintWriter
public PrintWriter(String fileName);
//创建具有指定文件名称和字符集且不带自动行刷新的新 PrintWriter
public PrintWriter(String fileName,String csn);
//创建新 PrintWriter(具有自动行刷新)
public PrintWriter(Writer out,boolean autoFlush);
从PrintWeiter的构造方法中我们就可以知道，该高级流很灵活，接下来我们会介绍BufferedWriter/BufferedReader这一对字符缓冲流，但是，由于BufferedWriter没有PrintWriter使用灵活，所以在实际的操作中，我们往往会使用PrinterWriter/BufferedReader这种组合。
1.2、常用的方法
//打印boolean值
public void print(boolean b);
//打印 boolean 值，然后终止该行
public void println(boolean x);
//打印字符
public void print(char c);
//打印字符，然后终止该行
public void println(char x);
//打印字符数组
public void print(char[] s);
//打印字符数组，然后终止该行
public void println(char[] x);
//打印 double 精度浮点数
public void print(double d);
//打印 double 精度浮点数,然后终止该行
public void println(double x);
//打印一个浮点数
public void print(float f);
//打印浮点数，然后终止该行
public void println(float x);
//打印整数
public void print(int i);
//打印整数，然后终止该行
public void println(int x);
//打印 long 整数
public void print(long l);
//打印 long 整数，然后终止该行
public void println(long x);
//打印对象
public void print(Object obj);
//打印 Object，然后终止该行
public void println(Object x);
//打印字符串。如果参数为 null，则打印字符串 "null"
public void print(String s);
//打印 String，然后终止该行
public void println(String x);
//通过写入行分隔符字符串终止当前行
public void println();
//使用指定格式字符串和参数将一个格式化字符串写入此 writer 中。如果启用自动刷新，则调用此方法将刷新输出缓冲区
public PrintWriter format(Locale l,String format,Object... args);
//使用指定格式字符串和参数将一个格式化字符串写入此 writer 中。如果启用自动刷新，则调用此方法将刷新输出缓冲区
public PrintWriter format(String format,Object... args);
//将指定字符添加到此 writer
public PrintWriter append(char c);
//将指定的字符序列添加到此 writer
public PrintWriter append(CharSequence csq);
//将指定字符序列的子序列添加到此 writer
public PrintWriter append(CharSequence csq,int start,int end);
//写入字符数组
public void write(char[] buf);
//写入字符数组的某一部分
public void write(char[] buf,int off,int len);
//写入单个字符
public void write(int c);
//写入字符串
public void write(String s);
//写入字符串的某一部分
public void write(String s,int off,int len);
1.2.1、将字符串写到文件中
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
/**
* PrintWriter:是具有自动行刷新的缓冲字符输出流(高级流)
* @author Administrator
*
*/
public class PWDemo01 {
public static void main(String[] args) {
try {
//打开文件
FileOutputStream fos=new FileOutputStream("pw.txt");
//设置编码集
OutputStreamWriter osw=new OutputStreamWriter(fos,"UTF-8");
/**
* 创建具有自动刷新的PrinterWriter后，每当我们使用println()/print()
* 方法写出字符串后，都会自动调用flush()方法
* 但是,这个无疑会增加写出次数而降低写出效率
*/
//写出数据
PrintWriter pw=new PrintWriter(osw, true);
pw.println("字符缓冲");
pw.append("测试数据");
pw.write("哈哈哈");
pw.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
2、BufferedWriter的使用
BufferedWriter:字符缓冲输出流(高级流),将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。 可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。
2.1、构造方法
//创建一个使用默认大小输出缓冲区的缓冲字符输出流
public BufferedWriter(Writer out);
//创建一个使用给定大小输出缓冲区的新缓冲字符输出流
public BufferedWriter(Writer out,int sz);12345
2.2、常用的方法
//写入字符数组的某一部分
public void write(char[] cbuf,int off,int len);
//写入单个字符
public void write(int c);
//写入字符串的某一部分
public void write(String s,int off,int len);
//写入一个行分隔符
public void newLine();
2.2.1、将字符串写入到文件中
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
/**
* BufferedWriter:字符缓冲输出流(高级流)
* @author 作者 E-mail:1832567496@qq.com
* @date 创建时间：2016年10月9日 上午11:10:21
* @version 1.0
* @parameter
* @since
* @return
*/
public class BWDemo01 {
public static void main(String[] args) {
try {
//打开文件
FileOutputStream fos=new FileOutputStream("pw.txt");
//设置编码集
OutputStreamWriter osw=new OutputStreamWriter(fos,"UTF-8");
//将字符输出流包装为字符缓冲输出流
BufferedWriter bw=new BufferedWriter(osw);
bw.write("BW测试文字");
bw.append("BWBWBWBWBW");
bw.flush();
bw.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
从BufferedWriter的构造函数和常用的方法中可以看出来，BufferedWriter的使用相比较PrinterWriter来讲就比较简单了，所以在应用中我们一般不使用BufferedWriter而是使用PrinterWriter，大家知道BufferedWriter即可。
3、BufferedReader的使用
BufferedReader:缓冲字符输入流，高级流。从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。可以以行为单位读取字符串。
3.1、构造函数
//创建一个使用默认大小(8192)输入缓冲区的缓冲字符输入流
public BufferedReader(Reader in);
//创建一个使用指定大小输入缓冲区的缓冲字符输入流
public BufferedReader(Reader in,int sz);
3.2、常用的方法
//读取单个字符
public int read();
//读入字符数组中的某一部分
public int read(char[] cbuf,int off,int len);
//读取一个文本行
public String readLine();
//跳过字符
public long skip(long n);
3.2.1、从文件中读取文本数据
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
/**
* BufferedReader:缓冲字符输入流，高级流
* 从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
* 可以以行为单位读取字符串
* @author Administrator
*
*/
public class BRDemo01 {
public static void main(String[] args) {
try {
/**
* 逐个字符的读取
*/
FileInputStream fis=new FileInputStream("pw.txt");
InputStreamReader isr=new InputStreamReader(fis, "UTF-8");
BufferedReader br=new BufferedReader(isr);
int size=0;
while((size=br.read())!=-1){
char content=(char)size;
System.out.println(content);
}
/**
* 整行读取
*/
FileInputStream fis1=new FileInputStream("pw.txt");
InputStreamReader isr1=new InputStreamReader(fis1, "UTF-8");
BufferedReader br1=new BufferedReader(isr1);
String isNull=null;
/**
* public String readLine()
* 该方法的返回值如果为null，则说明已经读到文件的末尾了
*/
while((isNull=br1.readLine())!=null){
System.out.println(isNull);
}
br.close();
br1.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
4、使用PrintWriter/BufferedReader实现文件的复制
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
public class SummaryPWAndBR {
public static void main(String[] args) {
/**
* 使用字符缓冲输入流和字符缓冲输出流实现文件的复制
* 1.打开文件
* 2.设置字符集
* 3.进行读写操作
* 4.关闭流
*/
try {
long begin=System.currentTimeMillis();
//打开源文件
FileInputStream fis=new FileInputStream("pwSrc.txt");
//设置字符集
InputStreamReader isr=new InputStreamReader(fis, "UTF-8");
//从源文件读入数据
BufferedReader br=new BufferedReader(isr);
//打开目标文件
FileOutputStream fos=new FileOutputStream("pwDest.txt");
//设置字符集
OutputStreamWriter osw=new OutputStreamWriter(fos, "UTF-8");
//写入数据到目标文件
PrintWriter pw=new PrintWriter(osw, true);
int size=0;
char[] buffer=new char[10240];
while((size=br.read(buffer, 0, buffer.length))!=-1){
pw.write(buffer, 0, size);
}
br.close();
pw.close();
long end=System.currentTimeMillis();
System.out.println("使用字符缓冲输入流实现文件的复制完毕！耗时："+(end-begin)+"毫秒");
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果：
运行结果.PNG
