JDK中IO包的源码解读配合大神的一起看，秒懂。

大神总结的目录：http://www.cnblogs.com/skywang12345/p/io_01.html(装载)，仅供个人学习，如有抄袭请包容(我也忘了cry....)

一、 BufferedInputStream类

1)  构造方法

BufferedInputStream(InputStreamin)

BufferedInputStream(InputStreamin, int size)

两个构造方法  参数为in 输入流  size buf的size 默认sizedefaultBufferSize = 8192

2)  类方法

read() read(byteb[], int off, int len) skip(long) available() mark(int) reset()方法上添加了sychronized方法，因此锁机制产生。

3)  类特殊属性

// 缓存数组的原子更新器。

// 该成员变量与buf数组的volatile关键字共同组成了buf数组的原子更新功能实现，

// 即，在多线程中操作BufferedInputStream对象时，buf和bufUpdater都具有原子性(不同的线程访问到的数据都是相同的)

private staticfinal

AtomicReferenceFieldUpdater<BufferedInputStream,byte[]> bufUpdater =

AtomicReferenceFieldUpdater.newUpdater

(BufferedInputStream.class,  byte[].class, "buf");

4)  类作用

BufferedInputStream的作用是为其它输入流提供缓冲功能。创建BufferedInputStream时，我们会通过它的构造函数指定某个输入流为参数。

BufferedInputStream会将该输入流数据分批读取，每次读取一部分到缓冲中；操作完缓冲中的这部分数据之后，再从输入流中读取下一部分的数据。

为什么需要缓冲呢？原因很简单，效率问题！缓冲中的数据实际上是保存在内存中，而原始数据可能是保存在硬盘或NandFlash等存储介质中；而我们知道，从内存中读取数据的速度比从硬盘读取数据的速度至少快10倍以上。

那干嘛不干脆一次性将全部数据都读取到缓冲中呢？第一，读取全部的数据所需要的时间可能会很长。第二，内存价格很贵，容量不像硬盘那么大。

5)  实践

InputStream as =new FileInputStream("C:\\bis路径\\123.txt");

BufferedInputStreambis = new BufferedInputStream(as);

bis.read(char[] a,0, 10);

bis.close();

二、    BufferedOutputStream类

1)  构造方法

BufferedOutputStream(OutputStreamout)

BufferedOutputStream(OutputStreamout, int size)

两个构造方法  参数为out输出流  size buf的size 默认sizedefaultBufferSize = 8192

2)  类方法

write(int b) write(byteb[], int off, int len) flush()方法上添加了sychronized方法，因此锁机制产生。

3)  类作用

BufferedOutputStream通过字节数组来缓冲数据，当缓冲区满或者用户调用flush()函数时，它就会将缓冲区的数据写入到输出流中。

4)  实践

FileOutputStreamfile = new FileOutputStream("out.txt");

BufferedOutputStreamout = new BufferedOutputStream(file, 16);

// 将ArrayLetters数组的前10个字节写入到输出流中

out.write(byte[] b,0, 10);

// 将“换行符\n”写入到输出流中

out.write('\n');

out.close();

三、    BufferedReader类

1)  构造方法

BufferedReader(Readerin)

BufferedReader(Readerin, int size)

两个构造方法  参数为Reader流  size buf的size 默认sizedefaultBufferSize = 8192

2)  类方法

read() read(charcbuf[], int off, int len) readLine() skip(long) ready() mark(int) reset()close()方法上添加了synchronized(lock)属性，因此锁机制产生。

3)  类作用

BufferedReader类将Reader类封装为缓存类，将Reader字节流或者字符流统一封装为字符流缓存，用以方便读取提高缓存效率，读取方式可以逐个char也可以逐行读取，其中继承父类Reader的lock属性来统一锁住读等操作，其效率比BufferedInputStream直接锁住方法高，而导致输出结果也有差异。

4)  实践

InputStream as =new FileInputStream("C:\\hebao-user\\123.txt");

InputStreamReaderisr = new InputStreamReader(as);

BufferedReader br= new BufferedReader(isr);

br. readLine();

br. read(char[] b, 0,10);

br.close();

四、    BufferedWriter类

1)  构造方法

BufferedWriter(Writer out)

BufferedWriter(Writer out, int sz)

两个构造方法  参数为out 输出流  sz buf的size 默认sizedefaultBufferSize = 8192

2)  类方法

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)    // 写入字符串的某一部分。

3)  类作用

BufferedWriter通过字符数组来缓冲数据，当缓冲区满或者用户调用flush()函数时，它就会将缓冲区的数据写入到输出流中。

4)  实践

OutputStream os =new FileOutputStream("C:\\hebao-user\\123.txt");

OutputStreamWriterosw = new OutputStreamWriter(os);

BufferedWriter bw= new BufferedWriter(osw);

bw.write(char[] b,0, 10);

bw.write(Strings);

bw.close();

五、    对比BufferedInputStream和BufferedReader

六、    ByteArrayInputStream类

1)  构造方法

ByteArrayInputStream(byte[] buf)

ByteArrayInputStream(byte[] buf, int offset, int length)

两个构造方法  参数为buf字节数组即缓存字节数组，从offset开始读取数据，读取的长度为length

2)  类方法

synchronizedint         available()

             void        close()

synchronizedvoid        mark(int readlimit)

             boolean     markSupported()

synchronizedint         read()

synchronizedint         read(byte[] buffer, intoffset, int length)

synchronizedvoid        reset()

synchronizedlong        skip(long byteCount)

3)  类作用

