android基础-Java篇9：IO系统

File类(API文档: File)

File可以代表一个特定文件的名称，又能代表一个目录下的一组文件的名称，如果是文件集，可以通过方法（list系列方法），使其返回目录列表。

既然File对象代表的是对文件和目录的指定（引用），该类也可以用于文件和目录的创建、查找、删除等。

构造方法：

File(String path):在指定路径下构造一个新实例

File(File dir, String name):在指定的目录(dir)下构建一个指定名称(name)的新实例

File(String dirPath, String name):在指定的目录路径(dirPath)下构建一个指定名称(name)的新实例

File(URI uri):在指定的路径(URI转换的)下构造一个新实例

File方法主要如下

String getName():返回由此实例表示的文件或目录的名称。

String getParent()：返回此实例的父路径名(字符串)，如果没有指定父目录，则返回 null。

File getParentFile():返回此实例的父路径名的File对象，如果没有指定父目录，则返回 null。

String getPath():以字符串的形式返回此实例所表示的路径。

boolean isAbsolute():此实例是否为绝对路径名。

String getAbsolutePath():以字符串的形式返回此实例的绝对路径名。

boolean canRead():应用程序是否可以读取此实例表示的文件。

boolean canWrite():应用程序是否可以修改此实例表示的文件。

boolean exists():此实例所表示的文件或目录是否存在。

boolean isDirectory():此实例所表示的文件是否是一个目录。

boolean isFile():此实例所表示的文件是否是一个标准文件。

long lastModified():返回此实例所表示的文件最后一次被修改的时间。

long length():返回由此实例所表示的文件的长度。

boolean createNewFile():根据存储在此文件中的路径信息(不存在时)在文件系统上创建一个新的空文件。如果该方法创建文件，则此方法返回true;如果该文件已存在，则返回false。请注意，即使文件不是文件，它也会返回false。

boolean delete():删除此实例所表示的文件或目录。

void deleteOnExit():在虚拟机终止时，会请求删除此实例所表示的文件或目录。

String[] list():返回由该实例所表示的目录中文件名称的字符串数组，如果这个文件不是一个目录，返回是null。

String[] list(FilenameFilter filter): 取此文件所表示的目录中的文件列表。然后通过filter过滤器过滤此列表。

File[] listFiles():返回此实例所表示的目录中包含的文件数组。如果这个文件不是一个目录返回null。如果此实例的路径是绝对路径，则数组中文件的路径是绝对路径，否则它们是相对路径。

File[] listFiles(FileFilter filter):

返回此实例所表示的目录中包含的并通过filter过滤器过滤的文件数组。

boolean mkdir():假定父文件存在，创建此实例指定的目录。

boolean mkdirs():创建此实例指定的目录，包括创建必需但不存在的父目录。

boolean renameTo(File newPath): 将该实例所表示的文件重命名为newPath。

boolean setLastModified(long time): 设置此该实例所表示的文件上次修改的时间。

boolean setReadOnly():设置为只能读操作。

int compareTo(File another):按字母顺序比较该实例和another的路径名。

boolean equals(Object obj):测试此对象与给定对象是否相等。

String toString():返回此实例的路径名字符串。

可以看到在IO流体系中，主要分为字节流、字符流

字节流又分为InputStream（输入流）、OutputStream（输出流）

字符流又分为Reader（读取）、Writer（写入）

可以看到IO流指的就是传输的进和出（In-Out），在字节流和字符流中都有所体现，进的为InputStream和Reader，出的为OutputStream和Writer。

字节流和字符流有什么区别？

字节流处理的单位是一个字节，存储的基本单位，操作字节和字节数组，基本涉及存储的数据都可以用字节流来传输。而字符流顾名思义，处理的单位是字符(Unicode字符)，一个字符为两个字节，主要用于文本的传输，因为字符流的基本单位是Unicode字符，所以支持多国语言文本(Unicode也被叫做万国码)。

那么问题又来了，既然字节流这么“强大”，这么“万能”，为什么还需要字符流？

字节流处理的是一个又一个的字节，本身是没办法直接处理Unicode字符，而Unicode字符是通过java虚拟机将字节转化而来，所以说，如果需要使用字节流来处理Unicode字符，中间就需要有一个处理转换的，这么做带来极大的不便。

那么，字节流和字符流该如何选择？

根据上两个问题可以知道，在涉及到文本传输的时候，建议使用字符流，其他类型的传输，如图片、音频等，采用字节流。

 

InputStream（输入流）(API文档: InputStream )

如上图InputStream的子类中主要常用的有：ByteArrayInputStream、StringBufferInputStream、FileInputStream、PipedInputStream、SequenceInputStream、ObjectInputStream、FilterInputStream

ByteArrayInputStream：允许将内存的缓冲区当做InputStream使用，以IO流的方式来完成对字节数组的内容的读取。

StringBufferInputStream(已经过时)：将String转换成InputStream。

FileInputStream：用于向文件中读取信息。

PipedInputStream：产生用于写入相关PipedOutputStream的数据，实现“管道化”概念。

SequenceInputStream：将两个或多个InputStream对象转换成单一InputStream。

ObjectInputStream：以对象为单位的传输，用于读取(重构)对象。

FilterInputStream：抽象类，作为“装饰器”的接口。其中“装饰器”为其他的InputStream类提供了有用的功能。

( “装饰器”出现在装饰器模式中，作用可以理解为用来在对象的外围动态扩展一些动能)

FilterInputStream子类中常用的有DataInputStream、BufferedInputStream、PushbackInputStream

