JAVA IO简单总结

JavaIO基本类简单总结

IO流之间的关系

图有点小问题，字符流Reader里面应该是CharArrayReader。

IO的分类

IO分阻塞型IO和非阻塞型IO（NIO）

阻塞型IO在读取数据时，如果数据未到达，会一直阻塞到读取到数据为止，所以称为阻塞型IO，在高并发的环境下性能不佳。

NIO不是使用 “流” 来作为数据的传输方式，而是使用通道，通道的数据传输是双向的，且NIO的数据写入和读取都是异步的，不会阻塞线程，所以称为非阻塞型IO，在高并发的环境下性能很好。

字节流和字符流的区别：

· 读写单位的不同：字节流以字节（8bit）为单位。字符流以字符为单位，根据码表映射字符，一次可能读多个字节。

· 处理对象不同：字节流可以处理任何类型的数据，如图片、avi等，而字符流只能处理字符类型的数据。

Java流操作的相关类或接口

File – 文件类

RandomAccessFile – 随机存储文件类

InputStream – 字节输入流

OutputStream – 字节输出流

Reader – 字符输入流

Writer – 字符输出流

字节流简单介绍

InputStream

它的子类中：

（1） ByteArrayInputStream、StringBufferInputStream、FileInputStream是三种基本的介质流，它们分别从Byte数组、StringBuffer、和本地文件中读取数据，PipedInputStream是从与其他线程共用的管道中读取数据。

（2）ObjectInputStream和所有FilterInputStream 的子类都是装饰流（装饰器模式的主角）。

ByteArrayInputStream

ByteArrayInputStream包含一个内部缓冲区，其中包含可从流中读取的字节。 内部计数器跟踪read方法提供的下一个字节。

关闭ByteArrayInputStream无效。 在关闭流之后可以调用此类中的方法，而不生成IOException 。

构造方法

方法	描述
ByteArrayInputStream(byte [] a)	接收字节数组作为参数
ByteArrayInputStream(byte []a, int off, int len)	接收一个字节数组，和两个整形变量 off、len，off表示第一个读取的字节，len表示读取字节的长度

常用方法

方法	描述
public int read()	从此输入流中读取下一个数据字节。
public int read(byte[] r, int off, int len)	将最多 len个数据字节从此输入流读入字节数组。
public int available()	返回可不发生阻塞地从此输入流读取的字节数。
public void mark(int read)	设置流中的当前标记位置。
public long skip(long n)	从此输入流中跳过 n 个输入字节
public void reset()	回到标记的位置

举个例子

String s = "hello, world";
byte[] a = s.getBytes();
byte[] c = new byte[a.length];
ByteArrayInputStream in = new ByteArrayInputStream(a);
System.out.println(in.available());
// 标记
in.mark(0);
// 全部输出给c
in.read(c);
// 重置读取的位置
in.reset();
int b;
while((b = in.read()) != -1) {
    System.out.print(Character.toUpperCase((char)b));
}
System.out.println();
for(int i=0;i<c.length;i++) {
    System.out.print(Character.toUpperCase((char)c[i]));
}
System.out.println();

FileInputStream

FileInputStream从文件系统中的文件获取输入字节。 可用的文件取决于主机环境。

FileInputStream用于读取诸如图像数据的原始字节流。 要读取字符流，考虑使用FileReader

构造方法

方法	描述
FileInputStream(File对象)	接收文件对象作为参数
FileInputStream(FilePath)	接收文件路径作为参数
FileInputStream(FileDescriptor fdObj)	使用文件描述符 fdObj创建 FileInputStream，该文件描述符表示与文件系统中实际文件的现有连接。

常用方法

方法	描述
public int read()	从此输入流中读取下一个数据字节。
public int read(byte[] r, int off, int len)	将最多 len个数据字节从此输入流读入字节数组。
public int available()	返回可不发生阻塞地从此输入流读取的字节数。
public void mark(int read)	设置流中的当前标记位置。
public long skip(long n)	从此输入流中跳过 n 个输入字节
public void reset()	回到标记的位置
getChannel()	返回与此文件输入流关联的唯一FileChannel对象。
getFD()	返回 FileDescriptor对象，该对象表示与此 FileInputStream正在使用的文件系统中的实际文件的连接。

举个例子

File file = new File("./IOStudy/in.txt");
FileInputStream in = new FileInputStream(file);
int b;
while((b = in.read()) != -1) {
    System.out.print(Character.toUpperCase((char)b));
}
System.out.println();

PipedInputStream

管道输入流应连接到管道输出流; 然后，管道输入流提供写入管道输出流的任何数据字节。 通常，一个线程从PipedInputStream对象读取数据，并且某些其他线程将数据写入相应的PipedOutputStream 。 建议不要尝试使用单个线程中的两个对象，因为它可能使线程死锁。 管道输入流包含缓冲区，在一定限度内将读操作与写操作解耦。 如果为连接的管道输出流提供数据字节的线程不再存在， 则称管道为broken 。

