Java第二十一天学习笔记~字符流缓冲区

字符流

Reader是字符输入流的基类，用于从某个源设备读取字符

Writer是字符输出流，用于向某个目标设备写入字符

字符流操作文件

字符输入流FileReader，通过此流可以从关联的文件中读取一个或一组字符。

在程序开发中，经常需要向文件中写入字符，可以使用Writer的一个子类FileReader。

需求：在硬盘上，创建一个文件，并写入一些文字数据。

用于操作操作文件的Writer的子类FileWriter，后缀名是父类名。前缀名是该流对象的功能。

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyTextTest {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		
		FileReader fr=new FileReader("IO流_2.txt");
		
		FileWriter fw=new FileWriter("copytext_1.txt");
		
		int ch=0;
		while((ch=fr.read())!=-1) {
			fw.write(ch);
		}
		fw.close();
		fr.close();
		

	}

}

package cn.itcast.p1.io.charstream.test;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyTextTest_2 {

	private static final int BUFFER_SIZE = 1024;

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FileReader fr=null;
		FileWriter fw=null;
		try 
		{
			fr=new FileReader("IO流_2.txt");
			fw=new FileWriter("copytest_2.txt");
			//创建一个临时容器，用于缓存读取到的字符
			char[] buf=new char[BUFFER_SIZE];//缓冲区
			
			int len=0;
			while((len=fr.read(buf))!=-1) {
				fw.write(buf, 0, len);
			}
			
			
		}catch (Exception e) {
			//System.out.println("读写失败");
			throw new RuntimeException("读写失败");
		}finally {
			if(fw!=null)
				try {
					fw.close();
				} catch (IOException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}
			if(fr!=null)
				try {
					fr.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
		}
		  
	}

}

操作步骤：

    1.创建一个FileWriter对象。该对象一被初始化就必须明确要被操作的文件，该文件会被创建到指定目录下，如果该目录下已经有同名文件，将被覆盖

    FileWriter fw=new FileWriter("demo.txt");

    2.调用write方法，将字符串写入到流中。

    fw.write();

    3.刷新流对象中的缓冲中的数据，将数据刷到目的地

    fw.flush();

    4.关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据，将数据刷到目的地中。和flush的区别，flush刷新后，流可以继续使用，close刷新后将会将流关闭。

    fw.close();

字符文件输入流FileReader

针对字符进行操作，而不是字节。它的间接父类是字符流Reader。FileWriter是用于写入字符文件的便捷类。

在FileReader类中未自定义方法，而是继承了其父类及间接父类中的方法。

构造方法

    public FileReader(File file)                 在给定从中读取数据的File的情况下创建一个新类

    public FileReader(String fileName)    在给定从中读取数据的文件名的情况下创建一个新类

字符文件输出流FileWriter

构造方法

    FileWriter(File file)                              通过file对象创建FileWriter

    FileWriter(File file, boolean append)  通过file对象创建类，append为true或false表示是否在文件追加

    FileWriter(FileDescriptor fd)               参数fd为文件描述符，通过文件描述符创建FileWriter

    FileWriter(String fileName)                 参数fileName为文件路径名，通过文件路径创建FileWriter

    FileWriter(String fileName, boolean append) 

字符输入流Reader

该类是抽象类，不能被实例化

方法

    abstract void close()             关闭输入流

    void mark ()                           在输入流中标记当前位置

    boolean markSupported ()    测试输入流是否支持mark()和reset()方法

    int read ()                              从输入流读取下一字符

    int read (char[] cbuf)             从输入流读取若干字符数据，并存储到字符数组

    abstract int read (char[] cbuf, int off, int len)       从输入流读取至多len个字符数据，并存储到字符数组

    boolean void ready ()           判断是否准备读取输入流

    void reset ()                          将输入流重新定位到mark()方法标记的位置

    long skip (long n)                  跳过输入流中n个字符数据

 

字符输出流Writer

该类是抽象类，不能被实例化