ByteArrayInputStream实际上是通过“字节数组”去保存数据。

(01) 通过ByteArrayInputStream(byte buf[]) 或 ByteArrayInputStream(byte buf[], int offset, int length) ，我们可以根据buf数组来创建字节流对象。

(02) read()的作用是从字节流中“读取下一个字节”。

(03) read(byte[]buffer, int offset, int length)的作用是从字节流读取字节数据，并写入到字节数组buffer中。offset是将字节写入到buffer的起始位置，length是写入的字节的长度。

(04)markSupported()是判断字节流是否支持“标记功能”。它一直返回true。

(05) mark(intreadlimit)的作用是记录标记位置。记录标记位置之后，某一时刻调用reset()则将“字节流下一个被读取的位置”重置到“mark(intreadlimit)所标记的位置”；也就是说，reset()之后再读取字节流时，是从mark(int readlimit)所标记的位置开始读取。

4)  实践

String string ="asdfasdfadf";

ByteArrayInputStreambais = new ByteArrayInputStream(string.getBytes());

while(bais.available()> 0){

    int tmp = bais.read();

    System.out.print((char)tmp);

}

System.out.print("空行还是空！");

七、    ByteArrayOutputStream类

1)  构造方法

ByteArrayOutputStream()

ByteArrayOutputStream(intsize)

创建指定数组大小的“字节数组输出流”，默认字节数组大小为32.

2)  类方法

             void    close()

synchronizedvoid    reset()

             int     size()

synchronizedbyte[]  toByteArray()

             String  toString(int hibyte)

             String  toString(String charsetName)

             String  toString()

synchronizedvoid    write(byte[] buffer, int offset,int len)

synchronizedvoid    write(int oneByte)

synchronizedvoid    writeTo(OutputStream out)

3)  类作用

ByteArrayOutputStream实际上是将字节数据写入到“字节数组”中去。

(01) 通过ByteArrayOutputStream()创建的“字节数组输出流”对应的字节数组大小是32。

(02) 通过ByteArrayOutputStream(int size) 创建“字节数组输出流”，它对应的字节数组大小是size。

(03) write(intoneByte)的作用将int类型的oneByte换成byte类型，然后写入到输出流中。

(04) write(byte[]buffer, int offset, int len) 是将字节数组buffer写入到输出流中，offset是从buffer中读取数据的起始偏移位置，len是读取的长度。

(05)writeTo(OutputStream out) 将该“字节数组输出流”的数据全部写入到“输出流out”中。

4)  实践

byte[] b = {0x41,0x42, 0x43};

ByteArrayOutputStreambaos = new ByteArrayOutputStream();

baos.write(b);

if (baos.size()> 0) {

    System.out.println(baos.toString("UTF-8"));

    System.out.println(newString(baos.toByteArray()));

}

八、    CharArrayReader类

1)  构造方法

CharArrayReader(char[]buf)

CharArrayReader(char[]buf, int offset, int length)

CharArrayReader 是字符数组输入流。它和ByteArrayInputStream类似，只不过ByteArrayInputStream是字节数组输入流，而CharArray是字符数组输入流。CharArrayReader 是用于读取字符数组，它继承于Reader。操作的数据是以字符为单位！

2)  类方法

void      close()

void      mark(int readLimit)      synchronized (lock) {}  

boolean   markSupported()

int       read()            synchronized(lock) {}

int       read(char[] buffer, int offset, int len)synchronized(lock) {}

boolean   ready()           synchronized(lock) {}

void      reset()           synchronized(lock) {}

long      skip(long charCount)     synchronized (lock) {}

3)  类作用

CharArrayReader实际上是通过“字符数组”去保存数据。

 

(01) 通过 CharArrayReader(char[] buf) 或 CharArrayReader(char[] buf, int offset, int length) ，我们可以根据buf数组来创建CharArrayReader对象。

(02) read()的作用是从CharArrayReader中“读取下一个字符”。

(03) read(char[]buffer, int offset, int len)的作用是从CharArrayReader读取字符数据，并写入到字符数组buffer中。offset是将字符写入到buffer的起始位置，len是写入的字符的长度。

(04)markSupported()是判断CharArrayReader是否支持“标记功能”。它始终返回true。

(05) mark(intreadlimit)的作用是记录标记位置。记录标记位置之后，某一时刻调用reset()则将“CharArrayReader下一个被读取的位置”重置到“mark(int readlimit)所标记的位置”；也就是说，reset()之后再读取CharArrayReader时，是从mark(int readlimit)所标记的位置开始读取。

4)  实践

String string ="asdfasdfadf好";

CharArrayReadercar = new CharArrayReader(string.toCharArray());

while(car.ready()){

    int tmp = car.read();

    System.out.print((char)tmp);

}

字符类型 汉字可以直接输出

九、    CharArrayWriter类

1)  构造方法

CharArrayWriter()

CharArrayWriter(intinitialSize)

CharArrayWriter是字符数组输出流。它和ByteArrayOutputStream类似，只不过ByteArrayOutputStream是字节数组输出流，而CharArray是字符数组输出流。CharArrayWriter是用于写字符数组，它继承于Writer。操作的数据是以字符为单位！创建指定数组大小的“字符数组输出流”，默认字符数组大小为32.

2)  类方法

CharArrayWriter     append(CharSequence csq, int start, intend)

CharArrayWriter     append(char c)

CharArrayWriter     append(CharSequence csq)

void     close()

void     flush()

void     reset()

int     size()

char[]     toCharArray()    synchronized(lock){}