构造方法

方法	描述
PipedInputStream()	创建一个 PipedInputStream，使它还不是 connected 。
PipedInputStream(int pipeSize)	创建一个 PipedInputStream，使其尚未 connected并使用指定的管道大小作为管道缓冲区。
PipedInputStream(PipedOutputStream src)	创建 PipedInputStream，使其连接到管道输出流 src 。
PipedInputStream(PipedOutputStream src, int pipeSize)	创建一个 PipedInputStream ，使其连接到管道输出流 src并使用指定的管道大小作为管道缓冲区。

常用方法

方法	描述
public int read()	从此输入流中读取下一个数据字节。
public int read(byte[] r, int off, int len)	将最多 len个数据字节从此输入流读入字节数组。
public int available()	返回可不发生阻塞地从此输入流读取的字节数。
public long skip(long n)	从此输入流中跳过 n 个输入字节
public void connect(PipedOutputStream src)	与管道输出流连接

举个例子

// 当不用的时候，注意close
PipedInputStream in = new PipedInputStream();
PipedOutputStream out = new PipedOutputStream();
in.connect(out);
String s = "hello, world";
byte[] a = s.getBytes();
out.write(a);
out.close();
int b = 0;
while((b = in.read()) != -1) {
    System.out.print(Character.toUpperCase((char)b));
}
in.close();
System.out.println();

ObjectInputStream

• 序列化和反序列化：Java 序列化 | 菜鸟教程 (runoob.com)
• 将一个特定的数据结构转换为一组字节的过程称之为序列化
• 将一组字节转换为特定的数据结构的过程称之为反序列化
• 持久化：
• 将数据写入硬盘长久保存的过程称之为持久化
  只能将支持 java.io.Serializable 接口的对象写入流中。每个 serializable 对象的类都被编码，编码内容包括类名和类签名、对象的字段值和数组值，以及从初始对象中引用的其他所有对象的闭包。

ObjectInputStream 反序列化流，将之前使用 ObjectOutputStream 序列化的原始数据恢复为对象，以流的方式读取对象。

构造方法

方法	描述
ObjectInputStream(InputStream in)	创建从指定 InputStream 读取的 ObjectInputStream。从流读取序列化头部并予以验证。在对应的 ObjectOutputStream 写入并刷新头部之前，此构造方法将阻塞。

常用方法

方法	描述
readObject()	从 ObjectInputStream 读取对象。对象的类、类的签名和类及所有其超类型的非瞬态和非静态字段的值都将被读取。
readxxx()	读取某一类型的数据

举个例子

static class A implements Serializable{
    int a,b;
    private static final long serialVersionUID = 6871740251451383067L;
    A(int a,int b) {
        this.a = a;
        this.b = b;
    }
    public static long getSerialversionuid() {
        return serialVersionUID;
    }
}

IOtest(String args[]) throws Exception{
    ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("in.txt"));
    A a = new A(1,2);
    out.writeObject(a);
    out.write(1);
    out.close();
    ObjectInputStream in = new ObjectInputStream(new FileInputStream("in.txt"));
    A b = (A)in.readObject();
    System.out.println(b.a + " " + b.b);
    System.out.println(in.read());
}

DataInputStream

数据输入流允许应用程序以与机器无关的方式从底层输入流中读取原始Java数据类型。 应用程序使用数据输出流来写入稍后可由数据输入流读取的数据。

DataInputStream对于多线程访问不一定安全。 线程安全是可选的。

构造方法

方法	描述
DataInputStream(InputStream in)	接收InputStream对象作为参数

常用方法

方法	描述
public final int read(byte[] r, int off, int len)	从所包含的输入流中将 len 个字节读入一个字节数组中。如果len为-1，则返回已读字节数。
Public final int read(byte [] b)	从所包含的输入流中读取一定数量的字节，并将它们存储到缓冲区数组 b 中。
public final Boolean readBooolean()	从输入流中读取字节，返回输入流中两个字节作为对应的基本数据类型返回值。
public final byte readByte()	从输入流中读取字节，返回输入流中两个字节作为对应的基本数据类型返回值。
public final short readShort()	从输入流中读取字节，返回输入流中两个字节作为对应的基本数据类型返回值。
public final Int readInt()	从输入流中读取字节，返回输入流中两个字节作为对应的基本数据类型返回值。
public String readLine()	从输入流中读取下一文本行
public String readUTF()	从输入流中读取一个UTF编码的数据

举个例子

DataInputStream in = new DataInputStream(new FileInputStream("./IOStudy/in.txt"));
DataOutputStream out = new DataOutputStream(new FileOutputStream("./IOStudy/in.txt"));
for(int i=1;i<=12;i++) {
    out.write(i);
}
int a;
while((a = in.readInt()) != -1) {
    System.out.print(a + " ");
}
System.out.println();

