学习笔记-马士兵java- （IO初步）流

1. Java 流式输入/输出原理：

　　a. 在JAVA程序中，对于数据的输入/输出操作以“流”（stream）方式进行；J2SDK 提供了各种各样的“流”类，用以获取不同类的数据；程序中通过标准的方法输入或输出数据。

2. JAVA 流类的分类：

　　a.  java.io 包中定义了多个流类型（类或抽象类）来实现输入/输出功能。可从不同角度对其进行分类：

　　　　① 按数据流的方向不同：输入流、输出流。

　　　　② 按处理数据单位不同：字节流、字符流。

　　　　③ 按功能不同：节点流、处理流。

　　b. J2SDK 所提供的所有流类型位于包 java.io 内都分别继承自一下四种抽象流类型。

　　　　　　　　　　　　字节流　　　　　　　　 字符流

　　　　输入流　　　　InputStream　　　　　　   Reader

　　　　输出流　　　　OutputStream　　　　　　Writer

　　c. 节点流和处理流：

　　　　① 节点流：可以从一个特定的数据源（节点）读写数据（如：文件、内存）。（直接与数据源相连）

　　　　② 处理流：“连接”在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能。

3. 输入/输出流类：

补充说明：管道为线程与线程之间的通信。

　　a. InputStream：继承自 InputStream 的流是用于向程序中输入数据，且数据的单位为字节（8bit）：

　　　　⑴ FileInputStream（节点流）　　// 从文件读数据

　　　　⑵ PipedInputStream（节点流）　　// 从管道读数据（管道：线程和线程的通信）

　　　　⑶ FilterInputStream（处理流）　　//

　　　　　　① LineNumberInputStream（处理流）　　//

　　　　　　② DataInputStream（处理流）　　//

　　　　　　③ BufferedInputStream（处理流）　　//

　　　　　　④ PushbackInputStream（处理流）　　//

　　　　⑷ ByteArrayInputStream（节点流）　　// 从字节数据读数据

　　　　⑸ SequenceInputStream（处理流）　　//

　　　　⑹ StringBufferInputStream（节点流）　　// 从字符串读数据

　　　　⑺ ObjectInputStream（处理流）　　// 对象的序列化

　　b. InputStream 的基本方法：

　　　　⑴ int read() throws IOException　　// 读取一个字节并以证书的形式返回（0~255），如果返回 -1 已到输入流的末尾。

　　　　⑵ int read(byte[] buffer) throws IOException　　// 读取一系列字节并存储到一个数组 buffer，返回实际读取的字节数，如果读取前已经到输入流的末尾返回 -1。

　　　　⑶  int read(byte[] buffer, int offset, int length) throws IOException　　// 读取 length 个字节，并存储到一个字节数组 buffer，从 length 位置开始，返回实际读取的字节数，如果读取前以到输入流的末尾返回 -1。

　　　　⑷ void close() throws IOException　　// 关闭流，释放内存资源。

　　　　⑸ long skip(long n) throws IOException　　// 跳过 n 个字节不读，返回实际跳过的字节数。

　　c. OutputStream: 继承自 OutputStream 的流是用于程序中输入数据，且数据的单位为字节（8bit）：

　　　　⑴ FileOutputStream（节点流）

　　　　⑵ PipedOutputStream（节点流）

　　　　⑶ FilterOutputStream（处理流）

　　　　　　① DataOutputStream（处理流）

　　　　　　② BufferedOutputStream（处理流）

　　　　　　③ PrintStream（处理流）

　　　　⑷ ByteArrayOutputStream（节点流）

　　　　⑸ ObjectOutputStream（处理流）

　　d. OutputStream 的基本方法：

　　　　⑴ void write(int b) throws IOException　　// 向输出流中写入一个字节数据，该字节数据为参数 b 的低 8 位。

　　　　⑵ void write(byte[] b) throws IOException　　// 将一个字节类型的数组中的数据写入输出流。

　　　　⑶ void write(byte[] b, int off, int len) throws IOException　　// 将一个字节类型的数组中的从指定位置（off）开始的 len 个字节写入到输出流。