String     toString()       synchronized(lock){}

void     write(char[] buffer, int offset, int len) synchronized(lock){}

void     write(int oneChar)     synchronized(lock){}

void     write(String str, int offset, int count) synchronized(lock){}

void     writeTo(Writer out)    synchronized(lock){}

3)  类及方法作用

CharArrayWriter实际上是将数据写入到“字符数组”中去。

 

(01) 通过CharArrayWriter()创建的CharArrayWriter对应的字符数组大小是32。

(02) 通过CharArrayWriter(int size) 创建的CharArrayWriter对应的字符数组大小是size。

(03) write(int oneChar)的作用将int类型的oneChar换成char类型，然后写入到CharArrayWriter中。

(04) write(char[]buffer, int offset, int len) 是将字符数组buffer写入到输出流中，offset是从buffer中读取数据的起始偏移位置，len是读取的长度。

(05) write(Stringstr, int offset, int count) 是将字符串str写入到输出流中，offset是从str中读取数据的起始位置，count是读取的长度。

(06) append(charc)的作用将char类型的c写入到CharArrayWriter中，然后返回CharArrayWriter对象。

注意：append(char c)与write(int c)都是将单个字符写入到CharArrayWriter中。它们的区别是，append(char c)会返回CharArrayWriter对象，但是write(int c)返回void。

(07)append(CharSequence csq, int start, int end)的作用将csq从start开始(包括)到end结束(不包括)的数据，写入到CharArrayWriter中。

注意：该函数返回CharArrayWriter对象！

(08)append(CharSequence csq)的作用将csq写入到CharArrayWriter中。

注意：该函数返回CharArrayWriter对象！

(09)writeTo(OutputStream out) 将该“字符数组输出流”的数据全部写入到“输出流out”中。

4)  实践

CharArrayWritercaw = new CharArrayWriter();

caw.write('A');

caw.write("asd");

System.out.println(caw.toString());

System.out.println(newString(caw.toCharArray()));

caw.append('b').append("jhg").append("oiuytr",2, 4);

System.out.println(caw.toString());

十、  对比ByteArrayInputStream和CharArrayReader

1.从构建对象上看，ByteArrayInputStream是创建时传入byte[]字节数组并缓存起来，而CharArrayReader创建时传入字符并缓存起来。

2.从对象方法上看，ByteArrayInputStream的write针对的是单个byte或byte数组写入，而CharArrayReader的write针对的是单个字符或者字符数组写入，还可以append追加char或者char[]。

3.从功能上看，ByteArrayInputStream只是针对一个字节缓存数组的一系列操作，而CharArrayReader对字符缓存类似于前者的操作外，还可以扩展内存并返回CharArrayWriter类型，writeTo将buf中现有的字节写入到subWriter中

4.从性能上看，ByteArrayInputStream是将read等方法synchronized加锁，而CharArrayReader是在方法内上synchronized(lock)加锁，因此后者效率更高。

十一、        DataInputStream类

1)  构造方法

DataInputStream(InputStreamin)

DataInputStream 是数据输入流。它继承于FilterInputStream。

2)  类方法

final int     read(byte[] buffer, int offset, intlength)

final int     read(byte[] buffer)

final boolean     readBoolean()

final byte     readByte()

final char     readChar()

final double     readDouble()

final float     readFloat()

final void     readFully(byte[] dst)

final void     readFully(byte[] dst, int offset, intbyteCount)

final int     readInt()

final String     readLine()

final long     readLong()

final short     readShort()

final staticString     readUTF(DataInput in)

final String     readUTF()

final int     readUnsignedByte()

final int     readUnsignedShort()

final int     skipBytes(int count)

3)  类及方法作用

DataInputStream 的作用就是“允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。”

在read等方法上添加final类型的原因有二：

第一、把方法锁定，防止任何继承类修改它的意义和实现，即不允许其子类覆盖其方法 。

第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。

4)  实践

FileInputStreamfis = new FileInputStream("C:\\hebao-user\\123.txt");

DataInputStreamdis = new DataInputStream(fis);

byte[] bs = newbyte[4];  // 防止乱码 每次读取4个字节

while(dis.available() > 0) {

    dis.read(bs); 

    System.out.print(new String(bs, 0, bs.length));

}

dis.close();

十二、        DataOutputStream类

1)  构造方法

DataOutputStream(OutputStream out)

DataOutputStream是数据输出流。它继承于FilterOutputStream。

2)  类方法

synchronized voidwrite(int b)

synchronized voidwrite(byte b[], int off, int len)

                      void flush()

final voidwriteBoolean(boolean v)

final voidwriteByte(int v)

final voidwriteShort(int v)

final voidwriteChar(int v)

final voidwriteInt(int v)

final void writeLong(longv)

final voidwriteFloat(float v)

final voidwriteDouble(double v)

final voidwriteBytes(String s)

final voidwriteChars(String s)

final voidwriteUTF(String str)

final int size()

3)  类及方法作用

1.DataOutputStream是用来装饰其它输出流，将DataOutputStream和DataInputStream输入流配合使用，“允许应用程序以与机器无关方式从底层输入流中读写基本 Java 数据类型”。

2.两个write使用synchronized类型来修饰是防止多线程写入操作。具体以后再考究

4)  实践

String ss ="slkdjflsj好";

FileOutputStreamfos = new FileOutputStream("C:\\hebao-user\\123.txt");

DataOutputStreamdos = new DataOutputStream(fos);

dos.write(ss.getBytes());

dos.close();