BufferedInputStream

提供缓冲输入流功能。缓冲输入流相对于普通输入流的优势是，它提供了一个缓冲数组，每次调用read方法的时候，它首先尝试从缓冲区里读取数据，若读取失败（缓冲区无可读数据），则选择从物理数据源（譬如文件）读取新数据（这里会尝试尽可能读取多的字节）放入到缓冲区中，最后再将缓冲区中的内容部分或全部返回给用户.由于从缓冲区里读取数据远比直接从物理数据源（譬如文件）读取速度快。

BufferedInputStream向另一个输入流添加功能 - 即缓冲输入并支持mark和reset方法的功能。 创建BufferedInputStream将创建内部缓冲区阵列。 当读取或跳过来自流的字节时，内部缓冲区根据需要从包含的输入流中重新填充，一次多个字节。 mark操作会记住输入流中的一个点，并且reset操作会导致在从包含的输入流中获取新字节之前重新读取自最近的mark操作以来读取的所有字节。

构造方法

方法	描述
BufferedInputStream(InputStream in)	接收InputStream对象作为参数
BufferedInputStream(InputStream in, int size)	创建具有指定缓冲区大小的 BufferedInputStream ，并保存其参数（输入流 in ）供以后使用。

常用方法

方法	描述
public int read()	从此输入流中读取下一个数据字节。
public int read(byte[] r, int off, int len)	将最多 len个数据字节从此输入流读入字节数组。
public int available()	返回可不发生阻塞地从此输入流读取的字节数。
public void mark(int read)	设置流中的当前标记位置。
public long skip(long n)	从此输入流中跳过 n 个输入字节
public void reset()	回到标记的位置
public boolean markSupported()	判断是否支持标记

举个例子

BufferedInputStream in = new BufferedInputStream(new FileInputStream("./IOStudy/in.txt"));
int a;
while((a = in.read()) != -1) {
    System.out.print(Character.toUpperCase((char) a));
}
System.out.println();

OutputStream

它的子类中：

（1） ByteArrayOutputStream、FIleOutputStream是两种基本的介质，它们分别向Byte 数组，和本地文件中写入数据。PipedOutputStream是从与其他线程共用的管道中写入数据。

（2） ObjectOutputStream和所有FilterOutputStream的子类都是装饰流。

ByteArrayOutputStream

字节数组输出流在内存中创建一个字节数组缓冲区，所有发送到输出流的数据保存在该字节数组缓冲区中。

构造方法

方法	描述
ByteArrayOutputStream()	默认流的大小32字节
ByteArrayOutputStream(int a)	传入参数设置流的大小

常用方法

方法	描述
public void reset()	将此字节数组输出流的 count 字段重置为零，从而丢弃输出流中目前已累积的所有数据输出。
public byte[] toByteArray()	创建一个新分配的字节数组。数组的大小和当前输出流的大小，内容是当前输出流的拷贝。
public String toString()	将缓冲区的内容转换为字符串，根据平台的默认字符编码将字节转换成字符。
public void write(int w)	将指定的字节写入此字节数组输出流。
public void write(byte []b, int off, int len)	将指定字节数组中从偏移量 off 开始的 len 个字节写入此字节数组输出流。
public void writeTo(OutputStream outSt)	将此字节数组输出流的全部内容写入到指定的输出流参数中。

举个例子

ByteArrayOutputStream out = new ByteArrayOutputStream();
while(out.size() != 12) {
    out.write(System.in.read());
}
byte a[] = out.toByteArray();
ByteArrayInputStream in = new ByteArrayInputStream(a);
int b = 0;
while((b = in.read()) != -1) {
    System.out.print((char)b);
}
System.out.println();

FIleOutputStream

文件输出流是用于将数据写入File或FileDescriptor的输出流。 文件是否可用或是否可以创建取决于底层平台。 特别是某些平台允许一次仅打开一个文件以供写入FileOutputStream （或其他文件写入对象）。 在这种情况下，如果涉及的文件已经打开，则此类中的构造函数将失败。

构造方法

方法	描述
FileOutputStream(File/Path)	File对象或者文件路径作为参数
FileOutputStream(File/Path,bool append)	append为true表示增加，false表示覆盖

常用方法

方法	描述
public void write(int w)	将指定的字节写入此字节数组输出流。
public void write(byte []b, int off, int len)	将指定字节数组中从偏移量 off 开始的 len 个字节写入此字节数组输出流。
getChannel()	返回与此文件输出流关联的唯一FileChannel对象。
getFD()	返回与此流关联的文件描述符。

举个例子

FileOutputStream out = new FileOutputStream("./IOStudy/in.txt",true);
String s = "hello, world";
byte[] a = s.getBytes();
out.write(a);
out.close();

