# JavaSE —— IO

# 1. 原理

I/O 是 Input/Output 的缩写， I/O 技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。
Java 程序中，对于数据的输入/输出操作以“流(stream)” 的方式进行。
java.io 包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。
输入 input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
输出 output：将程序（内存）数据输出到磁盘、光盘等存储设备中。

# 2. 分类

按操作数据单位不同分为

字节流(8 bit)
字符流(16 bit)

按数据流的流向不同分为：

输入流
输出流

按流的角色的不同分为：

节点流：直接从数据源或目的地读写数据。
处理流：不直接连接到数据源或目的地，而是“连接”在已存在的流(节点流或处理流)之上，通过对数据的处理为程序提供更为强大的读写功能。

# 3. 流体系

装饰器模式

动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式想必生成子类更为灵活。

装饰模式又名包装（Wrapper）模式。装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。

装饰模式中的角色

抽象构件角色（Component）：给出一个抽象接口，以规范准备接受附加责任的对象。
具体构件角色（ConcreteComponent）：定义一个将要接收附加责任的类。
装饰角色（Decorator）：持有一个构件（Component）对象的实例，并定义一个与抽象构件接口一致的接口。
具体装饰角色（ConcreteDecorator）：负责给构件对象“贴上”附加的责任。

适用场景

想透明并且动态地给对象增加新的职责的时候
给对象增加的职责，在未来存在增加或减少功能
用继承扩展功能不太现实的情况下，应该考虑用组合的方式
装饰模式与继承关系的目的都是要扩展对象的功能，但是装饰模式可以提供比继承更多的灵活性。装饰模式允许系统动态决定“贴上”一个需要的“装饰”，或者除掉一个不需要的“装饰”。继承关系则不同，继承关系是静态的，它在系统运行前就决定了。
通过使用不同的具体装饰类以及这些装饰类的排列组合，设计师可以创造出很多不同行为的组合。

优点

通过组合而非继承的方式，实现了动态扩展对象的功能的能力。
有效避免了使用继承的方式扩展对象功能而带来的灵活性差，子类无限制扩张的问题。
充分利用了继承和组合的长处和短处，在灵活性和扩展性之间找到完美的平衡点。
装饰者和被装饰者之间虽然都是同一类型，但是它们彼此是完全独立并可以各自独立任意改变的。
遵守大部分 GRAP 原则和常用设计原则，高内聚、低偶合。

缺点

装饰链不能过长，否则会影响效率。
因为所有对象都是继承于 Component，所以如果 Component 内部结构发生改变，则不可避免地影响所有子类（装饰者和被装饰者），也就是说，通过继承建立的关系总是脆弱地，如果基类改变，势必影响对象的内部，而通过组合建立的关系只会影响被装饰对象的外部特征。
只在必要的时候使用装饰者模式，否则会提高程序的复杂性，增加系统维护难度。

JDK中的装饰模式

由于 Java I/O 库需要很多性能的各种组合，如果这些性能都是用继承的方法实现的，那么每一种组合都需要一个类，这样就会造成大量性能重复的类出现。而如果采用装饰模式，那么类的数目就会大大减少，性能的重复也可以减至最少。因此装饰模式是 Java I/O 库的基本模式。

根据上图可以看出：

抽象构件（Component）角色：由 InputStream 扮演。这是一个抽象类，为各种子类型提供统一的接口。
具体构件（ConcreteComponent）角色：由 ByteArrayInputStream、FileInputStream、PipedInputStream、StringBufferInputStream 等类扮演。它们实现了抽象构件角色所规定的接口。
抽象装饰（Decorator）角色：由 FilterInputStream 扮演。它实现了 InputStream 所规定的接口。
具体装饰（ConcreteDecorator）角色：由几个类扮演，分别是 BufferedInputStream、DataInputStream 以及两个不常用到的类LineNumberInputStream、PushbackInputStream。

# 4. 四个抽象基类

# InputStream

int read()

从输入流中读取数据的下一个字节。返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。
int read(byte[] b)

从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。否则以整数形式返回实际读取的字节数。
int read(byte[] b, int off,int len)

将输入流中最多 len 个数据字节读入 byte 数组。尝试读取 len 个字节，但读取的字节也可能小于该值。以整数形式返回实际读取的字节数。如果因为流位于文件末尾而没有可用的字节，则返回值 -1。
public void close() throws IOException

