Reader与Writer的实现

Reader与Writer的实现

             

CharArrayReader与CharArrayWriter

CharArrayReader从CharArray中读出，一个char就是两个字节。CharArrayWriter，从其他地方写入CharArray。本身处理的就是Unicode

示例：

import java.io.CharArrayReader;
import java.io.CharArrayWriter;
import java.io.IOException;
​
public class TestCharArrayReaderWriter {
​
    public static void main(String[] args) {
        char[] cs = "我们都是好孩子".toCharArray();
        CharArrayReader arrayReader = new CharArrayReader(cs);
        try {
            System.out.println((char)arrayReader.read());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            arrayReader.close();
        }
        
        CharArrayWriter arrayWriter = new CharArrayWriter(2);
        arrayWriter.write((int) '我');
        arrayWriter.write((int) '们');
        arrayWriter.write((int) '都');
        System.out.println(arrayWriter.toString());
        arrayWriter.close();
    }
}

BufferedWriter与BufferedReader

BufferedReader，传入的参数是Reader，说明，它是封装流的，可以读取一行， 或者使用mark/skip。BufferedWriter传入Writer，可以写入新行等。

            

示例：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.CharArrayReader;
import java.io.CharArrayWriter;
import java.io.IOException;
​
public class TestBufferedReaderWriter {
​
    public static void main(String[] args) {
        
        char[] cbf = "我们都是好孩子\n我们以后不是好孩子\n哈哈".toCharArray();
        BufferedReader bufferedReader = new BufferedReader(new CharArrayReader(cbf), 3);
        try {
            System.out.println(bufferedReader.readLine());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        CharArrayWriter charArrayWriter = new CharArrayWriter();
        BufferedWriter bufferedWriter = new BufferedWriter(charArrayWriter);
        try {
            bufferedWriter.write(cbf);
            bufferedWriter.flush();
            System.out.println(charArrayWriter.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                bufferedWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

​StringWriter与StringReader

StrnigReader接受一个String类型的变量，重写了skip/mark/reset这些方法。StringWriter内部使用StringBuffer作为存储容器，并且增加了append方法，可以接受CharSequence类型的变量。

示例：

import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
​
public class TestStringReaderWriter {
​
    public static void main(String[] args) {
        String s = "1们都是好孩子";
        StringReader reader = new StringReader(s);
        try {
            reader.mark(5); //必须为正数，当时代码中并没有使用
            System.out.println((char)reader.read());  //1
            reader.reset();
            System.out.println((char)reader.read());//1
            reader.reset();
            System.out.println((char)reader.read());//1
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            reader.close();
        }
        StringWriter stringWriter = new StringWriter();
        stringWriter.write("我们");
        stringWriter.append("123").append("4");
        stringWriter.flush();
        System.out.println(stringWriter.getBuffer().toString());
        try {
            stringWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

PipedReader与PipedWriter

PipedReader必须与PipedWriter相连，一端写入，一端获取

                    

示例

import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
​
public class TestPipedReaderWriter {
​
    public static void main(String[] args) {
        PipedReader pipedReader = new PipedReader();
        PipedWriter pipedWriter = new PipedWriter();
        ReadThread readThread = new ReadThread(pipedReader);
        WriteThread writeThread = new WriteThread(pipedWriter);
        try {
            pipedReader.connect(pipedWriter);
            readThread.start();
            writeThread.start();
            System.out.println((char)pipedReader.read() + "--1");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                pipedReader.close();
                pipedWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
class ReadThread extends Thread {
​
    PipedReader pipedReader;
    public ReadThread(PipedReader pipedReader) {
        this.pipedReader = pipedReader;
    }
    public void run() {
        try {
            System.out.println((char)pipedReader.read());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
}
class WriteThread extends Thread {
​
    PipedWriter pipedWriter;
    public WriteThread(PipedWriter pipedWriter) {
        this.pipedWriter = pipedWriter;
    }
    public void run() {
        try {
            Thread.sleep(2000);
            pipedWriter.write("我们".toCharArray());
            pipedWriter.flush(); //此处必须有
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
    
}

输出结果可能为

InputStreamReader与OutputStreamWriter

这二者都是装饰流 。关键是Reader与Writer。Reader表示输入流，从什么输入，从InputStream中输入。Writer表示输出流，输出到什么中，输出到OutputStream中。所以InputStreamReader从字节流输入，read出字符。OutputStreamWriter使用writer方法将字符输出到流中

例子：

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
​
public class TestInputStreamReaderOutputStreamWriter {
​
    public static void main(String[] args) {
        //定义输出流
        ByteArrayOutputStream arrayOutputStream = new ByteArrayOutputStream();
        //定义输出转换流，目的是将write的东西转换成byte
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(arrayOutputStream);
        try {
            outputStreamWriter.write("我们都是好孩子");
            outputStreamWriter.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭流
            try {
                outputStreamWriter.close();
                arrayOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println(arrayOutputStream.toString()); //我们都是好孩子
        //将byte数组转换为char数组
        //将
        ByteArrayInputStream arrayInputStream = new ByteArrayInputStream(arrayOutputStream.toByteArray());
        InputStreamReader inputStreamReader = new InputStreamReader(arrayInputStream);
        try {
            System.out.println((char)inputStreamReader.read()); //我
            System.out.println((char)inputStreamReader.read()); //们
            System.out.println((char)inputStreamReader.read()); //都
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                arrayInputStream.close();
                inputStreamReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
    }
}

FileReader与FileWriter

FileReader继承自InputStreamReader，FileWriter继承自OutputStreamWriter，构造函数中调用父类的构造函数，并将文件流传入。

            

示例：

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
​
public class TestFileReaderFileWriter {
​
    public static void main(String[] args) {
        char[] cbuf = new char[100];
        int length = -1;
        //从文件中读出
        FileReader fileReader = null;
        try {
            fileReader = new FileReader("C:\\Users\\Administrator\\Desktop\\123.txt");
            length = fileReader.read(cbuf);
            System.out.println(new String(cbuf));
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //写入文件
        FileWriter fileWriter = null;
        try {
            fileWriter = new FileWriter("C:\\Users\\Administrator\\Desktop\\1234.txt");
            fileWriter.write(cbuf, 0, length);
            fileWriter.write("\r\n是的");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
    }
}

FilterReader与FilterWriter

继承自Reader与Writer并且持有父类的对象。

                

PushbackReader

​ 继承自FilterReader，不支持mark，添加了unread方法，首先将读出的数据放置在一个数组中，然后从数组中读取数据，当使用unread方法时，又将数据放回在数组中。使得流看起来像是可以回退。

                    

示例：

import java.io.IOException;
import java.io.PushbackReader;
import java.io.StringReader;
​
public class TestPushBackReader {
​
    public static void main(String[] args) {
        StringReader stringReader = new StringReader("我们都是好孩子");
        PushbackReader pushbackReader = new PushbackReader(stringReader, 5);
        try {
            System.out.println((char)pushbackReader.read());//我
            System.out.println((char)pushbackReader.read());//们
            pushbackReader.unread("不".toCharArray());
            System.out.println((char)pushbackReader.read());//不
            System.out.println((char)pushbackReader.read());//都
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            stringReader.close();
            try {
                pushbackReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

PrintWriter

        转换字节流为字符流，并且可将基本类型转换为字符添加到输出流中。

​ 转换字节流为字符流使用 this(new BufferedWriter(new OutputStreamWriter(out)), autoFlush);这种包装来实现。先将OutputStream转换为Writer，然后为Writer添加Buffer的功能。

            

示例：

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
​
public class TestPringWriter {
​
    public static void main(String[] args) {
        PrintWriter printWriter = null;
        try {
            printWriter = new PrintWriter(new File("C:\\Users\\Administrator\\Desktop\\132.txt"));
            printWriter.println();
            printWriter.print(12);
            printWriter.println(false);
            printWriter.print(12.1);
            printWriter.print("我们都是好孩子");
            printWriter.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally {
            if(null != printWriter) {
                printWriter.close();
            }
        }
    }
}

结果：