PipedOutputStream

管道输出流可以连接到管道输入流以创建通信管道。 管道输出流是管道的发送端。 通常，数据由一个线程写入PipedOutputStream对象，并且由其他线程从连接的PipedInputStream读取数据。 建议不要尝试使用单个线程中的两个对象，因为它可能使线程死锁。 如果从连接的管道输入流读取数据字节的线程不再存在， 则称该管道为broken 。

构造方法

方法	描述
PipedOutputStream()	创建管道输出流
PipedOutputStream(PipedInputStream snk)	创建管道输出流并绑定管道输入流

常用方法

方法	描述
public void write(int w)	将指定的字节写入此字节数组输出流。
public void write(byte []b, int off, int len)	将指定字节数组中从偏移量 off 开始的 len 个字节写入此字节数组输出流。
public void connect(PipedInputStream src)	与管道输入流连接

举个例子

PipedInputStream in = new PipedInputStream();
PipedOutputStream out = new PipedOutputStream();
in.connect(out);
String s = "hello, world";
byte[] a = s.getBytes();
out.write(a);
out.close();
int b = 0;
while((b = in.read()) != -1) {
    System.out.print(Character.toUpperCase((char)b));
}
in.close();
System.out.println();

ObjectOutputStream

将对象序列化输入到流中

构造方法

方法	描述
public ObjectOutputStream(OutputStream out)	创建写入指定 OutputStream 的 ObjectOutputStream。此构造方法将序列化流部分写入底层流；调用者可以通过立即刷新流，确保在读取头部时，用于接收 ObjectInputStreams 构造方法不会阻塞。

常用方法

方法	描述
public final Object writeObject()	向 ObjectOutputStream 写入对象。
writexxx()	向 ObjectOutputStream 写入类型为xxx的数据

举个例子

static class A implements Serializable{
    int a,b;
    private static final long serialVersionUID = 6871740251451383067L;
    A(int a,int b) {
        this.a = a;
        this.b = b;
    }
    public static long getSerialversionuid() {
        return serialVersionUID;
    }
}

IOtest(String args[]) throws Exception{
    ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("in.txt"));
    A a = new A(1,2);
    out.writeObject(a);
    out.write(1);
    out.close();
    ObjectInputStream in = new ObjectInputStream(new FileInputStream("in.txt"));
    A b = (A)in.readObject();
    System.out.println(b.a + " " + b.b);
    System.out.println(in.read());
}

DataOutputStream

数据输出流允许应用程序以与机器无关方式将Java基本数据类型写到底层输出流

构造函数

方法	描述
DataOutputStream(OutputStream out)	接收OutputStream对象作为参数

常用方法

方法	描述
public final void write(byte[] w, int off, int len)	将指定字节数组中从偏移量 off 开始的 len 个字节写入此字节数组输出流。
Public final int write(byte [] b)	将指定的字节写入此字节数组输出流。
public final void writeBooolean()	指定的基本数据类型以字节的方式写入到输出流。
public final void writeByte()	指定的基本数据类型以字节的方式写入到输出流。
public final void writeShort()	指定的基本数据类型以字节的方式写入到输出流。
public final void writeInt()	指定的基本数据类型以字节的方式写入到输出流。
Public void flush()	刷新此输出流并强制写出所有缓冲的输出字节。
public final void writeBytes(String s)	将字符串以字节序列写入到底层的输出流，字符串中每个字符都按顺序写入，并丢弃其高八位。

举个例子

DataInputStream in = new DataInputStream(new FileInputStream("./IOStudy/in.txt"));
DataOutputStream out = new DataOutputStream(new FileOutputStream("./IOStudy/in.txt"));
for(int i=1;i<=12;i++) {
    out.write(i);
}
int a;
while((a = in.readInt()) != -1) {
    System.out.print(a + " ");
}
System.out.println();

PrintStream

PrintStream向另一个输出流添加功能，即能够方便地打印各种数据值的表示。 还提供了另外两个功能。 与其他输出流不同， PrintStream永远不会抛出IOException ; 相反，异常情况仅设置可通过checkError方法测试的内部标志。 可选地，可以创建PrintStream以便自动刷新; 这意味着flush字节数组写入方法后自动调用，所述一个println方法被调用时，或者一个新行字符或字节（ '\n' ）被写入。

PrintStream打印的所有字符都使用给定的编码或字符集转换为字节，如果未指定，则使用平台的默认字符编码。 PrintWriter类应该在需要写入字符而不是字节的情况下使用。

此类始终使用charset的默认替换字符串替换格式错误且不可映射的字符序列。 当需要更多地控制编码过程时，应使用CharsetEncoder类。

构造方法