DataInputStream：与DataOutputStream搭配使用，实现可移植方式从流读取基本数据类型。

BufferedInputStream：使用时可以通过缓冲区来防止每次读取数据时都得进行实际写操作。

PushbackInputStream：具有“能弹出一个字节的缓冲区”。因此可以将读到的最后一个字符回退

 

 

OutputStream（输出流） (API文档: OutputStream)

如上图OutputStream的子类中主要常用的有：ByteArrayOutputStream、FileOutputStream、PipedOutputStream、ObjectOutputStream、FilterOutputStream

ByteArrayOutputStream：在内存中创建一个字节数组缓冲区，所有发送到输出流的数据保存在该字节数组缓冲区中，以IO流的方式来完成对字节数组的内容的写入。

FileOutputStream：用于将信息写到文件，对应InputStream的FileInputStream。

PipedOutputStream：任何写入其中的信息都会自动作为相关PipedInputStream的输出。实现“管道化”概念，对应InputStream的PipedInputStream。

ObjectOutputStream：将 Java 对象的基本数据类型和图形写入 OutputStream ，对应InputStream 的ObjectInputStream

FilterOutputStream：抽象类，作为“装饰器”的接口。其中“装饰器”为其他的OutputStream类提供了有用的功能。

FilterOutputStream子类中常用的有DataOutputStream、PrintStream、BufferedOutputStream

DataOutputStream：与DataInputStream搭配使用，实现可移植方式向流写入基本数据类型。

PrintStream：用于产生格式化输出。其中DataOutputStream处理数据的存储，PrintStream处理显示

BufferedOutputStream：使用时可以通过缓冲区来防止每次发送数据时都得进行实际写操作。

 

Reader(API文档: Reader)

如上图，Reader的子类中主要常用的有：BufferedReader、InputStreamReader、FileReader 、StringReader、PipedReader、CharArrayReader、FilterReader、PushbackInputStream

BufferedReader：在作用上和BufferedInputStream一致，使用了缓冲区。

InputStreamReader：将InputStream转换为Reader。

         FileReader：用于向文件中读取信息。

StringReader：对应InputStream中的StringBufferInputStream，实现把字符串作为数据源的输入实现。

PipedReader：产生用于写入相关PipedWriter的数据，实现“管道化”概念。

CharArrayReader：作用上对应ByteArrayInputStream，唯一区别是CharArrayReader是把字符数组作为源的输入实现。

FilterReader：抽象类，作为“装饰器”的接口。其中“装饰器”为其他的Reaber类提供了有用的功能。

         PushbackInputStream：实现“推回”已读取的字节的功能，以便可以再次读取它们。

 

 

Writer (API文档: Writer)

如上图，Writer的子类中主要常用的有：BufferedWriter、OutputStreamWriter、FileWriter 、PrinterWriter、StringWriter、PipedWriter、CharArrayWriter、FilterWriter

BufferedWriter：在作用上和BufferedOutputStream一致，使用了缓冲区。

OutputStreamWriter：将OutputStreamr转换为Write。

         FileWriter：用于将信息写到文件，对应Reader的FileReader。

PrintWriter：和PrintStream以各种各样的格式，打印各种各样的数据。

StringWriter：与StringReader搭配使用，实现把字符串作为数据源的输出实现。

PipedWriter：任何写入其中的信息都会自动作为相关PipedReader的输出。实现“管道化”概念，和PipedReader搭配使用。

CharArrayWriter：作用上对应ByteArrayOutputStream，唯一区别是CharArrayReader是把字符数组作为源的输出实现。

FilterWriter：抽象类，作为“装饰器”的接口。其中“装饰器”为其他的Writer类提供了有用的功能。

上面对InputStream和OutputStream、Reader和Writer常用的子类做了简要介绍，但是很难看出如何使用，正如IO流体系介绍中说的，是一种传输进和出的关系，所以可以在上面看出，InputStream和OutputStream、Reader和Writer中许多子类是两两相对应形成这种关系。

IO流在功能上分类可以分节点流和处理流，节点流是从特定的地方(文件等)读写数据，处理流是是对一个已存在的流的连接和封装（所以属于处理流的类在构造方法里都要传入其他流对象作为参数），为了更好的学习IO流，采用根据更细功能分类的方式去介绍这些类：

内存流：字节内存流、字符内存流、字符串流

字节内存流：ByteArrayInputStream和ByteArrayOutputStream

ByteArrayInputStream构造函数：

ByteArrayInputStream(byte[]buf)：接收字节数组作为参数创建实例

ByteArrayInputStream(byte[] buf, intoffset, int length)：除了接收一个字节数组以外，还指定了第一个读取字节的位置(offset)以及读取字节的长度(length)。

ByteArrayOutputStream构造函数：

ByteArrayOutputStream（）：构造一个默认大小为32字节的缓冲区。

ByteArrayOutputStream（int size）：构造一个指定大小为size字节的缓冲区。

ByteArrayInputStream方法：

synchronized int available() : 返回剩余字节数。

void  close(): 关闭流并回收资源。

synchronized void mark(int readlimit) : 在此输入流中设置标记，readlimit为标记失效之前一定会被读取的字节数。

Boolean markSupported() : 指示此流是否支持mark()和 reset()方法。

synchronized int read() : 从源字节数组中读取单个字节,并将其作为范围从0到255的整数返回。

synchronized int read(byte[] buffer, intbyteOffset, int byteCount) : 从buffer数组的第byteOffset个开始读取，读取数据长度为byteCount。