十三、        File类

1)  构造函数

// 静态成员

public staticfinal String     pathSeparator        // 路径分割符":"

public staticfinal char     pathSeparatorChar    // 路径分割符':'

public staticfinal String     separator            // 分隔符"/"

public staticfinal char     separatorChar        // 分隔符'/'

// 构造函数

File(File dir,String name)

File(String path)

File(StringdirPath, String name)

File(URI uri)

2)  类方法

boolean    canExecute()    // 测试应用程序是否可以执行此抽象路径名表示的文件。

boolean    canRead()       // 测试应用程序是否可以读取此抽象路径名表示的文件。

boolean    canWrite()      // 测试应用程序是否可以修改此抽象路径名表示的文件。

int    compareTo(File pathname)    // 按字母顺序比较两个抽象路径名。

boolean    createNewFile()         // 当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。

static File    createTempFile(String prefix, String suffix)    // 在默认临时文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。

static File    createTempFile(String prefix, Stringsuffix, File directory)    // 在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。

boolean    delete()             // 删除此抽象路径名表示的文件或目录。

void    deleteOnExit()       // 在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。

boolean    equals(Object obj)   // 测试此抽象路径名与给定对象是否相等。

boolean    exists()             // 测试此抽象路径名表示的文件或目录是否存在。

File    getAbsoluteFile()    // 返回此抽象路径名的绝对路径名形式。

String    getAbsolutePath()    // 返回此抽象路径名的绝对路径名字符串。

File    getCanonicalFile()   // 返回此抽象路径名的规范形式。

String    getCanonicalPath()   // 返回此抽象路径名的规范路径名字符串。

long    getFreeSpace()       // 返回此抽象路径名指定的分区中未分配的字节数。

String    getName()            // 返回由此抽象路径名表示的文件或目录的名称。

String    getParent()          // 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。

File    getParentFile()      // 返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回 null。

String    getPath()            // 将此抽象路径名转换为一个路径名字符串。

long    getTotalSpace()      // 返回此抽象路径名指定的分区大小。

long    getUsableSpace()     // 返回此抽象路径名指定的分区上可用于此虚拟机的字节数。

int    hashCode()               // 计算此抽象路径名的哈希码。

boolean    isAbsolute()         // 测试此抽象路径名是否为绝对路径名。

boolean    isDirectory()        // 测试此抽象路径名表示的文件是否是一个目录。

boolean    isFile()             // 测试此抽象路径名表示的文件是否是一个标准文件。

boolean    isHidden()           // 测试此抽象路径名指定的文件是否是一个隐藏文件。

long    lastModified()       // 返回此抽象路径名表示的文件最后一次被修改的时间。

long    length()             // 返回由此抽象路径名表示的文件的长度。

String[]    list()           // 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。

String[]    list(FilenameFilter filter)    // 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。

File[]    listFiles()                        // 返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。

File[]    listFiles(FileFilter filter)       // 返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。

File[]    listFiles(FilenameFilter filter)   // 返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。

static File[]    listRoots()    // 列出可用的文件系统根。

boolean    mkdir()    // 创建此抽象路径名指定的目录。

boolean    mkdirs()   // 创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。

boolean    renameTo(File dest)    // 重新命名此抽象路径名表示的文件。

boolean    setExecutable(boolean executable)    // 设置此抽象路径名所有者执行权限的一个便捷方法。

boolean    setExecutable(boolean executable, booleanownerOnly)    // 设置此抽象路径名的所有者或所有用户的执行权限。

boolean    setLastModified(long time)       // 设置此抽象路径名指定的文件或目录的最后一次修改时间。

boolean    setReadable(boolean readable)    // 设置此抽象路径名所有者读权限的一个便捷方法。

boolean    setReadable(boolean readable, booleanownerOnly)    // 设置此抽象路径名的所有者或所有用户的读权限。

boolean    setReadOnly()                    // 标记此抽象路径名指定的文件或目录，从而只能对其进行读操作。

boolean    setWritable(boolean writable)    // 设置此抽象路径名所有者写权限的一个便捷方法。

boolean    setWritable(boolean writable, booleanownerOnly)    // 设置此抽象路径名的所有者或所有用户的写权限。

String    toString()    // 返回此抽象路径名的路径名字符串。

URI    toURI()   // 构造一个表示此抽象路径名的 file: URI。

URL    toURL()   // 已过时。 此方法不会自动转义 URL 中的非法字符。建议新的代码使用以下方式将抽象路径名转换为 URL：首先通过 toURI 方法将其转换为 URI，然后通过 URI.toURL 方法将 URI 装换为 URL。

十四、        FileDescriptor类

1)  FileDescriptor 介绍

FileDescriptor 是“文件描述符”。

FileDescriptor 可以被用来表示开放文件、开放套接字等。

以FileDescriptor表示文件来说：当FileDescriptor表示某文件时，我们可以通俗的将FileDescriptor看成是该文件。但是，我们不能直接通过FileDescriptor对该文件进行操作；若需要通过FileDescriptor对该文件进行操作，则需要新创建FileDescriptor对应的FileOutputStream，再对文件进行操作。

2)  in, out, err介绍

(01) in  -- 标准输入(键盘)的描述符

(02) out -- 标准输出(屏幕)的描述符

(03) err -- 标准错误输出(屏幕)的描述符

它们3个的原理和用法都类似，下面我们通过out来进行深入研究。

3)  out 的作用和原理

out是标准输出(屏幕)的描述符。但是它有什么作用呢？