关闭此输入流并释放与该流关联的所有系统资源。

# Reader

int read()

读取单个字符。作为整数读取的字符，范围在 0 到 65535 之间 (0x00-0xffff)(2个字节的Unicode码)，如果已到达流的末尾，则返回 -1。
int read(char[] cbuf)

将字符读入数组。如果已到达流的末尾，则返回 -1。否则返回本次读取的字符数。
int read(char[] cbuf,int off,int len)

将字符读入数组的某一部分。存到数组 cbuf 中，从 off 处开始存储，最多读 len 个字符。如果已到达流的末尾，则返回 -1。否则返回本次读取的字符数。
public void close() throws IOException

关闭此输入流并释放与该流关联的所有系统资源。

# OutputStream

void write(int b)

将指定的字节写入此输出流。write 的常规协定是：向输出流写入一个字节。要写入的字节是参数 b 的八个低位。b 的 24 个高位将被忽略。即写入0~255范围的。
void write(byte[] b)

将 b.length 个字节从指定的 byte 数组写入此输出流。write (b) 的常规协定是：应该与调用 write(b, 0, b.length) 的效果完全相同。
void write(byte[] b,int off,int len)

将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
public void flush()throws IOException

刷新此输出流并强制写出所有缓冲的输出字节，调用此方法指示应将这些字节立即写入它们预期的目标。
public void close() throws IOException

关闭此输出流并释放与该流关联的所有系统资源。

# Writer

void write(int c)

写入单个字符。要写入的字符包含在给定整数值的 16 个低位中，16 高位被忽略。即写入0 到 65535 之间的Unicode码。
void write(char[] cbuf)

写入字符数组。
void write(char[] cbuf,int off,int len)

写入字符数组的某一部分。从 off 开始，写入 len 个字符。
void write(String str)

写入字符串。
void write(String str,int off,int len)

写入字符串的某一部分。
void flush()

刷新该流的缓冲，则立即将它们写入预期目标。
public void close() throws IOException

关闭此输出流并释放与该流关联的所有系统资源。

# 5. 节点流（文件流）

# 读取文件

FileInputStream 从文件系统中的某个文件中获得输入字节。

FileInputStream 用于读取非文本数据之类的原始字节流。

要读取字符流，需要使用 FileReader。

四部曲：

示例：

    @Test
    public void testFileReader(){

     	  //1. 创建一个流对象，将已经存在的文件加载入流
        FileReader fr = null;
        try{
            //IDEA 中相对路径：相对于当前 Module（main方法里面的是相对于当前Project）
            fr = new FileReader(new File(("src/com/hedon/iotest/Test.txt")));
            //2. 创建一个临时存放数据的数组
            char[] ch = new char[1024];
            int len;
            //3. 调用流对象的读取方法将流中数据读到数组中
            while ((len=fr.read(ch)) != -1){
                System.out.println(new String(ch,0,len));
            }
        }catch (IOException e){
            System.out.println("read-Exception:" + e.getMessage());
        }finally {
            try{
                //4. 关系资源
                fr.close();
            }catch (IOException e){
                System.out.println("close-Exception :" + e.getMessage());
            }
        }
    }

# 写入文件

FileOutputStream 从文件系统中的某个文件中获得输出字节。

FileOutputStream 用于写出非文本数据之类的原始字节流。

要写出字符流，需要使用 FileWriter。

三部曲：

示例：

	  @Test
    public void testFileWriter(){

        FileWriter fw = null;
        try {
            //1. 创建一个流对象，将已经存在的文件加载入流
            fw = new FileWriter(new File("src/com/hedon/iotest/Test.txt"));
            //2. 写入数据
            fw.write("新的数据写进来啦~");
        }catch (IOException e){
            System.out.println("write-exception: " + e.getMessage());
        }finally {
            try {
                if (fw != null){
                    //3. 关闭
                    fw.flush();
                    fw.close();
                }
            }catch (Exception e){
                System.out.println("close-exception: " + e.getMessage());
            }
        }

    }

# 注意点：

在写入一个文件时，如果使用构造器 FileOutputStream(file)，则目录下有同名文件将被覆盖。
如果使用构造器 FileOutputStream(file,true)，则目录下的同名文件不会被覆盖，在文件内容末尾追加内容。
在读取文件时，必须保证该文件已存在，否则报异常。
字节流操作字节，比如：.mp3，.avi，.rmvb，mp4，.jpg，.doc，.ppt
字符流操作字符，只能操作普通文本文件。最常见的文本文件：.txt，.java，.c，.cpp 等语言的源代码。尤其注意 .doc, excel, ppt 这些不是文本文件。