　　　　⑷ void close() throws IOException　　// 关闭流，释放内存资源。

　　　　⑸ void flush() throws IOException　　// 将输出流中的缓冲的数据全部写出到目的地。

　　e. Reader：继承自 Reader 的流都是用于向程序中输入数据，且数据的单位为字符（16bit）：

　　　　⑴ BufferedReader（处理流）

　　　　　　① LineNumberReader（处理流）

　　　　⑵ CharArrayReader（节点流）

　　　　⑶ InputStreamReader（处理流）

　　　　　　① FileReader（节点流）

　　　　⑷ FilterReader（处理流）

　　　　　　① PushbackReader（处理流）

　　　　⑸ PipedReader（节点流）

　　　　⑹  StringReader（节点流）

　　f. Reader 的基本方法：

　　　　⑴ int read() throws IOException　　// 读取一个字符，并以证书的形式返回（0~255），如果返回 -1 已到输入流的末尾。

　　　　⑵ int read(char[] cbuf) throws IOException　　// 读取一系列字符并存储到一个数组 buffer，返回实际读取的字符数，如果读取前已经到输入流的末尾返回 -1.

　　　　⑶ int read(char[] cbuf, int offset, int length) throws IOException　　// 读取 length 个字符，并存储到一个数组 buffer，从 length 位置开始，返回实际读取的字符数，如果读取前已到输入流的末尾，返回 -1。

　　　　⑷ void close() throws IOException　　// 关闭流，释放内存资源。

　　　　⑸ long skip(long n) throws IOException　　// 跳过 n 个字符不读，返回实际跳过的字节数。

　　g. Write ：继承自 Writer 的流都是用于程序中输出数据，且数据的单位为字符（16 bit）:

　　　　⑴ BufferedWriter（处理流）

　　　　⑵ CharArrayWriter（节点流）

　　　　⑶ OutputStreamReader（处理流）

　　　　　　① FileWriter（节点流）

　　　　⑷ FilterWriter（处理流）

　　　　⑸ PipedWriter（节点流）

　　　　⑹ StringWriter（节点流）

　　　　⑺ FilterWriter（处理流）

　　h. Write 的基本方法：

　　　　⑴ void write(int c) throws IOException　　// 向输出流中写入一个字符数据，该字节数为参数 b 的低16位。

　　　　⑵ void write(char[] cbuf) throws  IOException　　// 讲一个字符类型的数据中的数据吸入输出流。

　　　　⑶ void write(char[] cbuf, int offset, int length) throws IOException　　// 将一个字符类型的数组中的从指定位置（offset）开始的 length 个字符写入到输出流。

　　　　⑷ void write(String string) throws IOException　　// 将一个字符串中的字符写入到输出流

　　　　⑸ void write(String string, int offset, int length) throws IOException　　// 将一个字符串从 offset 开始的 length 个字符写入到输出流。

　　　　⑹ void close() throws IOException　　// 关闭流，释放内存资源。

　　　　⑺ void flush() throws IOException　　// 将输出流中缓冲的数据全部写出到目的地。

4. 常见的节点流和处理流：

　　a. 节点流类型：

 

　　b. 访问文件：

　　　　① FileInputStream 和 FileOutputStream 分别继承自 InputStream 和 OutputStream 用于向文件中的输入和输出字节。

　　　　② FileInputStream 和 FileOutputStream 的常用构造方法：

　　　　　　⑴ FileInputStream(String name) throws FileNotFoundException

　　　　　　⑵ FileInputStream(File file) throws FileNotFoundException

　　　　　　⑶ FileOutputStream(String name) throws FileNotFoundException

　　　　　　⑷ FileOutputStream(File file) throws FileNotFoundException

　　　　　　⑸ FileOutputStream(File file, boolean append) throws FileNotFoundException

　　　　③ FileInputStream 和 FileOutputStream 类支持其父类 InputStream 和 OutputStream 所提供的数据读写方法。

　　　　④ 注意：