方法	描述
PrintStream(File file)	使用指定的文件创建没有自动行刷新的新打印流。
PrintStream(File file, String csn)	使用指定的文件和字符集创建一个没有自动行刷新的新打印流。
PrintStream(File file, Charset charset)	使用指定的文件和字符集创建一个没有自动行刷新的新打印流。
PrintStream(OutputStream out)	创建新的打印流。
PrintStream(OutputStream out, boolean autoFlush)	创建新的打印流。
PrintStream(OutputStream out, boolean autoFlush, String encoding)	创建新的打印流。
PrintStream(OutputStream out, boolean autoFlush, Charset charset)	创建一个新的打印流，具有指定的OutputStream，自动行刷新和字符集。
PrintStream(String fileName)	使用指定的文件名创建没有自动行刷新的新打印流。
PrintStream(String fileName, String csn)	使用指定的文件名和字符集创建一个没有自动行刷新的新打印流。
PrintStream(String fileName, Charset charset)	使用指定的文件名和字符集创建一个没有自动行刷新的新打印流。

常用方法

方法	描述
public void print()	对标python中的print，将类型数据对应字符串写到PrintStream流中
public void println()	将类型数据对应字符串写到PrintStream流中
public void printf()	对标c++的printf，将格式化后的字符串写到PrintStream流中
public void format()	类似printf()

举个例子

PrintStream out = new PrintStream(System.out);
out.println(1);
out.print("hello, world");
out.printf("%d\n",5);
out.format("%d\n" + "%d\n",5,6);

字符流简单介绍

Reader

Reader 类的常用子类如下。

• CharArrayReader 类：将字符数组转换为字符输入流，从中读取字符。
• StringReader 类：将字符串转换为字符输入流，从中读取字符。
• InputStreamReader 类：将字节输入流转换为字符输入流，可以指定字符编码。
• BufferedReader 类：为其他字符输入流提供读缓冲区。
• PipedReader 类：连接到一个 PipedWriter。

CharArrayReader

将字符数组转换为字符输入流，从中读取字符。

构造函数

方法	描述
CharArrayReader(char[] buf)	传入字符数组作为输入流
CharArrayReader(char[] buf, int offset, int length)	接收一个字符数组，和两个整形变量 off、len，off表示第一个读取的字符，len表示读取字符的长度

常用方法

方法	描述
public int read()	从此输入流中读取下一个数据字符。
public int read(char[] r, int offset, int len)	将最多 len个数据字符从此输入流读入字符数组。
public int available()	返回可不发生阻塞地从此输入流读取的字符数。
public void mark(int read)	设置流中的当前标记位置。
public long skip(long n)	从此输入流中跳过 n 个输入字符
public void reset()	回到标记的位置

举个例子

char a[] = {'h','e','l','l','o',',',' ','w','o','r','l','d'};
char c[] = new char[a.length];
CharArrayReader in = new CharArrayReader(a);
in.mark(0);
in.read(c);
in.reset();
int b;
while((b = in.read()) != -1) {
    System.out.print((char) b);
}
System.out.println();
for(int i=0;i<c.length;i++) {
    System.out.print(c[i]);
}
System.out.println();

StringReader

将字符串转换为字符输入流，从中读取字符。

构造函数

方法	描述
StringReader(String s)	接收字符串作为输入流

常用方法

方法	描述
public int read()	从此输入流中读取下一个数据字符。
public int read(char cbuf[], int off, int len)	将最多 len个数据字符从此输入流读入字符数组。
public int available()	返回可不发生阻塞地从此输入流读取的字符数。
public void mark(int read)	设置流中的当前标记位置。
public long skip(long n)	从此输入流中跳过 n 个输入字符
public void reset()	回到标记的位置

举个例子

String s = "hello, world";
StringReader in = new StringReader(s);
int b;
while((b = in.read()) != -1) {
    System.out.print((char) b);
}
System.out.println();

InputStreamReader

InputStreamReader是从字节流到字符流的桥接器：它使用指定的charset读取字节并将其解码为字符。 它使用的字符集可以通过名称指定，也可以明确指定，或者可以接受平台的默认字符集。

每次调用一个InputStreamReader的read（）方法都可能导致从底层字节输入流中读取一个或多个字节。 为了实现字节到字符的有效转换，可以从基础流中提取比满足当前读取操作所需的更多字节。

构造方法

方法	描述
InputStreamReader(Inputstream in)	创建一个使用默认字符集的 InputStreamReader。
InputStreamReader(Inputstream in，Charset cs)	创建使用给定字符集的 InputStreamReader。
InputStreamReader(InputStream in, CharsetDecoder dec)	创建使用给定字符集解码器的 InputStreamReader。
InputStreamReader(InputStream in, String charsetName)	创建使用指定字符集的 InputStreamReader。

常用方法