# 6. 缓冲流

# 6.1 作用

为了提高数据读写的速度，Java API 提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组，缺省使用 8192 个字节（8Kb）的缓冲区。

# 6.2 分类

缓冲流要“套接”在相应的节点流（文件流）之上，根据数据操作单位可以把缓冲流分为:

BufferedInputStream、BufferedOutputStream
BufferedReader、BufferedWriter

# 6.3 原理

# 读

当读取数据时，数据按块读入缓冲区，其后的读操作则直接访问缓冲区。

当使用 BufferedInputStream 读取字节文件时，BufferedInputStream 会一次性从文件中读取 8192 个（8Kb）字节，存在缓冲区中，直到缓冲区装满了，才重新从文件中读取下一个 8192 个字节数组。

# 写

向流中写入字节时，不会直接写到文件，先写到缓冲区中直到缓冲区写满， BufferedOutputStream 才会把缓冲区中的数据一次性写到文件里。

使用方法 flush() 可以强制将缓冲区的内容全部写入输出流。

# 关

关闭流的顺序和打开流的顺序相反。只要关闭最外层流即可，关闭最外层流也会相应关闭内层节点流。

如果是带缓冲区的流对象的 close() 方法，不但会关闭流，还会在关闭流之前刷新缓冲区，关闭后不能再写出。

# 6.4 示例

/**
 * 复制文件内容
 */
@Test
public void testBuffer(){

    BufferedReader br = null;
    BufferedWriter bw = null;

    try {
        //源文件
        br = new BufferedReader(new FileReader("src/com/hedon/iotest/source.txt"));
        //目标文件
        bw = new BufferedWriter(new FileWriter("src/com/hedon/iotest/dest.txt"));
        String str;
        //一次读取字符文本文件的一行字符
        while ((str = br.readLine()) != null){
            bw.write(str);  //一次写入一行字符串
            bw.newLine();   //写入行分隔符
        }
        //刷新缓冲区
        bw.flush();
    }catch (IOException e){
        System.out.println("read or write exception: " + e.getMessage());
    }finally {
        try {
            if(bw != null){
                // 关闭过滤流时,会自动关闭它所包装的底层节点流
                bw.close();
            }
        }catch (IOException e){
            System.out.println("close bw exception: " + e.getMessage());
        }

        try {
            if (br != null){
                br.close();
            }
        }catch (IOException e){
            System.out.println("close br exception: " + e.getMessage());
        }
    }
}

# 7. 转换流

转换流提供了在字节流和字符流之间的转换
Java API 提供了两个转换流：
- InputStreamReader：将 InputStream 转换为 Reader
- OutputStreamWriter：将 Writer 转换为 OutputStream
字节流中的数据都是字符时，转成字符流操作更高效。
很多时候我们使用转换流来处理文件乱码问题，实现编码和解码的功能。

# InputStreamReader

实现将字节的输入流按指定字符集转换为字符的输入流 -> 将 InputStream 转换为 Reader
需要和 InputStream “套接”。

构造器：

public InputStreamReader(InputStream in)
public InputSreamReader(InputStream in,String charsetName)
- 如: Reader isr = new InputStreamReader(System.in,“gbk”);

# OutputStreamWriter

实现将字符的输出流按指定字符集转换为字节的输出流 -> 将 Writer 转换为 OutputStream
需要和 OutputStream “套接”。

构造器：

public OutputStreamWriter(OutputStream out)
public OutputSreamWriter(OutputStream out,String charsetName)

    @Test
    public void transferTest() throws IOException{

        FileInputStream fis = new FileInputStream("src/com/hedon/iotest/Test.txt");
        FileOutputStream fos = new FileOutputStream("src/com/hedon/iotest/Test1.txt");

        InputStreamReader isr = new InputStreamReader(fis);
        OutputStreamWriter osw = new OutputStreamWriter(fos);

        BufferedReader br = new BufferedReader(isr);
        BufferedWriter bw = new BufferedWriter(osw);

        String str = null;
        while ((str = br.readLine()) != null){
            bw.write(str);
            bw.newLine();
            bw.flush();
        }
        bw.close();
        br.close();
    }