我们可以通俗理解，out就代表了标准输出(屏幕)。若我们要输出信息到屏幕上，即可通过out来进行操作；但是，out又没有提供输出信息到屏幕的接口(因为out本质是FileDescriptor对象，而FileDescriptor没有输出接口)。怎么办呢？

很简单，我们创建out对应的“输出流对象”，然后通过“输出流”的write()等输出接口就可以将信息输出到屏幕上。如下代码：

try {

    FileOutputStream out = newFileOutputStream(FileDescriptor.out);

    out.write('A');

    out.close();

} catch(IOException e) {

}

执行上面的程序，会在屏幕上输出字母'A'。

为了方便我们操作，java早已为我们封装好了“能方便的在屏幕上输出信息的接口”：通过System.out，我们能方便的输出信息到屏幕上。

因此，我们可以等价的将上面的程序转换为如下代码：

System.out.print('A');

十五、        FileInputStream类

1)  构造方法

FileInputStream(Filefile)         // 构造函数1：创建“File对象”对应的“文件输入流”

FileInputStream(FileDescriptorfd) // 构造函数2：创建“文件描述符”对应的“文件输入流”

FileInputStream(Stringpath)       // 构造函数3：创建“文件(路径为path)”对应的“文件输入流”

2)  类方法

int      available()             // 返回“剩余的可读取的字节数”或者“skip的字节数”

void     close()                 // 关闭“文件输入流”

FileChannel      getChannel()    // 返回“FileChannel”

finalFileDescriptor     getFD() // 返回“文件描述符”

int      read()                  // 返回“文件输入流”的下一个字节

int      read(byte[] buffer, int byteOffset, intbyteCount) // 读取“文件输入流”的数据并存在到buffer，从byteOffset开始存储，存储长度是byteCount。

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

3)  类作用

FileInputStream 是文件输入流，它继承于InputStream。

通常，我们使用FileInputStream从某个文件中获得输入字节。

4)  实践

FileInputStreamfis = new FileInputStream("C:\\hebao-user\\123.txt");

System.out.println((char)fis.read());

fis.close();

十六、        FileOutputStream类

1)  构造方法

FileOutputStream(Filefile)                   // 构造函数1：创建“File对象”对应的“文件输入流”；默认“追加模式”是false，即“写到输出的流内容”不是以追加的方式添加到文件中。

FileOutputStream(Filefile, boolean append)   // 构造函数2：创建“File对象”对应的“文件输入流”；指定“追加模式”。

FileOutputStream(FileDescriptorfd)           // 构造函数3：创建“文件描述符”对应的“文件输入流”；默认“追加模式”是false，即“写到输出的流内容”不是以追加的方式添加到文件中。

FileOutputStream(Stringpath)                 // 构造函数4：创建“文件(路径为path)”对应的“文件输入流”；默认“追加模式”是false，即“写到输出的流内容”不是以追加的方式添加到文件中。

FileOutputStream(Stringpath, boolean append) // 构造函数5：创建“文件(路径为path)”对应的“文件输入流”；指定“追加模式”。

2)  类方法

void                    close()      // 关闭“输出流”

FileChannel             getChannel() // 返回“FileChannel”

finalFileDescriptor    getFD()      // 返回“文件描述符”

void                    write(byte[] buffer, intbyteOffset, int byteCount) // 将buffer写入到“文件输出流”中，从buffer的byteOffset开始写，写入长度是byteCount。

void                    write(int oneByte)  // 写入字节oneByte到“文件输出流”中

3)  类作用

FileOutputStream 是文件输出流，它继承于OutputStream。

通常，我们使用FileOutputStream将数据写入 File 或 FileDescriptor 的输出流。

4)  实践

String ss ="askldjflsakj好";

FileOutputStreamfos = new FileOutputStream("C:\\hebao-user\\123.txt");

fos.write(ss.getBytes());

fos.close();

十七、        FileReader类

1)  构造方法

FileReader(StringfileName)

FileReader(Filefile)

FileReader(FileDescriptorfd)

2)  类作用

FileReader 是用于读取字符流的类，它继承于InputStreamReader。要读取原始字节流，请考虑使用 FileInputStream，而且FileReader是基于InputStreamReader实现的。

十八、        FileWriter类

1)  构造方法

FileWriter(StringfileName)

FileWriter(StringfileName, boolean append)

FileWriter(Filefile)

FileWriter(Filefile, boolean append)

FileWriter(FileDescriptorfd)

2)  类作用

FileWriter 是用于写入字符流的类，它继承于OutputStreamWriter。要写入原始字节流，请考虑使用 FileOutputStream，而且FileWriter是基于OutputStreamWriter实现的。

十九、        FilterInputStream类

1)  构造方法

FilterInputStream(InputStreamin)

2)  类作用

FilterInputStream 的作用是用来“封装其它的输入流，并为它们提供额外的功能”。它的常用的子类有BufferedInputStream和DataInputStream。

(1)BufferedInputStream的作用就是为“输入流提供缓冲功能，以及mark()和reset()功能”。

(2)DataInputStream是用来装饰其它输入流，它“允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型”。应用程序可以使用DataOutputStream(数据输出流)写入由DataInputStream(数据输入流)读取的数据。

二十、        FilterOutputStream类

1)  构造方法

FilterOutputStream(OutputStreamout)

2)  类作用

FilterOutputStream的作用是用来“封装其它的输出流，并为它们提供额外的功能”。它主要包括BufferedOutputStream, DataOutputStream和PrintStream。

(01) BufferedOutputStream的作用就是为“输出流提供缓冲功能”。