　　　　　　Ⅰ 在实例化 FileInputStream 和 FileOutputStream 流时要用 try - catch 语句以处理其可能抛出的 FileNotFoundException。

　　　　　　Ⅱ 在读写数据时也要用 try - catch 语句以处理可能抛出的 IOException。

　　　　　　Ⅲ FileNotFoundException 是 IOException 的子类。

　　c. 处理流类型：

　　

5. 文件流：

　　a.

6. 缓冲流（处理流）：

　　a. 缓冲流要“套接”在相应的节点流之上，对读写数据提供了缓冲的能力，提高了读写的效率，同时增加了一些新的方法。

　　b. J2SDK 提供了四栋缓存流，其常用的构造方法：

　　　　⑴ BufferedReader(Reader in)

　　　　⑵ BufferedReader(reader in, int sz)　　// sz 为自定义缓存区的大小

　　　　⑶ BufferedWriter(Writer out)

　　　　⑷ BufferedWriter(Writer out, int sz)

　　　　⑸ BufferedInputStream(InputStream in)

　　　　⑹ BufferedInputStream(InputStream in, int size)

　　　　⑺ BufferedOutputStream(OutputStream out)

　　　　⑻ BufferedOutputStream(OutputStream out, int size)

　　c. 缓冲输入流支持其父类的 mark 和 reset 方法。

　　d. BufferedReader 提供了 readLine 方法用于读取一行字符串（以 \r 或 \n 分隔）。

　　e. BufferedWriter 提供了 newLine 用于写入一个"行分隔符"。

　　f. 对于输出的缓冲流，写出的数据会先在内存中缓存，使用 flush 方法将会使内存中的数据立刻写出。

7. 数据流(先写进去的先读出来)：

　　a. DataInputStream 和 DataOutputStream 分别继承自 InputStream 和 OutPutStream，它属于处理流，需要分别“套接”在 InputStream 和 OutputStream 类型的节点流上。

　　b. DataInputStream 和 DataOutputStream 提供了可以存取与机器无关的Java原始类型数据（如：int, double 等）的方法。

　　c. DataInputStream 和 DataOutputStream 的构造方法为：

　　　　① DataInputStream(InputStream in)

　　　　② DataOutputStream(OutputStream out)

8. 转换流(字节流与字符流的转换)：

　　a. InputStreamReader 和 OutputStreamWriter 用与字节数据到字符数据之间的转换。

　　b. InputStreamReader 需要和 InputStream “套接"。

　　c. OutputStreamWriter 需要和 OutputStream “套接"。

　　d. 转换流在构造时可以指定其编码集合，例如：

　　　　InputStream isr = new InputStreamReader(System in, "ISO8859_1")

9. Print 流：

　　a. PrintWriter 和 PrintStream 都属于输出流，分别针对与字符和字节。

　　b. PrintWriter 和 PrintStream 提供了重载的 print。

　　c. Println 方法用于多种数据类型的输出。

　　d. PrintWriter 和 PrintStream 的输出操作不会抛出异常，用户通过检测错误状态获取错误信息。

　　e.  PrintWriter 和 PrintStream 有自动 flush 功能。

　　f. PrintWriter常用构造方法：

　　　　⑴ PrintWriter(Writer out)

　　　　⑵ PrintWriter(Writer out,boolean autoFlush)

　　　　⑶ PrintWriter(OutputStream out)

　　　　⑷ PrintWriter(Outputstream out,boolean autoFlush)

　　　　⑸ PrintStream(OutputStream out)

　　　　⑹ PrintStream(OutputStream out, booleanautoFlush)

10. Object流（序列化）：

　　a. 直接将Object 写入或独处

　　　　① transient 关键字（透明的，修饰成员变量，transient 修饰的成员变量在序列化的时候不予考虑）

　　　　② serializable 接口（可序列化，标记性接口，不用实现任何方法）

　　　　③ externalizable 接口（外部化，serializable的子接口，自己实现对象序列化）：

　　　　　　⑴ readExternal(ObjectInput in)　　//  读对象 in

　　　　　　⑵ writeExternal(ObjectOutput out)　　// 写对象 out