方法	描述
public int read()	从此输入流中读取下一个数据字符。
public int read(char cbuf[], int off, int len)	将最多 len个数据字符从此输入流读入字符数组。
public boolean ready()	判断此流是否已经准备好用于读取
public long skip(long n)	从此输入流中跳过 n 个输入字符
String getEncoding()	返回此流使用的字符编码的名称

举个例子

byte a[] = "你好".getBytes();
InputStreamReader in = new InputStreamReader(new ByteArrayInputStream(a));
System.out.println(in.getEncoding());
int b;
while((b = in.read()) != -1) {
    System.out.print((char) b + " ");
}
System.out.println();
in.close();

BufferedReader

为其他字符输入流提供读缓冲区

构造方法

方法	描述
BufferedReader(Reader in)	创建一个缓冲字符输入流，该流使用带有指定Reader对象的默认大小的输入缓冲区。
BufferedReader(Reader in, int sz)	创建一个缓冲字符输入流，该流使用具有指定Reader对象的指定大小的输入缓冲区

常用方法

public int read()	从此输入流中读取下一个数据字符。
public int read(char cbuf[], int off, int len)	将最多 len个数据字符从此输入流读入字符数组。
public boolean ready()	判断此流是否已经准备好用于读取
public void mark(int read)	设置流中的当前标记位置。
public long skip(long n)	从此输入流中跳过 n 个输入字符
public void reset()	回到标记的位置
public String readLine()	读入一行，某行被认为由换行符（’\ n’），回车符（’\ r’）或回车符（紧随换行符）中的任何一个终止。

举个例子

byte a[] = "你\n\n好\n".getBytes();
BufferedReader in = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(a)));
System.out.print(in.readLine());
System.out.print((char) in.read());
System.out.print((char) in.read());

PipedReader

连接到一个 PipedWriter

构造方法

方法	描述
PipedReader()	创建一个 PipedReader ，使它还不是 connected 。
PipedReader(int pipeSize)	创建 PipedReader ，使其尚未 connected，并使用指定的管道大小作为管道缓冲区。
PipedReader(PipedWriter src)	创建一个 PipedReader以便它连接到管道 src 。
PipedReader(PipedWriter src, int pipeSize)	创建 PipedReader ，使其连接到管道写入器 src并使用指定的管道大小作为管道缓冲区。

常用方法

方法	描述
public int read()	从此输入流中读取下一个字符。
public int read(char[] r, int off, int len)	将最多 len个字符从此输入流读入字符数组。
public long skip(long n)	从此输入流中跳过 n 个输入字符
public void connect(PipedWriter src)	与管道输出流连接

举个例子

PipedReader in = new PipedReader();
PipedWriter out = new PipedWriter();
in.connect(out);
System.out.println(in.markSupported());
String s = "hello, world";
for(int i=0;i<s.length();i++) {
    out.write(s.charAt(i));
}
int b;
out.close();
while((b = in.read()) != -1) {
    System.out.print((char) b);
}
System.out.println();
in.close();

Writer

常用子类如下

• CharArrayWriter、StringWriter 是两种基本的介质流.

• OutputStreamWriter 是OutputStream 到Writer 转换到桥梁。

• BufferedWriter 很明显是一个装饰器，他和其子类复制装饰其他Reader对象。

• PipedWriter 是从与其他线程共用的管道中写入数据。

• PrintWriter, 与PrintStream 类似，功能和使用也非常相似。

CharArrayWriter

在字符缓冲区中收集其输出的字符流，然后可用于构造字符串。

构造函数

构造器	描述
CharArrayWriter()	创建一个新的CharArrayWriter。
CharArrayWriter(int initialSize)	创建具有指定初始大小的新CharArrayWriter。

常用方法

方法	描述
append(char c)	将指定的字符追加到此writer。
append(CharSequence csq)	将指定的字符序列追加到此writer。
append(CharSequence csq)	将指定的字符序列追加到此writer。
close()	关闭流。
flush()	冲洗流。
reset()	重置缓冲区，以便您可以再次使用它而不会丢弃已分配的缓冲区。
size()	返回缓冲区的当前大小。
toCharArray()	返回输入数据的副本。
toString()	将输入数据转换为字符串。
write(char[] c, int off, int len)	将字符写入缓冲区。
write(int c)	将字符写入缓冲区。
write(String str, int off, int len)	将一部分字符串写入缓冲区。
writeTo(Writer out)	将缓冲区的内容写入另一个字符流。

举个例子

CharArrayWriter out = new CharArrayWriter();
String s = "hello, world";
char c[] = s.toCharArray();
out.write(c);
char a[] = out.toCharArray();
for(char i : a) System.out.print(i);
System.out.println();
CharSequence d = "hello, world";

out.append(d);
char b[] = out.toCharArray();
for(char i : b) System.out.print(i);
System.out.println();

out.reset();

char e[] = out.toCharArray();
for(char i : e) System.out.print(i);
System.out.println();