(02)DataOutputStream 是用来装饰其它输出流，将DataOutputStream和DataInputStream输入流配合使用，“允许应用程序以与机器无关方式从底层输入流中读写基本 Java 数据类型”。

(03) PrintStream 是用来装饰其它输出流。它能为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。

二十一、            InputStreamReader类

1)  构造方法

InputStreamReader(InputStreamin)

InputStreamReader(InputStreamin, String charsetName)

InputStreamReader(InputStreamin, Charset cs)

InputStreamReader(InputStreamin, CharsetDecoder dec)

2)  类方法

int read()

int read(charcbuf[], int offset, int length)

3)  类作用

InputStreamReader是字节流通向字符流的桥梁：它使用指定的 charset 读写字节并将其解码为字符。

InputStreamWriter作用就是将“字节输入流”转换成“字符输入流”。它继承于Reader。它的原理是，我们创建“字符输入流”对象时，会指定“字节输入流”以及“字符编码”。

4)  实践

InputStream as =new FileInputStream("C:\\user路径\\123.txt");

InputStreamReaderisr = new InputStreamReader(as);

二十二、            OutputStreamWriter类

1)  构造方法

OutputStreamWriter(OutputStreamout, String charsetName)

OutputStreamWriter(OutputStreamout)

OutputStreamWriter(OutputStreamout, Charset cs)

OutputStreamWriter(OutputStreamout, CharsetEncoder enc)

2)  类方法

void write(int c)

void write(charcbuf[], int off, int len)

void write(Stringstr, int off, int len)

void flush()

void close()

3)  类作用

OutputStreamWriter是字节流通向字符流的桥梁：它使用指定的charset 读写字节并将其解码为字符。

OutputStreamWriter作用就是将“字节输出流”转换成“字符输出流”。它的原理是，我们创建“字符输出流”对象时，会指定“字节输出流”以及“字符编码”。

4)  实践

OutputStream os =new FileOutputStream("C:\\user路径\\123.txt");

OutputStreamWriterosw = new OutputStreamWriter(os);

二十三、            ObjectInputStream类

1)  构造方法

ObjectInputStream(InputStreaminput)

2)  类方法

int     available()

void     close()

void     defaultReadObject()

int     read(byte[] buffer, int offset, int length)

int     read()

boolean     readBoolean()

byte     readByte()

char     readChar()

double     readDouble()

ObjectInputStream.GetField     readFields()

float     readFloat()

void     readFully(byte[] dst)

void     readFully(byte[] dst, int offset, intbyteCount)

int     readInt()

String     readLine()

long     readLong()

final Object     readObject()

short     readShort()

String     readUTF()

Object     readUnshared()

int     readUnsignedByte()

int     readUnsignedShort()

synchronizedvoid    registerValidation(ObjectInputValidation object, int priority)

int     skipBytes(int length)

3)  类作用

ObjectInputStream 的作用是，对基本数据和对象进行序列化操作支持。当我们需要读取这些存储的“基本数据或对象”时，可以创建“文件输入流”对应的ObjectInputStream，进而读取出这些“基本数据或对象”。

注意： 只有支持java.io.Serializable 或 java.io.Externalizable 接口的对象才能被ObjectInputStream/ObjectOutputStream所操作！

4)  实践

ByteArrayInputStreambis = new ByteArrayInputStream(bos.toByteArray());

ObjectInputStreamois = new ObjectInputStream(bis);

addPhase =(LoanPhase) ois.readObject();//LoanPhase实体类必须序列化

ois.close();

二十四、            ObjectOutputStream类

1)  构造方法

ObjectOutputStream(OutputStreamout)

2)  类方法

void     close()

void     defaultWriteObject()

void     flush()

ObjectOutputStream.PutField     putFields()

void     reset()

void     useProtocolVersion(int version)

void     write(int value)

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

void     writeBoolean(boolean value)

void     writeByte(int value)

void     writeBytes(String value)

void     writeChar(int value)

void     writeChars(String value)

void     writeDouble(double value)

void     writeFields()

void     writeFloat(float value)

void     writeInt(int value)

void     writeLong(long value)

final void     writeObject(Object object)

void     writeShort(int value)

void     writeUTF(String value)

void     writeUnshared(Object object)

3)  类作用

ObjectOutputStream的作用是，对基本数据和对象进行序列化操作支持。创建“文件输出流”对应的ObjectOutputStream对象，该ObjectOutputStream对象能提供对“基本数据或对象”的持久存储；

注意： 只有支持java.io.Serializable 或 java.io.Externalizable 接口的对象才能被ObjectInputStream/ObjectOutputStream所操作！

4)  实践

ByteArrayOutputStreambos = new ByteArrayOutputStream();

ObjectOutputStreamoos = new ObjectOutputStream(bos);

oos.writeObject(lastPhase);// lastPhase实体类必须序列化

oos.close();

二十五、            PipedOutputStream类

1)  构造方法

PipedOutputStream(PipedInputStreamsnk)

PipedOutputStream()

2)  类方法

synchronized voidconnect(PipedInputStream snk)

void write(int b)

void write(byteb[], int off, int len)

synchronized voidflush()

void close()

3)  类作用

在java中，PipedOutputStream和PipedInputStream分别是管道输出流和管道输入流。

它们的作用是让多线程可以通过管道进行线程间的通讯。在使用管道通信时，必须将PipedOutputStream和PipedInputStream配套使用。

