JAVA基础 IO流技术

package cn.it.bz.IO;

import java.io.FileInputStream;

public class TestIO01 {
    public static void main(String[] args) {
        //先准备管道（流对象）
        try {
            FileInputStream fileInputStream = new FileInputStream("D:/a.txt");
            int read1 = fileInputStream.read();//读取文件中的一个字节，返回该字节的ASCII码
            int read2 = fileInputStream.read();//读取文件中第二个字节
            int read3 = fileInputStream.read();//读取文件中第三个字节
            int read4 = fileInputStream.read();//读取文件中第四个字节
            System.out.println("输出第一个字节："+read1);
            System.out.println("输出第二个字节："+read2);
            System.out.println("输出第三个字节："+read3);
            System.out.println("输出第四个字节："+read4); //读完后没东西读了，就输出-1
            //关闭流,占用系统资源，可能造成系统崩溃
            fileInputStream.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

三、IO流经典写法（适用于任何JDK版本）

package cn.it.bz.IO;

import java.io.*;
public class TestIO02 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("d:/a.txt"); // 内容是：abc
            StringBuilder sb = new StringBuilder();
            int temp = 0;
            //当temp等于-1时，表示已经到了文件结尾，停止读取
            while ((temp = fis.read()) != -1) {
                sb.append((char) temp); //将ASCII码转换为字符
            }
            System.out.println(sb);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                //这种写法，保证了即使遇到异常情况，也会关闭流对象。
                if (fis != null) {
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

四、IO流新语法经典写法（仅限于JDK1.7以后）

在JDK7以及以后的版本中可以使用try-with-resource语法更优雅的关闭资源。在java.lang.AutoCloseable接口中包含了一个close方法，该方法用于关闭资源。只要是实现了java.lang.AutoCloseable接口的对象，都可以使用try-with-resource关闭资源。

package cn.it.bz.IO;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class TestIO03 {
    public static void main(String[] args) {
        //使用try-with-resource方式关闭资源。
        //在try中打开资源，不需要在代码中添加finally块关闭资源。
        try(FileInputStream fileInputStream = new FileInputStream("D:/a.txt")){
            StringBuilder stringBuilder = new StringBuilder();
            int temp = 0;
            while ((temp = fileInputStream.read()) != -1){
                stringBuilder.append((char)temp);
            }
            System.out.println(stringBuilder);
        }catch (IOException e){

        }
    }
}

五、Java中流的概念细分

5.1 按流的方向分类

输入流：数据流向是数据源到程序（以InputStream、Reader结尾的流）。
输出流：数据流向是程序到目的地（以OutPutStream、Writer结尾的流）。

5.2 按处理的数据单元分类

字节流：以字节为单位获取数据，命名上以Stream结尾的流一般是字节流，如FileInputStream、FileOutputStream。
字符流：以字符为单位获取数据，命名上以Reader/Writer结尾的流一般是字符流，如FileReader、FileWriter。

5.3 按处理对象不同分类

节点流：可以直接从数据源或目的地读写数据，如FileInputStream、FileReader、DataInputStream等。
处理流：不直接连接到数据源或目的地，是”处理流的流”。通过对其他流的处理提高程序的性能，如BufferedInputStream、BufferedReader等。处理流也叫包装流。

”处理流的流”解释：

假设程序要读取外部文件中的内容，我们就要选择FileReader作为流对象，但是FileReader只能一个一个字符地读取文件中的字符，这时就需要使用BufferedReader、BufferedInputStream处理FileReader流对象，于是就不再是一个一个字符地读取文件，而是能实现一行一行地读取文件按。

节点流处于IO操作的第一线，所有操作必须通过它们进行；处理流可以对节点流进行包装，提高性能或提高程序的灵活性。

六、Java中常用IO流类的体系

Java为我们提供了多种多样的IO流，我们可以根据不同的功能及性能要求挑选合适的IO流，如图所示，为Java中IO流类的体系。

从上图发现，很多流都是成对出现的，比如：FileInputStream/FileOutputStream，显然是对文件做输入和输出操作的。我们下面简单做个总结：

InputStream/OutputStream

字节流的抽象类。
Reader/Writer

字符流的抽象类。
FileInputStream/FileOutputStream

节点流：以字节为单位直接操作“文件”。
ByteArrayInputStream/ByteArrayOutputStream

节点流：以字节为单位直接操作“字节数组对象”。
ObjectInputStream/ObjectOutputStream

处理流：以字节为单位直接操作“对象”。
DataInputStream/DataOutputStream

处理流：以字节为单位直接操作“基本数据类型与字符串类型”。
FileReader/FileWriter

节点流：以字符为单位直接操作“文本文件”（注意：只能读写文本文件）。
BufferedReader/BufferedWriter

处理流：将Reader/Writer对象进行包装，增加缓存功能，提高读写效率。
BufferedInputStream/BufferedOutputStream

处理流：将InputStream/OutputStream对象进行包装，增加缓存功能，提高读写效率
InputStreamReader/OutputStreamWriter

处理流：将字节流对象转化成字符流对象。
PrintStream

处理流：将OutputStream进行包装，可以方便地输出字符，更加灵活。

文件字节流：sream结尾。

文件字符流：reader、writer结尾。

七、Java中IO的四大抽象类

InputStream/OutputStream和Reader/writer类是所有IO流类的抽象父类，我们有必要简单了解一下这个四个抽象类的作用。然后，通过它们具体的子类熟悉相关的用法。

7.1 InputStream

此抽象类是表示字节输入流的所有类的父类。InputSteam是一个抽象类，它不可以实例化。数据的读取需要由它的子类来实现。根据节点的不同，它派生了不同的节点流子类，例如：FileInputStream 以字节为单位直接操作“文件”。

继承自InputSteam的流都是用于向程序中输入数据，且数据的单位为字节（8 bit）。

常用方法
方法名	使用说明
int read()	读取一个字节的数据，并将字节的值作为int类型（字符的ASCII码）返回(0-255之间的一个值)。如果未读出字节则返回-1（返回值为-1表示读取结束）
void close(）	关闭输入流对象，释放相关系统资源

7.2 OutputStream

此抽象类是表示字节输出流的所有类的父类。输出流接收输出字节并将这些字节发送到某个目的地。

常用方法
方法名	使用说明
void write(int n)	向目的地中写入一个字节
void close()	关闭输出流对象，释放相关系统资源

7.3 Reader

Reader用于读取的字符流抽象类，数据单位为字符。

常用方法
方法名	使用说明
int read()	读取一个字符的数据，并将字符的值作为int类型返回(0-65535之间的一个值，即Unicode值)。如果未读出字符则返回-1（返回值为-1表示读取结束）
void close()	关闭流对象，释放相关系统资源

7.4 Writer

Writer用于输出的字符流抽象类，数据单位为字符。

常用方法
方法名	使用说明
void write(int n)	向输出流中写出一个字符
void close()	关闭流对象，释放相关系统资源

八、常用流详解

8.1 文件字节流

8.1.1 FileInputStream文件字节输入流

FileInputStream通过字节的方式读取文件，适合读取所有类型的文件（图像、视频、文本文件等）。文件字节流是一个字节一个字节读取数据，如果数据源的编码方式和目的地的解码方式不同就会造成乱码问题。

package cn.it.bz.IO;

import java.io.FileInputStream;
import java.io.IOException;

public class TestFileInputStream {
    public static void main(String[] args) {
        //将磁盘D中a.txt以字节输入到程序中

        try(FileInputStream fileInputStream = new FileInputStream("D:/a.txt");)
        {

            StringBuilder stringBuilder = new StringBuilder();
            int temp = 0;
            while ((temp = fileInputStream.read()) != -1){//获取文件中数据的字节
                //将字节转成字符
                stringBuilder.append((char)temp);
            }
            System.out.println(stringBuilder);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

需要注意的是read()方法无参数，返回值是int类型，代表的是文件中字符对应的ASCII编码。返回值如果是-1的话表示文件已经读取完毕。对于得到的ASCII一般需要在程序中再将其强制转换为char字符类型

8.1.2 FileOutputStream文件字节输出流

FileOutputStream 通过字节的方式写数据到文件中，适合所有类型的文件（图像、视频、文本文件等。这里的字节指的是写出数据的参数是字节，不是将字符的字节输到文件中。

package cn.it.bz.IO;

import java.io.FileOutputStream;
import java.io.IOException;

public class TestFileOutputStream {
    public static void main(String[] args) {
        //将Java以字节输出到D盘下的a.txt文件中
        //true:表示会追加到文件末尾。false（默认）:表示重写整个文件的内容。
        try (FileOutputStream fileOutputStream = new FileOutputStream("d:/a.txt",true);)
        {
            //准备输出的数据
            String data = " java";
            //将字符串转为字节数组:j=>106  a=>97  v=>118 a=>97
            byte[] bytes = data.getBytes();
            fileOutputStream.write(data.getBytes());
            //刷新，将数据从内存中写入到磁盘中
            fileOutputStream.flush();
        } catch (IOException E) {
            E.printStackTrace();
        }
    }
}

需要注意的是write()方法的参数是字节或者是字节数组，输出到文件的时候会自动将字节或者是字节数组转换为对应ASCII码表示的字符。

8.1.3 通过字节缓冲区提高读写速度

package cn.it.bz.IO;

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class TestFileBuffer {
    public static void main(String[] args) {
        //获取当前时间的毫秒数
        long startTime = System.currentTimeMillis();
        copyFile("D:/a.txt","d:/b.txt");
        long endTime = System.currentTimeMillis();
        System.out.println(endTime-startTime);
    }
    //文件复制。source：源文件。destination：目的地文件
    public static void copyFile(String source,String destination){
        //流的关闭顺序是后开先关
        try(FileInputStream fileInputStream = new FileInputStream(source);
            FileOutputStream fileOutputStream = new FileOutputStream(destination))
        {
            //字节缓冲区。因为输入输出流是文件字节流，因此使用字节数组作为缓冲区
            byte[] buffer = new byte[1024];
            //先将文件读到程序
            int temp = 0;
            while ((temp = fileInputStream.read(buffer))!= -1){
                System.out.println("temp:"+temp);
                //将文件写出去。buffer：表示一次写出的字节的大小。off:表示从第0个位置开始写出。temp：表示写出的文件取决于temp，temp决定了缓冲区有多少字节数。
                fileOutputStream.write(buffer,0,temp);
            }
            //将数据写出到磁盘中
            fileOutputStream.flush();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

fileInputStream.read(buffer)
将文件中的数据，读入到缓冲区buffer中，返回的是该组数据的大小。假设，被读取文件的最后一组只有200个字节，那么输入字节流也只会读取这200个字节存放到缓冲区，缓冲区剩下的空间是没有数据的。
fileOutputStream.write(buffer,0,temp);
将本次循环中的数据写出到目标文件中，如果不给0,temp这两个参数，则将缓冲区中1024个字节全部输出到目标文件中，也就是即使缓冲区中1024个字节只有200个字节是数据，那输出流也会将这1024个字节输出到你目标文件中，剩下的824个字节用空格补齐。

注意在使用字节缓冲区时，我们需要注意：

为了减少对硬盘的读写次数，提高效率，通常设置缓存数组。相应地，读取时使用的方法为：read(byte[] b)；写入时的方法为：write(byte[ ] b, int off, int length)
程序中如果遇到多个流，每个流都要单独关闭，防止其中一个流出现异常后导致其他流无法关闭的情况。

8.1.4 缓冲字节流

Java缓冲流本身并不具有IO流的读取与写入功能，只是在别的流（节点流或其他处理流）上加上缓冲功能提高效率，就像是把别的流包装起来一样，因此缓冲流是一种处理流（包装流）。

BufferedInputStream和BufferedOutputStream这两个流是缓冲字节流，通过内部缓存数组（其实和前面的缓冲区数组一样，只不过缓冲区大小默认是8192个字节，可以通过构造方法来修改该缓冲区的大小）来提高操作流的效率。

package cn.it.bz.IO;

import java.io.*;

public class TestFileBufferedStream {
    public static void main(String[] args) {
        //获取当前时间的毫秒数
        long startTime = System.currentTimeMillis();
        copyFile("D:/abc.jpg","d:/2.jpg");
        long endTime = System.currentTimeMillis();
        long time = endTime-startTime;
        System.out.println("时间："+time);
    }
    public static void copyFile(String source,String destination){
        //两个节点流，两个处理流
        try(FileInputStream fileInputStream = new FileInputStream(source);
            FileOutputStream fileOutputStream = new FileOutputStream(destination);
            BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
            )
        {

            int temp = 0;
            while ((temp = bufferedInputStream.read()) != -1){
                bufferedOutputStream.write(temp);
            }

        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

8.2 文件字符流

前面介绍的文件字节流可以处理所有的文件，如果我们处理的是文本文件，也可以使用文件字符流，它以字符为单位进行操作。

文件字符流一般用于读写文本文件，不用于读取二进制文件，会产生乱码。字符流在遇到英文时一次读取一个字节，在遇到中文时一次读取多个字节（gbk编码一次读三个。utf-8一次读两个），这和字符集有关。

8.2.1 FileReader文件字符输入流

使用文件字符输入流读取数据时，遇到汉字会读取多个字节，GBK编码的汉字一次读取两个字节，UTF-8 编码的一次读取三个字节，在程序得到汉字字节时会将其按照指定或者是默认的解码规则解码得到十进制数。

package cn.it.bz.IO;

import java.io.FileReader;
import java.io.IOException;

public class TestFileReader {

    public static void main(String[] args) {
        //创建文件字符输入流对象
        try(FileReader fileReader = new FileReader("D:/a.txt");)
        {
            StringBuilder stringBuilder = new StringBuilder();
            int temp = 0;
            while ((temp = fileReader.read()) != -1){
                System.out.println(temp);
                stringBuilder.append((char)temp); //将字符解码得到的十进制数据还原回字符
            }
            System.out.println("输出："+stringBuilder);
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

8.2.2 FileWriter文件字符输出流

package cn.it.bz.IO;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class TestFileWriter {

    public static void main(String[] args) {
        //创建文件字符输出流对象,默认将源文件的内容覆盖，true表示开启追加。
        try(FileWriter fileWriter = new FileWriter("D:/a.txt",true);)
        {
            fileWriter.write("张三\r\n");//"\r\n"表示回车换行
            fileWriter.flush();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

8.2.3 缓冲字符流

BufferedReader/BufferedWriter增加了缓存机制，大大提高了读写文本文件的效率。

字符输入缓冲流

BufferedReader是针对字符输入流的缓冲流对象，提供了更方便的按行读取的方法：readLine(); 在使用字符流读取文本文件时，我们可以使用该方法以行为单位进行读取。

package cn.it.bz.IO;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class TestBufferedReader {
    public static void main(String[] args) {
        //创建字符输入缓冲流和字符输入节点流
        try(BufferedReader bufferedReader = new BufferedReader(new FileReader("D:/a.txt")))
        {
            String temp = "";
            while ((temp = bufferedReader.readLine()) != null){//循环读取一行字符串
                System.out.println(temp);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

字符输出缓冲流

BufferedWriter是针对字符输出流的缓冲流对象，在字符输出缓冲流中可以使用newLine()；方法实现换行处理。

package cn.it.bz.IO;

import java.io.*;

public class TestBufferedWriter {
    public static void main(String[] args) {
        //创建字符输入缓冲流和字符输入节点流
        try(BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("D:/a.txt")))
        {
            //向文件写出字符串
           bufferedWriter.write("摄像头");
           bufferedWriter.newLine(); //换行 
            bufferedWriter.write("青青子衿悠悠我心");
            bufferedWriter.flush();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

注意

readLine()方法是BufferedReader的方法，可以对文本文件进行更加方便的读取操作。
newLine()方法BufferedWriter的方法，可以使用newLine()方法换行。

8.2.4 小练习：为文件中的内容添加行号

package cn.it.bz.IO;

import java.io.*;

public class TestLineNumber {
    public static void main(String[] args) {
        try(BufferedReader bufferedReader = new BufferedReader(new FileReader("D:/a.txt"));
            BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("D:/a1.txt"))
        ) {
            String temp = " ";
            int  i = 1;
            while ((temp = bufferedReader.readLine()) != null){
               //向a1.txt文件写入数据
                bufferedWriter.write(i+"、"+temp);
                //换行
                bufferedWriter.newLine();
                //i+1
                i++;
            }
            //刷新
            bufferedWriter.flush();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

8.3 转换流

InputStreamReader字节流转换为字符流/OutputStreamWriter将字符流转换为字节流。转换流也是处理流。

8.3.1 转换流处理乱码问题

计算机中数据的存储规则：

计算机中的数据都是二进制的数据，八个二进制位组成一个字节，英文字母占一个字节，汉字占两个字节。

ASCII字符集：

ASCII字符集最多表示128个字符（7位）且只能存储英文字符，一个字节最多表示256个字符（8位），因此英文字符占一个字节足够。计算机中存储的二进制数据都是8位，只有7位的ASCII码是不能直接存储到计算机中的。因此还需要对7位的ASCII码进行编码，使其转换为8为的二进制数据，编码的结果就是在ASCII码的最高位补0。

GBK字符集：

中国win电脑上显示的ANSI实际上就是指的GBK字符编码集。GBK完全兼容ASCII

需要注意的是：解码是将二进制转为十进制。

Unicode字符编码：

存储全世界的字符编码，Unicode字符编码针对的是全世界的字符，因此针对不同国家地区的文字采取不同的编码方式，最常见的就是UTF-8（注意UTF-8不是字符集），规定英文字符占一个字节且最高位为0（0xxxxxxx），汉字占三个字节从高位到低位依次是 1110xxxx 10xxxxxxxx 10xxxxxxxx。

乱码产生的原因：

1、读取字符时没有读完。

2、编码和解码方式不统一。

如何避免产生乱码？

1、不使用字节流读取文件

2、使用相同的编码和解码方式

package cn.it.bz.IO;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class TestInputStreamReader {
    public static void main(String[] args) {

            try(
                //创建文件字节输入流对象
                FileInputStream fileInputStream = new FileInputStream("D:/a2.txt");
               //创建字节到字符的转换流
                InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"gbk");
                )
            {
                StringBuilder stringBuilder = new StringBuilder();
                int temp = 0;
                while ((temp = inputStreamReader.read()) != -1){
                    stringBuilder.append((char) temp);
                }
                System.out.println(stringBuilder);
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

8.3.2 小练习：通过字节流读取文本文件并添加行号

package cn.it.bz.IO;



import java.io.*;

public class TestLineNumber2 {
    public static void main(String[] args) {

        try (
                //创建字节文件输入流
                FileInputStream fileInputStream = new FileInputStream("D:/a.txt");
                //将字节流转换为字符流（解决中文乱码）
                InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"utf-8") ;
                //再使用字符缓冲(读一行)
                BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

               //创建字符文件输出流
                FileWriter fileWriter = new FileWriter("D:/a1.txt");
                //创建文件字符缓冲区
                BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);

        )
        {
            int i = 1;
            StringBuilder stringBuilder  = new StringBuilder();
            String s = "";
            while ((s = bufferedReader.readLine()) != null){
                System.out.println(s);
                //添加行号
                bufferedWriter.write(i+"、"+s);
                //换行，相当于是bufferedWriter.write("\r\n")
                bufferedWriter.newLine();
                i++;
            }
            //释放资源
          bufferedWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

原理图：

8.3.3 字符输出流

package cn.it.bz.IO;

import java.io.IOException;
import java.io.PrintWriter;

public class TestPrintWriter {
    public static void main(String[] args) {
        //创建字符流输出对象
        try(PrintWriter printWriter = new PrintWriter("D:/a.txt")) {

            printWriter.print("Java");//不换行
            printWriter.print("百战");
            printWriter.println("sxt");//换行
            printWriter.println("哈哈哈");
            printWriter.flush();

        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

小练习：通过字符输出流添加行号

package cn.it.bz.IO;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;

public class TestLineNumber3 {
    public static void main(String[] args) {
        try(
                //读入一行数据数据
                BufferedReader bufferedReader = new BufferedReader(new FileReader("D:/a.txt"));
                //输出数据
                PrintWriter printWriter = new PrintWriter("D:/a1.txt")) {
            int i = 1;
            String s = "";
            while ((s = bufferedReader.readLine()) != null){
                printWriter.println(i+"、"+s);
                i++;
            }
            //释放资源
            printWriter.flush();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

8.4 数据流

数据流将“基本数据类型与字符串类型”作为数据源，从而允许程序以与机器无关的方式从底层输入输出流中操作Java基本数据类型与字符串类型。数据流是处理流，不是节点流，而且只能处理文件字节流，不能处理文件字符流。

package cn.it.bz.IO;

import com.sun.org.apache.xerces.internal.impl.dv.dtd.IDREFDatatypeValidator;

import java.io.*;

public class TestDataOutputStream {
    public static void main(String[] args) {
        //先向文件写数据，在从文件获取数据。
        try(DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream("D:/a.txt"));
            DataInputStream dataInputStream = new DataInputStream(new FileInputStream("d:/a.txt"))
        ) {

            //将如下数据写到文件
            dataOutputStream.writeChar('张');
            dataOutputStream.writeUTF("输出字符串");
            dataOutputStream.writeInt(123);
            dataOutputStream.writeDouble(Math.random());
            dataOutputStream.writeBoolean(true);

            dataOutputStream.flush();

            //读取顺序需要和写入顺序一样才行
            System.out.println(dataInputStream.readChar());
            System.out.println(dataInputStream.readUTF());
            System.out.println(dataInputStream.readInt());
            System.out.println(dataInputStream.readDouble());
            System.out.println(dataInputStream.readBoolean());

        }catch (IOException E){
            E.printStackTrace();
        }
    }
}

1、使用数据流时，读取的顺序一定要与写入的顺序一致，否则不能正确读取数据。

2、数据流只能处理文件字节流，不能处理文件字符流

8.5 对象流

我们前边学到的数据流只能实现对基本数据类型和字符串类型的读写，并不能读取对象（字符串除外），如果要对某个对象进行读写操作，我们需要学习一对新的处理流：ObjectInputStream/ObjectOutputStream。对象流实际上是数据流的升级版，使用对象流也能实现对Java中基本数据类型的读写操作，还能对自定义对象进行读写操作。对象流和数据流一样都是处理流，只能处理字节流不能处理字符流。

8.5.1 对象流处理基本数据类型

package cn.it.bz.IO;

import java.io.*;

public class TestObjectStreamBasicType {
    public static void main(String[] args) {
        try(ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("D:/a.txt"));
            ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("D:/a.txt"))
        ) {

            //数据写出
            objectOutputStream.writeInt(123);
            objectOutputStream.writeChar('h');
            objectOutputStream.writeBoolean(true);
            //刷新
            objectOutputStream.flush();

            //按照写入的顺序读取数据
            System.out.println(objectInputStream.readInt());
            System.out.println(objectInputStream.readChar());
            System.out.println(objectInputStream.readBoolean());
        }catch (IOException E){
           E.printStackTrace();
        }
    }
}

8.5.2 对象流将对象序列化到文件

ObjectOutputStream可以将一个内存中的Java对象通过序列化的方式写入到磁盘的文件中。被序列化的对象必须要实现Serializable序列化接口，否则会抛出异常。

package cn.it.bz.IO;

import java.io.*;

public class TestObjectOutputStream {
    public static void main(String[] args) {
        try(ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("D:/a.txt"));
            ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("D:/a.txt"))) {

            //创建Users对象
            Users users = new Users(123,"zhangsan","12");
            //将对象序列化到文件
            objectOutputStream.writeObject(users);
            //刷新
            objectOutputStream.flush();

        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

如果想一次性将多个对象序列化到文件中，可以将对象放在集合中，集合实现了序列化接口。

8.5.3 将对象反序列化到内存中

package cn.it.bz.IO;

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class TestObjectInputStream {
    public static void main(String[] args) {
        //创建对象输入字节流与文件字节输入流对象
        try(ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("d:/a.txt"))){
            //将对象反序列化到内存中
            Users users = (Users) objectInputStream.readObject();
            System.out.println(users);
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

九、File类在IO中的作用

File是操作文件的，当以文件作为数据源或目标时，除了可以使用字符串作为文件以及位置的指定以外，我们也可以使用File类指定。

package cn.it.bz.IO;

import java.io.*;

public class TestFile {
    public static void main(String[] args) {
        try(BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(new File("D:/a.txt")),"gbk"))) {

            String s ="";
            while ((s = bufferedReader.readLine()) != null){
                System.out.println(s);
            }

        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

十、装饰器模式构建IO流体系

10.1 装饰器模式简介

装饰器模式是GOF23种设计模式中较为常用的一种模式。它可以实现对原有类的包装和装饰，使新的类具有更强的功能。

package cn.it.bz.IO;

class Iphone{
    private String name;

    public Iphone(String name) {
        this.name = name;
    }

    public void show() {
        System.out.println("我是" + name + ",可以在屏幕上显示");
    }
}

//装饰器
class TouyingPhone {

    public Iphone phone;

    public TouyingPhone(Iphone p) {
        this.phone = p;
    }
    // 对Iphone功能的扩展
    public void show() {
        phone.show();
        System.out.println("还可以投影，在墙壁上显示");
    }
}

public class TestDecoration {
    public static void main(String[] args) {
        Iphone iphone = new Iphone("苹果18");
        //将有投影能力的手机壳装到手机上
        TouyingPhone touyingPhone = new TouyingPhone(iphone);
        touyingPhone.show();
    }
}

10.2 IO流体系中的装饰器模式

IO流体系中大量使用了装饰器模式，让流具有更强的功能、更强的灵活性。比如：

FileInputStream fis = new FileInputStream(src);
BufferedInputStream bis = new BufferedInputStream(fis);

显然BufferedInputStream装饰了原有的FileInputStream，让普通的FileInputStream也具备了缓存功能，提高了效率。

十一、Apache IO包

Apache基金会介绍

Apache软件基金会（也就是Apache Software Foundation，简称为ASF），是专门为支持开源软件项目而办的一个非盈利性组织。在它所支持的Apache项目与子项目中，所发行的软件产品都遵循Apache许可证（Apache License）。官方网址为：www.apache.org

很多著名的Java开源项目都来源于这个组织。比如：commons、kafka、lucene、maven、shiro、struts等技术，以及大数据技术中的：hadoop（大数据第一技术）、hbase、spark、storm、mahout等。

commons-io工具包

Apache的commons-io工具包中提供了IOUtils/FileUtils，为我们提供了更加简单、功能更加强大的文件操作和IO流操作功能。

下载与添加commons-io包

下载地址

Commons IO – Download Apache Commons IO

在项目中创建lib文件境jar包拖入到该文件中，然后右键lib选择Add as Library

11.1 FileUtils类中常用方法的介绍

打开FileUtils的api文档，我们抽出一些工作中比较常用的静态方法，进行总结和讲解。总结如下：

方法名	使用说明
cleanDirectory	清空目录，但不删除目录
contentEquals	比较两个文件的内容是否相同
copyDirectory	将一个目录内容拷贝到另一个目录。可以通过FileFilter过滤需要拷贝的文件
copyFile	将一个文件拷贝到一个新的地址
copyFileToDirectory	将一个文件拷贝到某个目录下
copyInputStreamToFile	将一个输入流中的内容拷贝到某个文件
deleteDirectory	删除目录
deleteQuietly	删除文件
listFiles	列出指定目录下的所有文件
openInputSteam	打开指定文件的输入流
readFileToString	将文件内容作为字符串返回
readLines	将文件内容按行返回到一个字符串数组中
size	返回文件或目录的大小
write	将字符串内容直接写到文件中
writeByteArrayToFile	将字节数组内容写到文件中
writeLines	将容器中的元素的toString方法返回的内容依次写入文件中
writeStringToFile	将字符串内容写到文件中

11.1.1使用FileUtils工具类读取文件

package cn.it.bz.IO;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;

public class TestUtils1 {
    public static void main(String[] args) throws IOException {
        //content表示读取的文件中的全部的内容
        String content = FileUtils.readFileToString(new File("D:/a.txt"), "gbk");
        System.out.println(content);
    }
}

11.1.2使用FileUtils工具类实现目录拷贝

我们可以使用FileUtils完成目录拷贝，在拷贝过程中可以通过文件过滤器(FileFilter)选择拷贝内容。

package cn.it.bz.IO;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;

public class TestFileUtils2 {
    public static void main(String[] args) throws IOException {
        FileUtils.copyDirectory(new File("D:\\图片"), new File("d:/aaa"), new FileFilter() {
            //给定文件拷贝规则,只拷贝以png结尾的文件
                    @Override
                    public boolean accept(File pathname) {
                         if (pathname.getName().endsWith(".png")){
                             return true;  //拷贝
                         }
                        return false;  //不拷贝
                    }
                }
        );
    }
}

11.2 IOUtils的妙用

打开IOUtils的api文档，我们发现它的方法大部分都是重载的。所以，我们理解它的方法并不是难事。因此，对于方法的用法总结如下：

方法名	使用说明
buffer	将传入的流进行包装，变成缓冲流。并可以通过参数指定缓冲大小
closeQueitly	关闭流
contentEquals	比较两个流中的内容是否一致
copy	将输入流中的内容拷贝到输出流中，并可以指定字符编码
copyLarge	将输入流中的内容拷贝到输出流中，适合大于2G内容的拷贝
lineIterator	返回可以迭代每一行内容的迭代器
read	将输入流中的部分内容读入到字节数组中
readFully	将输入流中的所有内容读入到字节数组中
readLine	读入输入流内容中的一行
toBufferedInputStream，toBufferedReader	将输入转为带缓存的输入流
toByteArray，toCharArray	将输入流的内容转为字节数组、字符数组
toString	将输入流或数组中的内容转化为字符串
write	向流里面写入内容
writeLine	向流里面写入一行内容

package cn.it.bz.IO;

import org.apache.commons.io.IOUtils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class TestIOUtilsDemo {
    public static void main(String[] args) throws IOException {
        String content = IOUtils.toString(new FileInputStream("D:/a.txt"), "gbk");
        System.out.println(content);
    }
}