方法

    abstract void close()                     关闭输出流

    abstract void flush()                      刷新输出流，强制将缓冲区内容写入输出流

    void write(char[] cbuf)                   将指定字符数组的内容写入输出流

    abstract void write(char[] cbuf,int off,int len)          将指定字符数组从off位置开始的len个字符写入输出流

    write(int c)                                    将指定的字符写入输出流

    write(String str)                            将指定的字符串写入输出流

    write(String str,int off,int len)        将指定字符串从off位置开始的len个字符写入输出流

字符流的缓冲区

字符流提供了带缓冲区的包装流，分别是BufferedReader和BufferedWriter，其中BufferedReader用于对字符输入流进行包装，BufferedWriter用于对字符输出流进行包装。

缓冲区的出现提高了对数据的读写效率

对应类：BUfferWriter 、BufferedReader

特点：缓冲区要结合流才可以使用，在创建缓冲区之前，必须要有流对象。在流的基础上对流的功能进行了增强。

BufferedWriter步骤

    1.创建一个字符写入流对象

        FileWriter fw=new FileWriter("a.txt");

    2.将需要被提高效率的流对象作为参数传递给缓冲区的构造函数

        bufferedWriter bufw=new BufferedWriter(fw);

        buff.write("asdasdas");

        bufw.newLine();//换行符，跨平台的

    3.将缓冲区刷新

        bufw.flush;

    4.关闭缓冲区，就是在关闭缓冲区中的流对象

BufferedReader步骤

    1.创建一个字符写入流对象

        FileReader fr=new FileReader ("a.txt");

    2.将需要被提高效率的流对象作为参数传递给缓冲区的构造函数

        BufferedReader bufr=new BufferedReader (fr);

    3.读取流对象:该缓冲区提供了一个一次读取一行的方法。当返回null时表示，文件读到末尾

        String line=null;

        while((line=bufr.readLine())!=null) {

        String s=line;}

    4.关闭

        bufr.close();

readLine()方法的原理：无论是读一行，获取多个字符，最终都是在硬盘上一个一个读取，最终使用额还是read方法一次读一个的方法。

通过缓冲区复制一个文本文件

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyTextByBufTest {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		FileReader fr=new FileReader("buf.txt");
		BufferedReader bufr=new BufferedReader(fr);
		
		FileWriter fw=new FileWriter("buf_copy.txt");
		BufferedWriter bufw=new BufferedWriter(fw);
		
		String line=null;
		while((line=bufr.readLine())!=null) {
			bufw.write(line);
		}
		/*int ch=0;
		while((ch=bufr.read())!=-1) {
			bufw.write(ch);
		}
		*/
		bufw.close();
		bufr.close();
	}

}

字符缓冲区输入流BufferedReader

从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组和行的高效读取。

构造方法

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

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

方法

    void close()                                 关闭该流

    void mark(int readAheadLimit)    标记流中的当前位置

    boolean markSupported()           判断此流是否支持mark()操作

    int read()                                     读取单个字符

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

    String readLine()                         读取一个文本行

    boolean ready()                          判断此流是否已准备好被读取

    void reset()                                 将流重置为最新的标记

    long skip(long n) 跳过字符

字符缓冲区输出流BufferedWriter

将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。可以指定缓冲区的大小，或者接受默认的大小。

构造方法

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

    public BufferedWriter(Writer out, int size)   创建一个使用size指定大小输出缓冲区的输出流

方法

    void close()          关闭该输出流

    void flush()           刷新该流的缓冲

    void newLine()     写入一个行分隔符

    void write(char[] cbuf, int off,int len)     写入字符数组的某一部分

    void write(int c)     写入单个字符

    void write(String s,int off,int len)          写入字符串的某一部分

文件的读取

文件的读取方式一：FileReader();

    1.创建一个FileReader对象。文件读取流对象，和指定名称的文件相关联，要保证该文件是已经存在的，如果不存在会发生异常

    FileReader fr=new FileReader("demo.txt");

    2.调用读取流的对象的read方法

        (1)int ch=fr.read();一次读一个字符，会自动往下读。

        (2)读出所有字符 

     while（(ch=fr.read())!=-1）{

        System.out.println((char)ch);

     }

    3.关闭流资源，

    fr.close();