out.close();

StringWriter

在字符串缓冲区中收集其输出的字符流，然后可用于构造字符串。

构造函数

方法	描述
StringWriter()	使用默认的初始字符串缓冲区大小创建新的字符串编写器。
StringWriter(int initialSize)	使用指定的初始字符串缓冲区大小创建新的字符串writer。

常用方法

方法	描述
append(char c)	将指定的字符追加到此writer。
append(CharSequence csq)	将指定的字符序列追加到此writer。
append(CharSequence csq, int start, int end)	将指定字符序列的子序列追加到此writer。
close()	关闭 StringWriter无效。
flush()	冲洗流。
getBuffer()	返回字符串缓冲区本身。
toString()	将缓冲区的当前值作为字符串返回。
write(char[] cbuf, int off, int len)	写一个字符数组的一部分。
write(int c)	写一个字符。
write(String str, int off, int len)	写一个字符串的一部分。

举个例子

StringWriter out = new StringWriter();
String s = "hello, world";
char c[] = s.toCharArray();
out.write(c);
StringBuffer a = out.getBuffer();
System.out.println(a);
CharSequence d = "hello, world";

out.append(d);
String b = out.toString();
System.out.println(b);

out.close();

OutputStreamWriter

OutputStreamWriter是从字符流到字节流的桥接器：使用指定的charset将写入其中的字符编码为字节。 它使用的字符集可以通过名称指定，也可以明确指定，或者可以接受平台的默认字符集。

每次调用write（）方法都会导致在给定字符上调用编码转换器。 生成的字节在写入底层输出流之前在缓冲区中累积。 请注意，传递给write（）方法的字符不会被缓冲。

为了获得最高效率，请考虑在BufferedWriter中包装OutputStreamWriter，以避免频繁的转换器调用。 例如：

构造函数

方法	描述
OutputStreamWriter(OutputStream out)	创建使用默认字符编码的OutputStreamWriter。
OutputStreamWriter(OutputStream out, String charsetName)	创建使用指定charset的OutputStreamWriter。
OutputStreamWriter(OutputStream out, Charset cs)	创建使用给定charset的OutputStreamWriter。
OutputStreamWriter(OutputStream out, CharsetEncoder enc)	创建使用给定charset编码器的OutputStreamWriter。

常用方法

方法	描述
flush()	刷新流。
getEncoding()	返回此流使用的字符编码的名称。
write(char[] cbuf, int off, int len)	写一个字符数组的一部分。
write(int c)	写一个字符。
write(String str, int off, int len)	写一个字符串的一部分。

举个例子

OutputStreamWriter out = new OutputStreamWriter(System.out);
String a = "hello, world";
out.write(a);
out.flush();
out.write(out.getEncoding());
out.flush();
out.close();

BufferedWriter

将文本写入字符输出流，缓冲字符，以便有效地写入单个字符，数组和字符串。

可以指定缓冲区大小，或者可以接受默认大小。 对于大多数用途，默认值足够大。

提供了一个newLine（）方法，它使用平台自己的行分隔符概念，由系统属性line.separator定义。 并非所有平台都使用换行符（’\n’）来终止行。 因此，调用此方法终止每个输出行比直接编写换行符更为可取。

通常，Writer会立即将其输出发送到基础字符或字节流。 除非需要提示输出，否则建议将BufferedWriter包装在任何write（）操作可能代价高昂的Writer周围，例如FileWriters和OutputStreamWriters。

构造函数

方法	描述
BufferedWriter(Writer out)	创建使用默认大小的输出缓冲区的缓冲字符输出流。
BufferedWriter(Writer out, int sz)	创建一个使用给定大小的输出缓冲区的新缓冲字符输出流。

常用方法

方法	描述
flush()	刷新流。
newLine()	写一个行分隔符。
write(char[] cbuf, int off, int len)	写一个字符数组的一部分。
write(int c)	写一个字符。
write(String s, int off, int len)	写一个字符串的一部分。

举个例子

BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
String s = "hello, world";
out.write(s);
out.newLine();
out.write(s);
out.flush();
out.close();

PipedWriter

管道字符输出流。

构造函数

方法	描述
PipedWriter()	创建一个尚未连接到管道读取器的管道编写器。
PipedWriter(PipedReader snk)	创建连接到指定管道读取器的管道编写器。

常用方法

方法	描述
close()	关闭此管道输出流并释放与此流关联的所有系统资源。
connect(PipedReader snk)	将此管道编写器连接到接收器。
flush()	刷新此输出流并强制写出任何缓冲的输出字符。
write(char[] cbuf, int off, int len)	将指定字符数组中的 len字符从偏移量 off开始写入此管道输出流。
write(int c)	将指定的 char写入管道输出流。

举个例子