使用管道通信时，大致的流程是：我们在线程A中向PipedOutputStream中写入数据，这些数据会自动的发送到与PipedOutputStream对应的PipedInputStream中，进而存储在PipedInputStream的缓冲中；此时，线程B通过读取PipedInputStream中的数据。就可以实现，线程A和线程B的通信。

4)  实践

查阅26.PipedInputStream类 四、实践

二十六、            PipedInputStream类

1)  构造方法

PipedInputStream(PipedOutputStreamsrc) DEFAULT_PIPE_SIZE = 1024

PipedInputStream(PipedOutputStreamsrc, int pipeSize)

PipedInputStream()DEFAULT_PIPE_SIZE = 1024

PipedInputStream(intpipeSize)

2)  类方法

voidconnect(PipedOutputStream src)

synchronized intread()

synchronized intread(byte b[], int off, int len)

synchronized intavailable()

void close()

3)  类作用

在java中，PipedOutputStream和PipedInputStream分别是管道输出流和管道输入流。

它们的作用是让多线程可以通过管道进行线程间的通讯。在使用管道通信时，必须将PipedOutputStream和PipedInputStream配套使用。

使用管道通信时，大致的流程是：我们在线程A中向PipedOutputStream中写入数据，这些数据会自动的发送到与PipedOutputStream对应的PipedInputStream中，进而存储在PipedInputStream的缓冲中；此时，线程B通过读取PipedInputStream中的数据。就可以实现，线程A和线程B的通信。

4)  实践

PipedInputStreampin = new PipedInputStream();

PipedOutputStreampout = new PipedOutputStream();

pin.connect(pout);  //输入流与输出流连接

ReadThreadreadTh   = new ReadThread(pin);

WriteThreadwriteTh = new WriteThread(pout);

newThread(readTh).start();

newThread(writeTh).start();

二十七、            PipedReader和PipedWriter类

1)  构造方法

PipedReader(PipedWritersrc) DEFAULT_PIPE_SIZE = 1024

PipedReader(PipedWritersrc, int pipeSize)

PipedReader()DEFAULT_PIPE_SIZE = 1024

PipedReader(intpipeSize)

 

PipedWriter(PipedReadersnk)

PipedWriter()

2)  类方法

PipedReader方法

voidconnect(PipedWriter src)

synchronized intread()

synchronized intread(char cbuf[], int off, int len)

synchronizedboolean ready()

void close()

PipedWriter方法

synchronized voidconnect(PipedReader snk)

void write(int c)

void write(charcbuf[], int off, int len)

synchronized voidflush()

void close()

3)  类作用

（1）PipedWriter 是字符管道输出流，它继承于Writer。

（2）PipedReader 是字符管道输入流，它继承于Reader。

（3）PipedWriter和PipedReader的作用是可以通过管道进行线程间的通讯。在使用管道通信时，必须将PipedWriter和PipedReader配套使用。

（4）管道流通信核心是,Writer和Reader公用一块缓冲区,缓冲区在Reader中申请,由Writer调用和它绑定的Reader的Receive方法进行写.

（5）两个管道必须是未连接的，不然会抛IOException异常，而未连接的两个管道write.connect(read)或者read.connect(write)效果一样。

4)  实践

Sender t1 = newSender();

Receiver t2 = newReceiver();

PipedWriter out =t1.getWriter();

PipedReader in =t2.getReader();

//管道连接。下面2句话的本质是一样。

//out.connect(in);

in.connect(out);

/** 

* Thread类的START方法：

* 使该线程开始执行；Java 虚拟机调用该线程的run 方法。  

* 结果是两个线程并发地运行；当前线程（从调用返回给 start 方法）和另一个线程（执行其 run 方法）。 

* 多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。  

*/

t1.start();

t2.start();

二十八、            PrintStream类

1)  构造方法

// 将“输出流out”作为PrintStream的输出流，不会自动flush，并且采用默认字符集

// 所谓“自动flush”，就是每次执行print(),println(), write()函数，都会调用flush()函数；

// 而“不自动flush”，则需要我们手动调用flush()接口。

PrintStream(OutputStreamout)

// 将“输出流out”作为PrintStream的输出流，自动flush，并且采用默认字符集。

PrintStream(OutputStreamout, boolean autoFlush)

// 将“输出流out”作为PrintStream的输出流，自动flush，采用charsetName字符集。

PrintStream(OutputStreamout, boolean autoFlush, String charsetName)

// 创建file对应的FileOutputStream，然后将该FileOutputStream作为PrintStream的输出流，不自动flush，采用默认字符集。

PrintStream(Filefile)

// 创建file对应的FileOutputStream，然后将该FileOutputStream作为PrintStream的输出流，不自动flush，采用charsetName字符集。

PrintStream(Filefile, String charsetName)

// 创建fileName对应的FileOutputStream，然后将该FileOutputStream作为PrintStream的输出流，不自动flush，采用默认字符集。

PrintStream(StringfileName)

// 创建fileName对应的FileOutputStream，然后将该FileOutputStream作为PrintStream的输出流，不自动flush，采用charsetName字符集。

PrintStream(StringfileName, String charsetName)

2)  类方法

// 将“字符c”追加到“PrintStream输出流中”

PrintStream     append(char c)

// 将“字符序列从start(包括)到end(不包括)的全部字符”追加到“PrintStream输出流中”

PrintStream     append(CharSequence charSequence, intstart, int end)

// 将“字符序列的全部字符”追加到“PrintStream输出流中”

PrintStream     append(CharSequence charSequence)

// flush“PrintStream输出流缓冲中的数据”，并检查错误