# 8. 标准流

System.in 和 System.out 分别代表了系统标准的输入和输出设备
默认输入设备是：键盘，输出设备是：显示器
System.in 的类型是 InputStream
System.out 的类型是 PrintStream，其是 OutputStream、FilterOutputStream 的子类
重定向：通过 System 类的 setIn，setOut 方法对默认设备进行改变。

public static void setIn(InputStream in) public static void setOut(PrintStream out)

例题：从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，直至当输入“e”或者“exit”时，退出程序。

		@Test
    public void standardStreamTest(){
        BufferedReader br = null;
        String s = null;
        try{
            // 把"标准"输入流(键盘输入)这个字节流包装成字符流,再包装成缓冲流
            InputStream in = System.in;
            InputStreamReader isr = new InputStreamReader(in);
            br = new BufferedReader(isr);
            //阻塞等待
            while ((s = br.readLine()) != null){
                if ("e".equalsIgnoreCase(s) || "exit".equalsIgnoreCase(s)){
                    System.out.println("安全退出！！");
                    break;
                }
                //将读取到的整行字符串大写
                System.out.println("->: " + s.toUpperCase());
                System.out.println("继续输入信息");
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                if (br != null){
                    // 关闭过滤流时,会自动关闭它包装的底层节点流
                    br.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }

    }

# 9. 打印流

实现将基本数据类型的数据格式转化为字符串输出。
打印流：PrintStream 和 PrintWriter
- 提供了一系列重载的 print() 和 println() 方法，用于多种数据类型的输出
- PrintStream 和 PrintWriter 的输出不会抛出 IOException 异常
- PrintStream 和 PrintWriter 有自动 flush 功能
- PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。
- System.out 返回的是 PrintStream 的实例

    @Test
    public void printStreamTest(){
        PrintStream ps = null;
        try{
            FileOutputStream fos = new FileOutputStream(new File("src/com/hedon/iotest/Test.txt"));
            // 创建打印输出流，设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
            ps = new PrintStream(fos,true);
            // 把标准输出流(控制台输出)改成文件
            if (ps != null){
                System.setOut(ps);
            }
            for (int i = 0; i < 256; i++) {
                // 输出ASCII字符
                System.out.println((char)i);
                // 每50个数据一行
                if ( i % 50 == 0){
                    System.out.println();
                }
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if (ps != null){
                ps.close();
            }
        }
    }

# 10. 数据流

为了方便地操作 Java 语言的基本数据类型和 String 的数据，可以使用数据流。
数据流有两个类：(用于读取和写出基本数据类型、String类的数据)
- DataInputStream
- DataOutputStream
- 分别“套接”在 InputStream 和 OutputStream 子类的流上

# DataInputStream

boolean readBoolean()
char readChar()
double readDouble()
long readLong()
String readUTF()
byte readByte()
float readFloat()
short readShort()
int readInt()
void readFully(byte[] b)

# DataOutputStream

将上述的方法的 read 改为相应的 write 即可。

		@Test
    public void dataStreamTest(){
        DataOutputStream dos = null;
        try{
            dos = new DataOutputStream(new FileOutputStream("src/com/hedon/iotest/Test.txt"));
            dos.writeUTF("Java 天下第一");
            dos.writeBoolean(true);
            dos.writeLong(1234567890L);
            System.out.println("写文件成功!");
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try {
                if (dos != null){
                    // 关闭过滤流时,会自动关闭它包装的底层节点流
                    dos.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }

    }

# 11. 对象流

ObjectInputStream
OjbectOutputSteam

# 11.1 作用

用于存储和读取基本数据类型数据或对象的处理流。
它的强大之处就是可以把 Java 中的对象写入到数据源中，也能把对象从数据源中还原回来。

# 11.2 序列化/反序列化

序列化：用 ObjectOutputStream 类保存基本类型数据或对象的机制。

反序列化：用 ObjectInputStream 类读取基本类型数据或对象的机制。

注意：ObjectOutputStream 和 ObjectInputStream 不能序列化 static 和 transient 修饰的成员变量。

# 11.3 对象的序列化

对象序列化机制允许把内存中的 Java 对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。当其它程序获取了这种二进制流，就可以恢复成原来的 Java 对象

序列化的好处在于可将任何实现了 Serializable 接口的对象转化为字节数据，使其在保存和传输时可被还原。

序列化是 RMI（Remote Method Invoke – 远程方法调用） 过程的参数和返回值都必须实现的机制，而 RMI 是 JavaEE 的基础。因此序列化机制是 JavaEE 平台的基础。

如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一。否则，会抛出 NotSerializableException 异常

Serializable
Externalizable

凡是实现 Serializable 接口的类都有一个表示序列化版本标识符的静态变量：private static final long serialVersionUID

serialVersionUID 用来表明类的不同版本间的兼容性。简言之，其目的是以序列化对象进行版本控制，有关各版本反序列化时是否兼容。
如果类没有显示定义这个静态常量，它的值是 Java 运行时环境根据类的内部细节自动生成的。若类的实例变量做了修改，serialVersionUID 可能发生变化。故建议，显式声明。
简单来说，Java 的序列化机制是通过在运行时判断类的 serialVersionUID 来验证版本一致性的。在进行反序列化时，JVM 会把传来的字节流中的 serialVersionUID 与本地相应实体类的 serialVersionUID 进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常——InvalidCastException。

# 11.4 使用

若某个类实现了 Serializable 接口，该类的对象就是可序列化的：

创建一个 ObjectOutputStream
调用 ObjectOutputStream 对象的 writeObject(对象) 方法输出可序列化对象
注意写出一次，操作 flush() 一次

反序列化：

创建一个 ObjectInputStream
调用 readObject() 方法读取流中的对象

强调：如果某个类的属性不是基本数据类型或 String 类型，而是另一个引用类型。那么这个引用类型必须是可序列化的，否则拥有该类型的 Field 的类也不能序列化。

# 谈谈你对 java.io.Serializable 接口的理解，我们知道它用于序列化，是空方法接口，还有其它认识吗?
1. 实现了 Serializable 接口的对象，可将它们转换成一系列字节，并可在以后完全恢复回原来的样子。这一过程亦可通过网络进行。这意味着序列化机制能自动补偿操作系统间的差异。
	 换句话说，可以先在 Windows 机器上创建一个对象，对其序列化，然后通过网络发给一台 Unix 机器，然后在那里准确无误地重新“装配”。不必关心数据在不同机器上如何表示，也不必关心字节的顺序或者其他任何细节。
2. 由于大部分作为参数的类如 String、Integer 等都实现了 java.io.Serializable 的接口，也可以利用多态的性质，作为参数使接口更灵活。

# 12. 随机存取文件流

RandomAccessFile

# 12.1 作用

RandomAccessFile 声明在 java.io 包下，但直接继承于 java.lang.Object 类。并且它实现了 DataInput、DataOutput 这两个接口，也就意味着这个类既可以读也可以写。

RandomAccessFile 类支持 “随机访问” 的方式，程序可以直接跳到文件的任意地方来读、写文件

支持只访问文件的部分内容
可以向已存在的文件后追加内容

RandomAccessFile 对象包含一个记录指针，用以标示当前读写处的位置。

RandomAccessFile 类对象可以自由移动记录指针:

long getFilePointer()：获取文件记录指针的当前位置
void seek(long pos)：将文件记录指针定位到 pos 位置

# 12.2 构造器

public RandomAccessFile(File file, String mode)
public RandomAccessFile(String name, String mode)

创建 RandomAccessFile 类实例需要指定一个 mode 参数，该参数指定 RandomAccessFile 的访问模式：

r：以只读方式打开
rw：打开以便读取和写入
rwd：打开以便读取和写入，同步文件内容的更新
rws：打开以便读取和写入，同步文件内容和元数据的更新

如果模式为只读 r，则不会创建文件，而是会去读取一个已经存在的文件，。如果读取的文件不存在则会出现异常。

如果模式为 rw 读写。如果文件不存在则会去创建文件，如果存在则不会创建。

# 12.3 应用

我们可以用 RandomAccessFile 这个类，来实现一个多线程断点下载的功能，用过下载工具的朋友们都知道，下载前都会建立两个临时文件，一个是与被下载文件大小相同的空文件，另一个是记录文件指针的位置文件，每次暂停的时候，都会保存上一次的指针，然后断点下载的时候，会继续从上一次的地方下载，从而实现断点下载或上传的功能。

← JavaSE —— File 类 JavaSE —— BIO/NIO/AIO →