文件的读取方式二：通过字符数组进行读取

    1.创建一个FileReader对象。文件读取流对象，和指定名称的文件相关联，要保证该文件是已经存在的，如果不存在会发生异常

    FileReader fr=new FileReader("demo.txt");

    2.定一个字符数组，用于存储读到字符，该rrad(char[])返回的是读到的字符个数。

    char[] buf=new char[1024]；一般定义1024-2个字节。

    int num=0;

    while（(num=fr.read(buf))!=-1）{

        System.out.println((new String(buf,0,num));

    }

文件的续写

传递一个true参数，代表不覆盖已有文件，并在已知文件的末尾处进行数据续写。

FileWriter fw=new FileWriter("demo.txt"，true);

换行转义字符：\r\n

IO异常的处理方式

    FileWriter fw=null;
    try {

        fw=new FileWriter("demo.txt");
        fw.write("sdfasd");

    } catch (IOException e) {
        e.printStackTrace();

    }finally { 
        try {

            if(fw!=null)
            fw.close();

        } catch (IOException e) { 
            e.printStackTrace();

        }
}
}

ListNumberReader带有行号的缓冲区

是BufferedReader的直接子类

     LineNumberReader lnr=new LineNumberReader();

    获取行号:lnr.getLineNumber();

    设置行号从几开始：lnr.setLineNumber(100);

    1.创建一个字符写入流对象

        FileReader fr=new FileReader ("a.txt");

    2.将需要被提高效率的流对象作为参数传递给缓冲区的构造函数

        LineNumberReader lnfr=new LineNumberReader (fr);

    3.读取流对象:该缓冲区提供了一个一次读取一行的方法。当返回null时表示，文件读到末尾

        String line=null;

        while((line=lnfr.readLine())!=null) {

            String s=line;

            String linenum=lnfr.getLineNumber();

        }

    4.关闭

        lnfr.close();

自定义带行号的MyLineNumber

public class MyLineBufferReader extends MyBufferedReader {
    public MyLineBufferReader(Reader r) {
        super(r);
    }
    private int LineNumber;
    public int getLineNumber() {
        return LineNumber;
    }
    public void setLineNumber(int lineNumber) {
        LineNumber = lineNumber;
    }
    public String myReadLine() throws IOException {
        LineNumber++;
        return super.myReadLine();
    }
}

自定义一个功能和readline一致的方法，来模拟下BufferedReader()

public class MyBufferedReader extends Reader {
    private Reader r;
    public MyBufferedReader(Reader r) {
        super();
        this.r = r;
    }
    //可以一次读取一行的方法
    public String myReadLine() throws IOException {
        //定义一个临时容器。StringBulider容器，应用于存储字符数组
        StringBuilder sb=new StringBuilder();
        int ch=0;
        while((ch=r.read())!=-1){
            if(ch=='\r')
                continue;
            if(ch=='\n')
                return sb.toString();
            else
                sb.append((char)ch);
        }
        if(sb.length()!=0)
            return sb.toString();
            return null;
        }
    }
}

读取一个.java文件，并打印在控制台上

   

 FileReader fr=null;
    char[] buf=new char[1024];
    int num=0;
    try {
        fr= new FileReader("a.txt"); 
        try {
            while((num=fr.read(buf))!=-1) {
            System.out.print(new String(buf,0,num));
        } catch (IOException e) { 
            e.printStackTrace();
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } finally {
        try {
            if(fr!=null)
            fr.close();
        } catch (IOException e) { 
            e.printStackTrace();
        }
    }

将C盘的一个文本文件拷贝到D盘(数组相当于存储之中的媒介)

步骤：

    1.新建一个文件用于存储要被拷贝的文件

    2.定义读取流和源文件关联

    3.通不过不断读写完成数据存储

    4.关闭资源

    FileWriter fw=null;
FileReader fr=null;
    try {
        fw=new FileWriter("b.txt");
        fr=new FileReader("a.txt");
        char[] buf=new char[1024];
        int num=0;
        while ((num=fr.read(buf))!=-1) {
            fw.write(buf,0,num);
        }
    }catch (IOException e) {
        e.printStackTrace();
    }finally {
        try {
            fr.close();
        } catch (IOException e) { 
            e.printStackTrace();
        }   
        try {
            fw.close();
        } catch (IOException e) { 
            e.printStackTrace();
        } 
}