synchronized void reset() : 将此流重置到最后标记的位置。

synchronized long skip(long byteCount) : 跳过输入流中的byteCount个字节。

ByteArrayOutputStream方法:

void  close():关闭流并回收资源。

synchronized void reset(): 将此流重置到字节数组的开头。

int size():返回至今为止写入的总字节数。

synchronized byte[] toByteArray(): 以字节数组的形式返回此流的内容。

String toString(String charsetName): 使用指定的字符集(charsetName)转换的数据流的内容。

String toString():以字符串形式返回此流的内容。

synchronized void write(byte[] buffer, intoffset, int len): 从buffer数组的第byteOffset个开始写入，写入数据长度为byteCount。

synchronized void write(int oneByte): 将指定的字节写入此字节数组输出流。

synchronized void writeTo(OutputStream out):将此字节数组输出流的全部内容写入到指定的输出流参数中。

 

例程：

public class ByteArrayTest {
public static void main(String args[])throws IOException {
byte[] Bytedata= "666".getBytes();//假设这段字节数组就是要输入进来的数据。

//假设这段数据长度未知，所以采用了List系列的类来存放用来存放从输入流中读取的数据，这里注意的 ArrayList只能存放对象类型。
ByteArrayInputStream byteArrayIn = new ByteArrayInputStream(Bytedata);
ArrayList list=new ArrayList();
while(bInput.read()!= -1) {
list.add( new Byte ( bInput.read() ) );//获取输入流的数据
}
byteArrayIn.close();
// Byteindata就是我们通过输入流传进来的数据,当成未知长度，所以采用遍历的方法。
byte[]Byteindata = new byte[list.size( )];
for(int i =0;i




 

字符内存流：CharArrayReader和CharArrayWriter

CharArrayReader构造函数：

CharArrayReader(char[]buf)：接收字符数组作为参数创建实例

CharArrayReader(char[]buf, int offset, int length)：除了接收一个字符数组以外，还指定了第一个读取字节的位置(offset)以及读取字节的长度(length)。

CharArrayWriter构造函数：

CharArrayWriter（）：构造一个默认大小为32字节的缓冲区。

CharArrayWriter（int initialSize）：构造一个指定大小为size字节的缓冲区。

CharArrayReader方法：

    CharArrayReader的方法很多和ByteArrayInputStream的方法相似，相似的方法有close()、mark(intreadlimit) 、markSupported()、read() 、read(char[] buffer, int offset, int count)、reset() 、skip(longcharCount)，这些方法不详细介绍，注意参数的不同，如skip方法跳过的是charCount个字符等。

Boolean ready()：数据流是否准备好被读取。如果下次可以没有阻塞的情况下进行阅读，返回true。

CharArrayWriter方法：
    CharArrayWriter的方法很多和ByteArrayOutputStream的方法相似，相似的方法有close()、reset()、size()、toCharArray()、toString()、write(char[]buffer, int offset, int len)、write(int oneChar)、writeTo(Writer out)，这些方法不详细介绍。

CharArrayWriter append(charc)：追加(写入)一个指定字符c到CharArrayWriter中，返回一个CharArrayWriter对象

CharArrayWriter append(CharSequencecsq)：将csq字符串写入到CharArrayWriter中，返回一个CharArrayWriter对象。（CharSequence和String一样用来定义字符串，不过CharSequence的值是可读可写的，而String的值是只读。）

CharArrayWriter append(CharSequencecsq, int start, int end)：将csq字符串的第start个（包含）到第end个（不包含）写入到CharArrayWriter中，返回一个CharArrayWriter对象。

void  flush()：刷新该流的缓冲，会强制写出缓冲的输出。

void  write(String str, int offset, int count)：将字符串str写入到输出流中，从第offset个开始读取，count是读取的长度。

 

字符串流：StringReader和StringWriter

StringReader构造函数：

StringReader(Stringstr)：接收字符串作为参数创建实例

StringWriter构造函数：

StringWriter（）：构造一个默认大小为16个字的新StringWriter。

StringWriter（intinitialSize）：构造一个指定大小为initialSize个字的新StringWriter。

StringReader方法：

     和CharArrayReader方法以及作用基本一样。

StringWriter方法：

append系列方法()作用和CharArrayWriter中的append系列方法一样，不过在这里返回的是StringWriter对象。

Writer系列方法中的作用也和CharArrayWriter中的Writer系列方法一样，不同的是StringWriter还有一个write(Stringstr)，作用是将String字符串写进StringWriter的缓冲区。

StringtoString()：以字符串形式获取此StringWriter内容的副本。

StringBuffergetBuffer() ：返回该StringWriter的缓冲区对象身。

StringWriter的close方法和flush方法是没有作用的，存在的原因仅仅是因为这两个在父类中存在，在继承的时候跟过来的。

 

CharArrayReader和CharArrayWriter、StringReader和StringWriter，在使用上与ByteArrayInputStream和ByteArrayOutputStream相似

 

转换流：InputStreamReader和OutputStreamWriter

InputStreamReader作用是实现字节流转换为字符流输入，OutputStreamWriter作用是实现字符流转换为字节流输出。

InputStreamReader构造函数：

InputStreamReader(InputStream in)：传入指定InputStream构造一个实例。

InputStreamReader(InputStream in, String charsetName)：传入指定InputStream和指定字符集名字构造一个实例。

InputStreamReader(InputStream in, CharsetDecoder dec)：传入指定InputStream和指字符集解码器构造一个实例。

InputStreamReader(InputStream in, Charset charset)：传入指定InputStream和指定字符集对象构造一个实例。

OutputStreamWriter构造函数：

OutputStreamWriter(OutputStream out)：传入指定OutputStream构造一个实例。

OutputStreamWriter(OutputStream out, String charsetName) ：传入指定OutputStream和指定字符集名字构造一个实例。

OutputStreamWriter(OutputStream out, Charset cs) ：传入指定OutputStream和指定字符集对象构造一个实例。

OutputStreamWriter(OutputStream out, CharsetEncoder charsetEncoder) ：传入指定OutputStream和指字符集编码器构造一个实例。

 

InputStreamReader方法：

void close()：关闭这个Reader

String getEncoding()：返回此编写器用于将字符转换为字节的编码的规范名称，如果此编写器已关闭，则返回null。

int read()：读取单个字符。

int read(char[] buffer, int offset, int count)：从buffer的第offset个开始读取，读取长度为count。

Boolean ready()：数据流是否准备好被读取。如果下次可以没有阻塞的情况下进行阅读，返回true。

OutputStreamWriter方法：

void close()：关闭。

void flush()：刷新缓冲区。

String getEncoding()：返回此流使用的字符编码的名称，如果已关闭，则返回null。

void write(int oneChar)：写入单个字符。

void write(char[] buffer, int offset, int count)：从buffer字符数组的第offset个开始写入，长度(写入个数)为count。

void write(String str, int offset, int count)：从str字符串的第offset个字符开始写入，长度(写入个数)为count。

例程：

class Bytetochartest {
    public static void main(String args[]) throws IOException {
        InputStreamReader my_ISR = new InputStreamReader(newFileInputStream("XXXX(路径) "); //获取了InputStreamReader对象了，下面读取出数据
        //按照内存流的惯例，当作是未知长度的，这里还有另一种遍历获取其数据的方式。
        int data_size;
        while(my_ISR.read() != -1){
            data_size++;
        }
        char [] data = new char[data_size];
        my_ISR.read(data);//这个方法是父类Reader的方法，将数据读取进这个数组，返回数组长度。
        my_ISR.close(); 
        OutputStreamWriter my_OSW = new OutputStreamWriter(newFileOutputStream("XXXX(路径) ");
        my_OSW.write(data); //这个方法是父类Writer的方法，将数组写入Writer，无返回值。
        my_OSW.close();
    }
}

 

数据流：DataInputStream和DataOutputStream

      数据流是使得输入/输出流直接可以对基本数据类型的数据进行读写操作的流,属于处理流，目的是使原来的流传输数据更加方便。

DataInputStream构造函数

DataInputStream(InputStream in)：传入一个指定输入流来构造实例。

DataOutputStream构造函数

DataOutputStream(OutputStream out)：传入一个指定输出流来构造实例。

DataInputStream方法：

final int read(byte[] buffer, int byteOffset,int byteCount)：从buffer字节数组的第byteOffset个开始读入，长度为byteCount。

final int read(byte[] buffer)：将buffer字节数组全部读入。

final void  readFully(byte[]dst)：将dst字节数组全部读入。（区别：readFully要求读出的字节长度与byte[]的长度相同，否则就会阻塞或抛异常，而上面read方法不要求。）

final void  readFully(byte[]dst, int offset, int byteCount)：从dst字节数组的第offset个开始读入，长度为byteCount。

final Boolean readBoolean()：读取一个布尔值。

final byte readByte()：读取一个8位字节值。

final char readChar()：读取一个高字节序(big-endian)的16位字符值。（big-endian：也叫大端，即高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。此处对这词不理解也没关系，可以理解为方法作用就是读取一个字符值就足够了。下同）

final double readDouble()：读取一个高字节序的64位双精度值。

final float readFloat()：读取一个高字节序的32位浮点值。

final int readInt()：读取一个高字节序的32位整数值。

final long  readLong()：读取一个高字节序的64位Long值。

final short readShort()：读取一个高字节序的32位short值。

final int readUnsignedByte()：读取一个无符号的8位字节值并将其作为int返回。

final int readUnsignedShort()：读取一个高字节序的无符号的16位short值并将其作为int返回。

final static String readUTF(DataInput in)： 从输入流in中读取一个指定长度的UTF-8(修改版格式)编码的 Unicode 字符串的表示形式，最后返回String形式的字符串，由流的开头2个字节指定长度。

final String readUTF()：读取一个UTF-8 (修改版格式)编码的字符串

final int skipBytes(intcount)：跳过count个字节。

DataOutputStream方法：

void  write(intoneByte)

void  write(byte[]buffer, int offset, int count)

final void  writeBoolean(booleanval)

final void  writeByte(intval)

final void  writeBytes(Stringstr)

final void  writeChar(intval)

final void  writeChars(Stringstr)

final void  writeDouble(doubleval)

final void  writeFloat(floatval)

final void  writeInt(intval)

final void  writeLong(longval)

final void  writeShort(intval)

final void  writeUTF(Stringstr)

以上方法和DataInputStream中的read系列方法相对应，作用只是从read系列方法的"读取"变成"写入"

void  flush()：刷新此流并且将所有待处理数据直接发送到流。

final int size()：返回至今为止写入流的总字节数。

 

《Thinking in Java》一书中关于数据流的例程写得非常好，简单明了，下面例程改写自《Thinking in Java》的例程：

public class DataStreamTest{

public static void main(String[] args)throws IOException {

DataOutputStream out = newDataOutputStream(newBufferedOutputStream(newFileOutputStream("XXX"（路径）)));

out.writeDouble(1.11111);

out.writeUTF("this was one");

out.writeDouble(2.22222);

out.writeUTF("this was two");

out.close();

 

DataInputStream in = new DataInputStream (newBufferedInputStream(newFileInputStream("XXX"（路径）)));

System.out.println(in. readDouble());

System.out.println(in. readUTF());

System.out.println(in. readDouble());

System.out.println(in. readUTF ());

in.close；

}

}

输出：

1.11111

this was one

2.22222

this was two

 

 

缓冲流：BufferedInputStream和BufferedOutputStream、BufferedReader和BufferedWriter

       缓冲流也是处理流，作用是在别的流上加上缓冲来提高效率。使用缓冲流能够更高效的读写数据，因为缓冲流会先将数据缓存起来，然后一起写入或读取，而不再是“写一个读一个”，在进行IO操作的时候加上缓冲流可以提升性能。

BufferedInputStream构造方法：

BufferedInputStream(InputStream in)：

BufferedInputStream(InputStream in, intsize)

BufferedOutputStream构造方法：

BufferedOutputStream(OutputStream out)

BufferedOutputStream(OutputStream out, intsize)

BufferedReader构造方法：

BufferedReader(Reader in)

BufferedReader(Reader in, int size)

BufferedWriter构造方法：

BufferedWriter(Writer out)

BufferedWriter(Writer out, int size)

可以看出，这四个类的构造方法在参数上都是基本一致的，传入指定输入流对象in/输出流对象Out和指定缓冲区大小为size字节构造一个实例，在没有指定缓冲区大小为size字节(没有size参数时)，默认提供8192字节的缓冲区。

 

BufferedInputStream和BufferedReader方法：

BufferedInputStream和BufferedReader两者基本一致的方法：

void close()：关闭

synchronized void mark(int readlimit)：在此输入流中设置标记，readlimit为标记失效之前一定会被读取的字节数。

Boolean markSupported()：指示是否支持mark()和reset()方法。

synchronized int read()：从此流中读取一个字节。

synchronized int read(byte[] buffer, intbyteOffset, int byteCount)/ read(char[] buffer, int offset, int length)：从buffer字节数组/字符数组的第byteOffset个开始读取，读取个数为byteCount个。

synchronized void reset()：将此流重置到最后标记的位置。

synchronized long skip(long Count)/ skip(longCount)：跳过Count个字节/字符。

BufferedInputStream独有的方法：

synchronized int available()：返回剩余字节数。

BufferedReader独有的方法：

String readLine()：读取一整行的文本数据，只有遇到"/r"、"/n"、"/r/n"才会被判定为一行并返回。

Boolean ready()：数据流是否准备好被读取。如果下次可以没有阻塞的情况下进行阅读，返回true。

 

BufferedOutputStream和BufferedWriter方法：

BufferedOutputStream和BufferedWriter两者基本一致的方法：

synchronized void close()：关闭

synchronized void flush()：刷新此流并将所有待处理数据写入流。

synchronized void write(byte[] buffer, intoffset, int length)/ write(char[] buffer, int offset, int count)：从buffer字节/字符数组的第offset个开始写入，写入数据长度为length。

synchronized void write(int oneByte)/write(int oneChar)：将一个字节/字符写入流中。

 BufferedWriter独有的方法：

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

void  write(Stringstr, int offset, int count) ：从str字符串的第offset个开始写入，写入数据长度为count。

例程

public class BufferedTest{
    public static void main(String[] args)throws IOException {
        File file = newFile("C:\\data.txt"); //假设data.txt文件绝对存在
        BufferedWriter MyBW = newBufferedWriter(new FileWriter(file)); 
        MyBW.write("My_BufferedWriter "); 
        MyBW.newLine(); 
        MyBW.write("已经换行。"); 
        MyBW.flush();
        MyBW.close();
        BufferedReader MyBR = newBufferedReader(new FileReader(file)); 
        String MyText;
        while (MyBR.readLine()!= null) { 
            MyText = MyText+ MyBR.readLine();
        }
        System.out.println(MyText);
        MyBR.close();// 关闭输入流
    }
}

对象流：ObjectInputStream和ObjectOutPutStream

      对象流实现了以对象为单位，在IO流上进行传输，其原理是将对象所在的类型全部转换成二进制，然后进行传输，也是处理流。

ObjectInputStream构造函数：

ObjectInputStream(InputStream input)：传入指定的输入流作为参数，构造一个新实例。

ObjectOutPutStream构造函数：

ObjectOutputStream（OutputStream output）：传入指定的输出流作为参数，构造一个新实例。

ObjectInputStream方法：

ObjectInputStream的方法非常多，像int available()、void close()、int read(byte[] buffer, int byteOffset, int byteCount)、int read()、Boolean readBoolean()、byte readByte()、char readChar()、double readDouble()、float readFloat()、void readFully(byte[] dst)、void readFully(byte[] dst, int offset, intbyteCount)、int readInt()、String readLine()、long         readLong()、short readShort()、String readUTF()、int readUnsignedByte()、int readUnsignedShort()、int skipBytes(intlength)，这些方法和上文其他类的相同名字的方法作用一样，这里不再一一说明。

以下是ObjectInputStream相对于上文其他类独有的方法：

void  defaultReadObject()：读取对象描述符和String域的label，defaultReadObject是一个十分特殊的方法，一般只能在readObject()方法中调用，用于修改默认的序列化机制。

ObjectInputStream.GetField   readFields()：读取当前正在从流中读取的对象的持久字段。读取的值存储在GetField对象中，该对象提供对持久字段的访问，返回一个GetField对象。

final Object readObject()：从源流中读取一个对象

Object readUnshared()：从源码流中读取一个非共享对象。

synchronized void registerValidation(ObjectInputValidationobject, int priority)：为object对象的反序列化验证注册回调。

ObjectOutPutStream方法：

ObjectInputStream的方法同样也非常多，像void close()、void flush()、void reset()、void write(int byte)、void   write(byte[] buffer, intoffset, int length)、void writeBoolean(booleanvalue)、void writeByte(int value)、void writeChar(intvalue)、void writeDouble(double value)、void writeFloat(floatvalue)、void writeInt(int value)、void writeLong(longvalue)、void writeShort(int value)、void writeUTF(Stringvalue)，这些方法和上文其他类的相同名字的方法作用一样，这里不再一一说明。

void defaultWriteObject()：写出对象描述符和String域的label，defaultWriteObject是一个十分特殊的方法，一般只能在WriteObject ()方法中调用，用于修改默认的序列化机制。

ObjectOutputStream.PutField putFields()：获取这个流的PutField对象。该对象提供对最终写入输出流的持久字段的访问。它用于将当前正在写入的对象字段中的值传输到持久字段。

void  useProtocolVersion(intversion)：设置此流使用的指定协议版本。

void writeBytes(String value)：将字符串value作为字节序列写入流。

void  writeChars(Stringvalue)：将字符串value作为字符序列写入流。

void  writeFields()：将当前写入的对象的字段写入流，字段被缓存在当前活动的PutField对象中。

final void  writeObject(Objectobject)：将对象写入流。

void  writeUnshared(Objectobject)：将非共享对象写入流。

例程：

class Person{
    String name ;
    String sex;
    int age;
    public Person (String name,String sex,intage){
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
}

public class ObjectStreamTest {
    public static void main(String[] args)throws IOException {
        File Myfile = new File("XXX"(路径));//假设存在文件
        FileOutputStream MyFOS = newFileOutputStream(Myfile);
        ObjectOutputStream MyOOS = new ObjectOutputStream(MyFOS);
        Person person_out = new Person ("小明","男", 10);
        objOP.writeObject(person_one);
        MyOOPS.close();
        MyFOS.close();
        FileInputStream MyFIS = new FileInputStream(Myfile);
        ObjectInputStream MyOIS = newObjectInputStream(MyFIS);
        Person person_In = (Person) MyOIS.readObject();
        System.out.println("name:"+ person_In.name+"sex:"+ person_In.sex+" age:"+ person_In.age);
        MyFIS.close();
        objIP.close();
    }
}

文件流：FileInputStream和FileOutputStream、FileReader和FilerWriter

      属于字节流，实现文件的输入和输出。

FileInputStream构造函数：

FileInputStream(File file)

FileInputStream(FileDescriptor fd)

FileInputStream(String path)

在构造实例都需要指定文件（地址）为参数，file为File对象、path为文件路径、fd为FileDescriptor对象都是指向文件（地址）。

FileOutputStream构造函数：

FileOutputStream(File file)

FileOutputStream(File file, boolean append)

FileOutputStream(FileDescriptor fd)

FileOutputStream(String path)

FileOutputStream(String path, booleanappend)

在构造实例都需要指定文件（地址）为输出参数，file为File对象、path为文件路径、fd为FileDescriptor对象，在没有append参数或者append参数为false时，如果输出路径下文件存在，该文件输出将被截断，如果该文件不存在，则会被创建，在存在append参数且为true时，如果输出路径下文件存在，则会将输出内容附加到文件内容的后面，如果该文件不存在，则会被创建。

FileReader构造函数：

FileReader(File file)

FileReader(FileDescriptor fd)

FileReader(String filename)

和FileInputStream相似，在构造实例都需要指定文件（路径）为参数，file为File对象、filename为文件(路径)、fd为FileDescriptor对象都是指向文件（路径）。

FilerWriter构造函数：

FileWriter(File file)

FileWriter(File file, Boolean append)

FileWriter(FileDescriptor fd)

FileWriter(String filename)

FileWriter(String filename, boolean append)

和FileOutputStream相似，在构造实例都需要指定文件（地址）为输出参数，file为File对象、filename为文件（路径）、fd为FileDescriptor对象，在没有append参数或者append参数为false时，如果输出路径下文件存在，该文件输出将被截断，如果该文件不存在，则会被创建，在存在append参数且为true时，如果输出路径下文件存在，则会将输出内容附加到文件内容的后面，如果该文件不存在，则会被创建。

 

FileInputStream方法

int available()：返回读取的剩余数量(估计量)

void close()：关闭

FileChannel getChannel()：返回只读的FileChannel对象并与此流共享其位置 (状态，原词：position)。

final FileDescriptor getFD()：返回底层文件描述符。

int read()：读取一个字节

int read(byte[] buffer, int byteOffset, intbyteCount)：从buffer字节数组的第byteOffset个开始读取，读取长度为byteCount。

long skip(long byteCount)：跳过byteCount个字节

FileOutputStream方法

void close()：关闭

FileChannel getChannel()：返回只写的FileChannel对象并与此流共享其位置 (状态，原词：position)。

final FileDescriptor getFD()：返回底层文件描述符。

void write(byte[] buffer, int byteOffset,int byteCount)：从buffer字节数组的第byteOffset个开始写入，写入长度为byteCount

void write(int oneByte)：将一个字节写入此流。

FileReader和FilerWriter并没有自己重写的方法，这两个类的方法均来自父类。

最直接的父类是InputStreamReader/OutputStreamWriter

 

管道流：PipedInputStream和PipedOutputStream、PipedReader和PipedWriter

实现管道化概念，对管道进行处理的节点流

PipedInputStream构造函数：

PipedInputStream()：默认构造函数。

PipedInputStream(PipedOutputStream out)：构造一个与out输出流连接的新实例。

PipedInputStream(int pipeSize)：构造一个指定缓冲区大小为pipeSize的新实例。

PipedInputStream(PipedOutputStream out, intpipeSize)：构造一个一个与out输出流连接并指定缓冲区大小为pipeSize的新实例

PipedOutputStream构造函数：

PipedOutputStream()：默认构造函数。

PipedOutputStream(PipedInputStream target) ：构造一个与target输入流连接的新实例。

PipedReader构造函数：

PipedReader()：默认构造函数。

PipedReader(PipedWriter out) ：构造一个与out输出流连接的新实例。

PipedReader(int pipeSize) ：构造一个指定缓冲区大小为pipeSize的新实例。

PipedReader(PipedWriter out, int pipeSize) ：构造一个一个与out输出流连接并指定缓冲区大小为pipeSize的新实例。

PipedWriter构造函数：

PipedWriter()：默认构造函数。

PipedWriter(PipedReader destination) ：构造一个与destination输入流连接的新实例。

 

PipedInputStream和PipedReader方法

两者同名的且作用上基本一致的方法：

synchronized void close()：关闭。

void connect(PipedOutputStream src)/ connect(PipedWritersrc)：将此输入流与src输出流连接

int read()：读取单个字节/字符。

synchronized int read(byte[]buffer, intOffset, int Count) /read(char[] buffer, int offset, int count)：从buffer数组的第Offset个开始读取，读取数据长度为Count。

PipedInputStream独有的方法：

synchronized int available(): 返回剩余字节数。与大多数流不同的是：如果流已关闭，则PipedInputStream返回0而不是抛出 IOException。

PipedReader独有的方法：

synchronized Boolean ready()：数据流是否准备好被读取。如果下次可以没有阻塞的情况下进行阅读，返回true。

 

PipedOutputStream和PipedWriter方法

两者的方法都同名且作用上基本一致：

void  close()：关闭。

void  connect(PipedInputStreamstream)/ connect(PipedReader reader)：将此输出流与stream/ reader输入流连接。

void  flush()：通知输出流可以读取输入流的数据了

void  write(byte[]buffer, int offset, int count)/ write(char[] buffer, int offset, int count)：从buffer数组的第offset个开始写入，写入数据长度为count。

void  write(intoneByte) /write(int onechar)：将一个字节/字符写入此流。

（管道流会在后面的多线程一文中使用,这里将不再写例程）

 

合并流：SequenceInputStream

      合并流的作用是连接两个或多个现有的输入流。当第一个流中读取结束之后会进入下一个流的读取，直到最后一个流读完，也是一个处理流。

SequenceInputStream构造函数：

SequenceInputStream (InputStream s1，InputStreams2)：传入输入流S1和输入流s2，构造一个将这两个输入流连接(合并)的实例。

SequenceInputStream (Enumeration <？extendsInputStream > e)：传入一个列举作为参数，构造一个将列举中所有所有输入流连接(合并)的实例。

 

SequenceInputStream方法：

还是熟悉的：

int available()：返回剩余字节数。

void close()：关闭输入流序列中的所有流。

int read()：读取单个字节/字符。

int read(byte[]buffer, int byteOffset, int byteCount)：从buffer数组的第byteOffset个开始读取，读取数据长度为byteCount。

 

例程：

public class SequenceInputStreamTest { 

   public static void main(String[] args) throws IOException { 

       FileInputStream file1 = new FileInputStream("C:\\data1.txt");

       FileInputStream file2= new FileInputStream("C:\\data2.txt");

构造函数一写法：

        SequenceInputStream MySIS = new SequenceInputStream(file1, file2);

构造函数二写法：

       ArrayList filelist= newArrayList();

       filelist.add(file1);

       filelist.add(file2);

       Enumeration Myenumeration =Collections.enumeration(filelist); 

       SequenceInputStream MySIS = new SequenceInputStream(Myenumeration); 

         

       //输出

       FileOutputStream MyFOS=new FileOutputStream("C:\\dataout.txt"); 

       while(MySIS.read()!=-1){

                MyFOS.write(MySIS.read());

       }

file1.close();

file2.close();

       MySIS.close();

       MyFOS.close();

   } 

}

 

回退流：PushbackInputStream和PushbackReader

回退流实现了把读取进来的某些数据重新回退到输入流的缓冲区之中。

PushbackInputStream构造函数：

PushbackInputStream（InputStreamin）：构造一个指定输入流in作为参数的实例

PushbackInputStream（InputStreamin，int size）：构造一个指定输入流in和指定缓冲区的大小size作为参数的实例。

PushbackReader构造函数

PushbackReader(Reader in) ：构造一个指定输入流in作为参数的实例

PushbackReader(Reader in, int size) ：构造一个指定输入流in和指定缓冲区的大小size作为参数的实例。

 

PushbackInputStream和PushbackReader方法：

两者的方法都同名且作用上基本一致：

void close()：关闭。

void mark(int readlimit)：在此输入流中设置标记，readlimit为标记失效之前一定会被读取的字节数。

Boolean markSupported(): 指示此流是否支持mark()和 reset()方法。

int read()：读取一个字节

int read(byte[] buffer, int Offset, intCount)/ read(char[] buffer, int offset, int count)：从buffer数组的第Offset个开始读取，读取数据长度为Count。

void reset(): 将此流重置到最后标记的位置。

long skip(long byteCount) : 跳过输入流中的byteCount个字节。

void unread(byte[] buffer, int offset, intlength)/ unread(char[] buffer, int offset, int length)：将一部分字节/字符从缓冲区中退回到此流中。

void unread(byte[] buffer)/ unread(char[]buffer)：将所有字节/字符从缓冲区中退回到此流中。

void unread(int oneByte)/ unread(intoneChar)：将一个字节从缓冲区中退回到此流中。

PushbackInputStream独有的方法：

int available()：返回剩余字节数。

PushbackInputStream独有的方法：

ready()：：数据流是否准备好被读取。如果下次可以没有阻塞的情况下进行阅读，返回true。

 

打印流：PrintStream和PrintWriter

打印流提供了非常方便的打印功能，可以打印任何类型的数据信息，其也是一个处理流。

PrintStream构造函数：

PrintStream(OutputStream out)：构造一个指定输出流out为目标的实例。默认情况下，当遇到换行符时，打印流不会自动将其内容清理到目标流​​。

PrintStream(OutputStream out, boolean autoFlush)：构造一个指定输出流out为目标的实例。同时指定autoFlush来确定是否在遇到换行符时，打印流是否自动将其内容刷新到输出流。

PrintStream(OutputStream out, booleanautoFlush, String charsetName)：构造一个指定输出流out为目标的实例。同时指定在写入时使用字符编码charsetName，指定autoFlush来确定是否在遇到换行符时，打印流是否自动将其内容刷新到输出流。

PrintStream(File file)：构造一个指定文件为目标的实例。

PrintStream(File file, String charsetName)：构造一个指定文件为目标的实例，同时指定在写入时使用字符编码charsetName。

PrintStream(String fileName)：构造一个指定文件名为目标的实例。

PrintStream(String fileName, StringcharsetName)：构造一个指定文件名为目标的实例，同时指定在写入时使用字符编码charsetName。

PrintWriter构造函数：

PrintWriter(OutputStream out)

PrintWriter(OutputStream out, booleanautoFlush)

PrintWriter(File file)

PrintWriter(File file, String charsetName)

PrintWriter(String fileName)

PrintWriter(String fileName, String charsetName)

以上六个构造函数和PrintStream中的构造函数参数作用一样。

PrintWriter(Writer wr)：构造一个指定写入器wr为目标的实例。默认情况下，当遇到换行符时，打印流不会自动将其内容清理到目标流​​。

PrintWriter(Writer wr, boolean autoFlush)：构造一个指定写入器wr为目标的实例。同时指定autoFlush来确定是否在遇到换行符时，打印流是否自动将其内容刷新到输出流。

 

PrintStream方法：

方法大同小异，大部分只有参数不同：

PrintStream append(char c)：

PrintStream append(CharSequencecharSequence, int start, int end)：

PrintStream append(CharSequencecharSequence)：

以上追加字符到目标流中。

PrintStream format(Locale l, String format,Object... args)：

PrintStream format(String format, Object...args)：

PrintStream printf(Locale l, String format,Object... args)

PrintStream printf(String format, Object...args)

以上format和printf方法都是打印出格式化的字符串。

 

void print(float f)

void print(double d)

synchronized void print(String str)

void print(Object o)

void print(char c)

void print(char[] chars)

void print(long l)

void print(int i)

void print(Boolean b)

以上print方法都是打印出XX(参数)。

 

void println()

void println(floatf)

void println(inti)

void println(longl)

void println(Objecto)

void println(char[]chars)

synchronized void println(String str)

void println(charc)

void println(doubled)

void println(booleanb)

以上print方法都是打印出XX(参数)，并换行。

 

Boolean checkError()：刷新此流并返回错误标志的值。

synchronized void close()：关闭

synchronized void flush()：将所有待处理数据立即发送到目标流。

synchronized void write(int oneByte) :将指定的字节写入此字节数组输出流。

void  write(byte[]buffer, int offset, int length) :从buffer数组的第offset个开始写入，写入数据长度为length。

 

PrintWriter方法：
PrintWriter方法除了write方法外，其他和PrintStream中方法一致。
PrintWriter write方法：

void write(char[] buf, intoffset, int count)：从buf字符数组的第offset个开始写入，长度(写入个数)为count。

void write(intoneChar) ：写入单个字符。

void write(char[]buf)：写入整个字符数组。

void write(String str, intoffset, int count) ：从str字符串的第offset个字符开始写入，长度(写入个数)为count。

void write(Stringstr)：写入一个字符串。

 

例程：

public class PrintTest{

public static void main(String arg[])throws Exception{

PrintStream MyPS= new PrintStream(newFileOutputStream(new File("

XXX(路径)"))) ;

MyPS.print ("This is a good idea!");

MyPS.close() ;

}

}

文件中就会有文本“This is a good idea!”。

 

------------------------------------------------分割线----------------------------------------------------------

上文如有错误、写得不合理以及有疑惑的地方，希望您可以在评论区提出。

在下十分感谢。

如果只是想在评论区吐吐槽、聊聊心得、卖个萌，同样也十分欢迎。

祝大家生活美好,干杯!~( ゜▽゜)つロ

 

转载请注明原作者以及附上原文章地址，谢谢。