Java中PrintWriter、BufferedWriter以及BufferredReader基本使用详解

PrintWriter的使用

PrintWriter:是具有自动行刷新的缓冲字符输出流，这是一个高级流。所谓的自动行刷新，意思就是说：在构造函数中指定autoFlush的值为true时，则 println()、printf() 或 format() 方法将自动刷新输出缓冲区(自动调用flush()方法)，但是,自动行刷新无疑会增加写出次数而降低写出效率。

---

构造函数

//使用指定文件创建不具有自动行刷新的新 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这种组合。

---

常用的方法

//打印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);

将字符串写到文件中

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();
        }
    }

}

---

BufferedWriter的使用

BufferedWriter:字符缓冲输出流(高级流),将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。 可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。

---

构造方法

//创建一个使用默认大小输出缓冲区的缓冲字符输出流
public BufferedWriter(Writer out);

//创建一个使用给定大小输出缓冲区的新缓冲字符输出流
public BufferedWriter(Writer out,int sz);

常用的方法

//写入字符数组的某一部分
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();

将字符串写入到文件中

import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

/**
 * BufferedWriter:字符缓冲输出流(高级流)
 * @author  作者 E-mail:[email protected]
 * @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即可。

---

BufferedReader的使用

BufferedReader:缓冲字符输入流，高级流。从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。可以以行为单位读取字符串。

---

构造函数

//创建一个使用默认大小(8192)输入缓冲区的缓冲字符输入流
public BufferedReader(Reader in);

//创建一个使用指定大小输入缓冲区的缓冲字符输入流
public BufferedReader(Reader in,int sz);

常用的方法

//读取单个字符
public int read();

//读入字符数组中的某一部分
public int read(char[] cbuf,int off,int len);

//读取一个文本行
public String readLine();

//跳过字符
public long skip(long n);

从文件中读取文本数据

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();
        }
    }

}

---

使用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();
        }
    }

}

运行结果：

以上内容只代表我个人的观点，有什么错误的地方请各路大神指正！转载请注明出处！谢谢！

每天进步一点点!