PipedReader in = new PipedReader();
PipedWriter out = new PipedWriter();
in.connect(out);
System.out.println(in.markSupported());
String s = "hello, world";
for(int i=0;i<s.length();i++) {
    out.write(s.charAt(i));
}
int b;
out.close();
while((b = in.read()) != -1) {
    System.out.print((char) b);
}
System.out.println();
in.close();

PrintWriter

将对象的格式化表示打印到文本输出流。 这个类实现所有的print中发现的方法PrintStream。 它不包含写入原始字节的方法，程序应使用未编码的字节流。

不像PrintStream类，如果启用自动刷新，将只有当一个做println ， printf ，或format被调用的方法，而不是当一个换行符恰好是输出。 这些方法使用平台自己的行分隔符概念而不是换行符。

这个类中的方法永远不会抛出I / O异常，尽管它的一些构造函数可能会。 客户端可以通过调用checkError()来查询是否发生了任何错误。

此类始终使用charset的默认替换字符串替换格式错误且不可映射的字符序列。 当需要对编码过程进行更多控制时，应使用CharsetEncoder类。

构造函数

方法	描述
PrintWriter(File file)	使用指定的文件创建一个没有自动行刷新的新PrintWriter。
PrintWriter(File file, String csn)	使用指定的文件和字符集创建一个没有自动行刷新的新PrintWriter。
PrintWriter(File file, Charset charset)	使用指定的文件和字符集创建一个没有自动行刷新的新PrintWriter。
PrintWriter(OutputStream out)	从现有的OutputStream创建一个没有自动行刷新的新PrintWriter。
PrintWriter(OutputStream out, boolean autoFlush)	从现有的OutputStream创建一个新的PrintWriter。
PrintWriter(OutputStream out, boolean autoFlush, Charset charset)	从现有的OutputStream创建一个新的PrintWriter。
PrintWriter(Writer out)	创建一个新的PrintWriter，没有自动行刷新。
PrintWriter(Writer out, boolean autoFlush)	创建一个新的PrintWriter。
PrintWriter(String fileName)	使用指定的文件名创建一个没有自动行刷新的新PrintWriter。
PrintWriter(String fileName, String csn)	使用指定的文件名和字符集创建一个没有自动行刷新的新PrintWriter。
PrintWriter(String fileName, Charset charset)	使用指定的文件名和字符集创建一个没有自动行刷新的新PrintWriter。

常用方法

方法	描述
append(char c)	将指定的字符追加到此writer。
append(CharSequence csq)	将指定的字符序列追加到此writer。
append(CharSequence csq, int start, int end)	将指定字符序列的子序列追加到此writer。
checkError()	如果流未关闭则刷新流并检查其错误状态。
clearError()	清除此流的错误状态。
close()	关闭流并释放与其关联的所有系统资源。
flush()	刷新流。
format(String format, Object… args)	使用指定的格式字符串和参数将格式化的字符串写入此writer。
format(Locale l, String format, Object… args)	使用指定的格式字符串和参数将格式化的字符串写入此writer。
print(boolean b)	打印一个布尔值。
print(char c)	打印一个角色。
print(char[] s)	打印一个字符数组。
print(double d)	打印双精度浮点数。
print(float f)	打印浮点数。
print(int i)	打印整数。
print(long l)	打印一个长整数。
print(Object obj)	打印一个对象。
print(String s)	打印一个字符串。
printf(String format, Object… args)	使用指定的格式字符串和参数将格式化字符串写入此writer的便捷方法。
printf(Locale l, String format, Object… args)	使用指定的格式字符串和参数将格式化字符串写入此writer的便捷方法。
println()	通过写行分隔符字符串来终止当前行。
println(boolean x)	打印一个布尔值，然后终止该行。
println(char x)	打印一个字符，然后终止该行。
println(char[] x)	打印一个字符数组，然后终止该行。
println(double x)	打印双精度浮点数，然后终止该行。
println(float x)	打印一个浮点数，然后终止该行。
println(int x)	打印一个整数，然后终止该行。
println(long x)	打印一个长整数，然后终止该行。
println(Object x)	打印一个对象，然后终止该行。
println(String x)	打印一个字符串，然后终止该行。
setError()	表示发生了错误。
write(char[] buf)	写一个字符数组。
write(char[] buf, int off, int len)	写入一个字符数组的一部分。
write(int c)	写一个字符。
write(String s)	写一个字符串。
write(String s, int off, int len)	写一个字符串的一部分。

举个例子

PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
String a = "hello, world";
int b = 1;
double c = 5.0;
out.println(a);
out.print(a);
out.println();
out.print(a);
out.format("%d\n",b);
out.printf("%d\n",b);
out.printf("%f\n",c);
out.format("%f\n",c);
out.append('n');
out.flush();

参考

java.io (Java SE 11 & JDK 11 ) (runoob.com)