boolean     checkError()

// 关闭“PrintStream输出流”

synchronizedvoid     close()

// flush“PrintStream输出流缓冲中的数据”。

// 例如，PrintStream装饰的是FileOutputStream，则调用flush时会将数据写入到文件中

synchronizedvoid     flush()

// 根据“Locale值(区域属性)”来格式化数据

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

// 根据“默认的Locale值(区域属性)”来格式化数据

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

// 将“float数据f对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数

void     print(float f)

// 将“double数据d对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数

void     print(double d)

// 将“字符串数据str”写入到“PrintStream输出流”中，print实际调用的是write函数

synchronizedvoid     print(String str)

// 将“对象o对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数

void     print(Object o)

// 将“字符c对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数

void     print(char c)

// 将“字符数组chars对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数

void     print(char[] chars)

// 将“long型数据l对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数

void     print(long l)

// 将“int数据i对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数

void     print(int i)

// 将“boolean数据b对应的字符串”写入到“PrintStream输出流”中，print实际调用的是write函数

void     print(boolean b)

// 将“数据args”根据“Locale值(区域属性)”按照format格式化，并写入到“PrintStream输出流”中

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

// 将“数据args”根据“默认Locale值(区域属性)”按照format格式化，并写入到“PrintStream输出流”中

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

// 将“换行符”写入到“PrintStream输出流”中，println实际调用的是write函数

void     println()

// 将“float数据对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数

void     println(float f)

// 将“int数据对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数

void     println(int i)

// 将“long数据对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数

void     println(long l)

// 将“对象o对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数

void     println(Object o)

// 将“字符数组chars对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数

void     println(char[] chars)

// 将“字符串str+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数

synchronizedvoid     println(String str)

// 将“字符c对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数

void     println(char c)

// 将“double数据对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数

void     println(double d)

// 将“boolean数据对应的字符串+换行符”写入到“PrintStream输出流”中，println实际调用的是write函数

void     println(boolean b)

// 将数据oneByte写入到“PrintStream输出流”中。oneByte虽然是int类型，但实际只会写入一个字节

synchronizedvoid     write(int oneByte)

// 将“buffer中从offset开始的length个字节”写入到“PrintStream输出流”中。

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

3)  类作用

PrintStream 是打印输出流，它继承于FilterOutputStream。

PrintStream 是用来装饰其它输出流。它能为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。

与其他输出流不同，PrintStream 永远不会抛出 IOException；它产生的IOException会被自身的函数所捕获并设置错误标记，用户可以通过 checkError() 返回错误标记，从而查看PrintStream内部是否产生了IOException。

另外，PrintStream 提供了自动flush 和 字符集设置功能。所谓自动flush，就是往PrintStream写入的数据会立刻调用flush()函数。

4)  实践

(1)File file = newFile("C:\\hebao-user\\123.txt");

PrintStream out =new PrintStream(new FileOutputStream(file));

(2)File file = newFile("C:\\hebao-user\\123.txt");

PrintStream out =new PrintStream(file);

(3)PrintStream ps= new PrintStream("C:\\hebao-user\\123.txt");

ps.write("asdf".getBytes());

ps.print("asdfas".toCharArray());

ps.print("asdfas")

二十九、            PrintWriter类

1)  构造方法

PrintWriter(OutputStreamout)

PrintWriter(OutputStreamout, boolean autoFlush)

PrintWriter(Writerwr)

PrintWriter(Writerwr, boolean autoFlush)

PrintWriter(Filefile)

PrintWriter(Filefile, String csn)

PrintWriter(StringfileName)

PrintWriter(StringfileName, String csn)

2)  类方法

PrintWriter     append(char c)

PrintWriter     append(CharSequence csq, int start, intend)

PrintWriter     append(CharSequence csq)

boolean     checkError()

void     close()

void     flush()

PrintWriter     format(Locale l, String format, Object...args)

PrintWriter     format(String format, Object... args)

void     print(float fnum)

void     print(double dnum)

void     print(String str)

void     print(Object obj)

void     print(char ch)

void     print(char[] charArray)

void     print(long lnum)

void     print(int inum)

void     print(boolean bool)

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

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

void     println()

void     println(float f)

void     println(int i)

void     println(long l)

void     println(Object obj)

void     println(char[] chars)

void     println(String str)

void     println(char c)

void     println(double d)

void     println(boolean b)

void     write(char[] buf, int offset, int count)

void     write(int oneChar)

void     write(char[] buf)

void     write(String str, int offset, int count)

void     write(String str)

3)  类作用

PrintWriter 是向文本输出流打印对象的格式化表示形式。此类实现在PrintStream中的所有与PrintStream类不同，如果启用了自动刷新，则只有在调用println、printf 或 format 的其中一个方法时才可能完成此操作，而不是每当正好输出换行符时才完成。这些方法使用平台自有的行分隔符概念，而不是换行符。此类中的方法不会抛出 I/O 异常，尽管其某些构造方法可能抛出异常。客户端可能会查询调用checkError()是否出现错误。

4)  实践

(1)File file = newFile("C:\\hebao-user\\123.txt");

PrintWriter out =new PrintWriter(new FileOutputStream(file, "UTF-8"));

(2)File file = newFile("C:\\hebao-user\\123.txt");

PrintWriter out =new PrintWriter(file);

(3)PrintWriter out= new PrintWriter("C:\\hebao-user\\123.txt");

ps.write("asdf".getBytes());

ps.print("asdfas".toCharArray());

ps.print("asdfas");