【Java】IO流

一、IO流基本概念

1.1、比特(Bit)、字节(Byte)、字符(Char)

• Bit 位，是计算机最小的二进制单位 ，取0或1，主要用于计算机操作。

• Byte 字节，是数据的最小单位，由8位bit组成，取值（-128-127），主要用于计算机操作数据。

• Char 字符，是用户可读写的最小单位，由16位bit（2个byte）组成，取值（0-65535），主要用于用户操数数据。

1.2、IO流的概念

1. 它是指数据从源头 流到 目的地，所以常把这种数据流叫做IO流。

2. I/O是Input/Output的缩写， I/O技术是非常实用的技术，用于 处理设备之间的数据传输。如读/写文件，网络通讯等。

3. Java程序中，对于数据的输入/输出操作以“流(stream)” 的 方式进行。　

4. java.io包下提供了各种“流”类和接口，用以获取不同种类的 数据，并通过标准的方法输入或输出数据。　　

5. 输入input: 读取外部数据(磁 盘、光盘等存储设备的数据)到 程序(内存)中。

6. 输出output: 将程序(内存) 数据输出到磁盘、光盘等存储设 备中。

1.3、流的分类

1. 按操作数据单位不同分为: 字节流(8 bit)，字符流(16 bit) 

2. 按数据流的流向不同分为: 输入流，输出流 

3. 按流的角色的不同分为: 节点流，处理流

　　

1.4、IO 流体系

　　　　

　　1、Java的IO流共涉及40多个类，实际上非常规则，都是从如下4个 抽象基类派生的。

　　2、由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。

　　

　　IO流继承体系

　　

二、字节流

2.1、Inpustream

　　InputStream有read方法，一次读取一个字节，OutputStream的write方法一次写一个int。这两个类都是抽象类。意味着不能创建对象，那么需要找到具体的子类来使用。操作流的步骤都是：

　　第一步：1：实例化File类对象

　　第二步：2：打开流（即创建流）

　　第三步：3：通过流读取内容

　　第四步：4：用完后，关闭流资源

　　案例一：使用 read()方法，一次读取一个字节,读到文件末尾返回-1.

public void testFileInputStream() {
    // 1、实例化File类对象
    File file = new File("hello.txt");
    // 2、提供具体流
    FileInputStream fis = null;
    try {
        fis = new FileInputStream(file);
        // 3、数据读取
        // read():返回读入的一个字符。如果达到文件末尾了，返回-1
        int data;
        while ( (data=fis.read()) != -1) {
            System.out.print((char) data);
        }

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

    } finally {
        // 4、关闭流
        if (fis != null) {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

　　案例二（推荐使用）：使用read()方法的时候，可以将读到的数据装入到字节数组中，相当于缓冲(提高效率)，并循环读取(读完所有内容).

public void testFileInputStream() {
    // 1、造文件
    File file = new File("hello.txt");

    // 2、造输入流
    FileInputStream fileInputStream = null;
    try {
        fileInputStream = new FileInputStream(file);

        // 3、读数据
        byte[] buffer = new byte[5];
        int len;
        while ((len = fileInputStream.read(buffer)) != -1) {
            System.out.print(new String(buffer, 0, len));
        }

    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        // 4、关闭流资源
        if (fileInputStream != null) {
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

　　

2.2、OutputStream

　　OutputStram 的write方法，一次只能写一个字节。成功的向文件中写入了内容。但是并不高效，如何提高效率呢？可以使用缓冲，在OutputStram类中有write(byte[] b)方法，将 b.length个字节从指定的 byte 数组写入此输出流中。

　　操作步骤与读取类似

public void testFileOutputStream() {
    // 1、提供File类对象，并指明写出的文件
    File file = new File("hello2.txt");

    // 2、提供FileOutputStream的对象，用于数据的写出
    FileOutputStream fos = null;
    try {
        // 第二个参数，是否在原文件上追加内容，默认为false
        fos = new FileOutputStream(file, true);

        // 3、写出的操作
        fos.write("I have a Dream".getBytes());

    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        // 4、流资源的关闭
        if (fos != null) {
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

　

2.3、输入输出流综合使用——文件拷贝实现　

　　可以根据拷贝的需求调整数组的大小，一般是1024的整数倍。使用缓冲后效率大大提高。目前我们是抛出处理，一旦出现了异常，close就没有执行，也就没有释放资源。那么为了保证close的执行该如何处理呢。那么就需要使用try{} catch(){}finally{}语句。try中放入可能出现异常的语句，catch是捕获异常对象，fianlly是一定要执行的代码。

public void testFileInputOutputStream() {
    // 1、创建File类的对象，指明读入和写出的文件
    File srcFile = new File("tomcat.png");
    File destFile = new File("tomcat2.png");


    // 2、创建输入流和输出流的对象
    FileInputStream fileInputStream = null;
    FileOutputStream fileOutputStream = null;
    try {
        fileInputStream = new FileInputStream(srcFile);
        fileOutputStream = new FileOutputStream(destFile);

        // 3、数据的读入和写出操作
        byte[] cbuf = new byte[1024];
        int len;
        while ((len = fileInputStream.read(cbuf)) != -1) {
            fileOutputStream.write(cbuf, 0, len);
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {

        // 4、关闭流资源
        if (fileOutputStream != null) {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (fileInputStream != null) {
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

三、字符流

　　计算机并不区分二进制文件与文本文件。所有的文件都是以二进制形式来存储的，因此，从本质上说，所有的文件都是二进制文件。所以字符流是建立在字节流之上的，它能够提供字符层次的编码和解码。可以说字符流就是：字节流 + 编码表，为了更便于操作文字数据。字符流的抽象基类：Reader ， Writer。由这些类派生出来的子类名称都是以其父类名作为子类名的后缀，如FileReader、FileWriter。

文件拷贝实现示例

public void testFileReaderFileWriter() {
    // 1、创建File类的对象，指明读入和写出的文件
    File srcFile = new File("hello.txt");
    File destFile = new File("hello2.txt");

    // 2、创建输入流和输出流的对象
    FileReader fileReader = null;
    FileWriter fileWriter = null;
    try {
        fileReader = new FileReader(srcFile);
        fileWriter = new FileWriter(destFile);

        // 3、数据的读入和写出操作
        char[] cbuf = new char[5];
        int len;
        while ((len = fileReader.read(cbuf)) != -1) {
            fileWriter.write(cbuf, 0, len);
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {

        // 4、关闭流资源
        if(fileWriter != null ){
            try {
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (fileReader != null) {
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

* 结论：
* 1、对于文本文件（.txt,.java,.c,.cpp），使用字符流处理
* 2、对于非文本文件(.jpg,.mp3,.mp4,.avi,.doc,.ppt)，使用字节流文件

四、缓冲流

　　Java其实提供了专门的字节流缓冲来提高效率。BufferedInputStream 和 BufferedOutputStream。BufferedOutputStream和BufferedOutputStream类可以通过减少读写次数来提高输入和输出的速度。它们内部有一个缓冲区，用来提高处理效率。查看API文档，发现可以指定缓冲区的大小。其实内部也是封装了字节数组。没有指定缓冲区大小，默认的字节是8192。显然缓冲区输入流和缓冲区输出流要配合使用。首先缓冲区输入流会将读取到的数据读入缓冲区，当缓冲区满时，或者调用flush方法，缓冲输出流会将数据写出。
注意：当然使用缓冲流来进行提高效率时，对于小文件可能看不到性能的提升。但是文件稍微大一些的话，就可以看到实质的性能提升了。

　　文件拷贝实现示例

public void bufferedStreamTest(){
    // 1、造文件
    File srcFile = new File("hello.txt");
    File destFile = new File("hello2.txt");

    // 2、造流
    // 2.1、造节点流
    FileInputStream fis = null;
    FileOutputStream fos = null;
    BufferedInputStream bis = null;
    BufferedOutputStream bos = null;
    try {
        fis = new FileInputStream(srcFile);
        fos = new FileOutputStream(destFile);

        // 2.2、造缓冲流
        bis = new BufferedInputStream(fis);
        bos = new BufferedOutputStream(fos);

        // 3、复制的细节：读取、写入
        byte[] buffer = new byte[1024];
        int len;
        while ((len = bis.read(buffer)) != -1) {
            bos.write(buffer, 0, len);

            // 刷新缓冲区，手动将buffer中的数据写入文件
//                bos.flush();
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {

        // 4、资源关闭
        // 要求：先关闭外层的流，在关闭内层的流
        if(bos != null) {
            try {
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(bis != null) {
            try {
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        // 说明：在关闭外层流的同时，内层流也会自动的进行关闭
        // 关闭内层流的操作，可以忽略
//        fos.close();
//        fis.close();
    }
}

五、转换流

1、转换流提供了在字节流和字符流之间的转换

　　2、Java API提供了两个转换流:

　　　　1）InputStreamReader:将InputStream转换为Reader  

　　　　2）OutputStreamWriter:将Writer转换为OutputStream

　　3、字节流中的数据都是字符时，转成字符流操作更高效。

　　4、很多时候我们使用转换流来处理文件乱码问题。实现编码和 解码的功能。

　　示例代码如下：

public void test2() {
    InputStreamReader isr = null;
    OutputStreamWriter osw = null;

    try {
        FileInputStream fis = new FileInputStream("hello.txt");
        FileOutputStream fos = new FileOutputStream("hello2.txt");

        isr = new InputStreamReader(fis, "utf-8");
        osw = new OutputStreamWriter(fos, "gbk");

        char[] cbuf = new char[5];
        int len;
        while ((len = isr.read(cbuf)) != -1) {
            String str = new String(cbuf, 0, len);
            System.out.print(str);
            osw.write(str);
        }

    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(osw != null){
            try {
                osw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (isr != null) {
            try {
                isr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}

六、其他流介绍

6.1、标准输入、输出流(了解)

•   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)

6.2、打印流(了解)

　　　实现将基本数据类型的数据格式转化为字符串输出

　　打印流:PrintStream和PrintWriter

•   提供了一系列重载的print()和println()方法，用于多种数据类型的输出

•   PrintStream和PrintWriter的输出不会抛出IOException异常

•   PrintStream和PrintWriter有自动flush功能

•   PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。

  　　在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。

•   System.out返回的是PrintStream的实例

6.3、数据流(了解)

　　1、为了方便地操作Java语言的基本数据类型和String的数据，可以使用数据流

　　2、数据流有两个类:(用于读取和写出基本数据类型、String类的数据) 

　　　　DataInputStream 和 DataOutputStream

　　　　分别“套接”在 InputStream 和 OutputStream 子类的流上

　　3、DataInputStream中的方法

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

　　4、DataOutputStream中的方法
　　　　将上述的方法的read改为相应的write即可。

/**
 * 数据流 DataInputStream 和 DataOutputStream
 * 作用：用于读取和写出基本数据类型的变量或字符串
 *
 */
public void testDataOutputStream(){
    DataOutputStream dos = null;
    try {
        dos = new DataOutputStream(new FileOutputStream("d.txt"));

        dos.writeUTF("中国人");
        dos.flush(); // 刷新操作，一定执行就会将数据写入文件
        dos.writeInt(12);
        dos.writeDouble(1.1);
        dos.writeBoolean(true);
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(dos != null) {
            try {
                dos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

public void testDataInputStream(){
    DataInputStream dis = null;
    try {
        dis = new DataInputStream(new FileInputStream("d.txt"));

        String str = dis.readUTF();
        System.out.println(str);
        int num = dis.readInt();
        System.out.println(num);
        double dou = dis.readDouble();
        System.out.println(dou);
        boolean b = dis.readBoolean();
        System.out.println(b);
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(dis != null) {
            try {
                dis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

6.4、对象流

　　ObjectInputStream和OjbectOutputSteam

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

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

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

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

　　使用参考：【Java】Java对象的序列化和反序列化

6.5、随机存取文件流

RandomAccessFile 类

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

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

　　　　> 支持只访问文件的部分内容

　　　　> 可以向已存在的文件后追加内容

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

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

　　　　> long getFilePointer():获取文件记录指针的当前位置

　　　　> void seek(long pos):将文件记录指针定位到 pos 位置

　　代码示例　

/**
 * RandomAccessFile的使用
 * 1、RandomAccessFile直接继承与Java.lang.Object类，实现类DataInput和Output两个接口
 * 2、RandomAccessFile既可以作为一个输入流，又可以作为一个输出流
 * 3、如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建
 * 如果写出到的文件存在，则会对原有文件内容进行覆盖。（默认情况下，从头开始）
 */
public class RandomAccessFileTest {

    public static void main(String[] args) {
        RandomAccessFileTest test = new RandomAccessFileTest();
        test.test3();
    }


    public void test1() {
        RandomAccessFile raf1 = null;
        RandomAccessFile raf2 = null;
        try {
            raf1 = new RandomAccessFile("hello.txt", "r");
            raf2 = new RandomAccessFile("hello2.txt", "rw");

            byte[] buff = new byte[5];
            int len;
            while ((len = raf1.read(buff)) != -1) {
                raf2.write(buff, 0, len);
                System.out.print(new String(buff, 0, len));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (raf2 != null) {
                try {
                    raf2.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (raf1 != null) {
                try {
                    raf1.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }


    public void test2() {
        RandomAccessFile raf2 = null;
        try {
            raf2 = new RandomAccessFile("hello2.txt", "rw");
            // 将指针调到角标为3的位置
            raf2.seek(3);
            raf2.write("xyz".getBytes());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (raf2 != null) {
                try {
                    raf2.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    /**
     * 使用RandomAccessFile实现插入效果
     */
    public void test3() {
        RandomAccessFile raf2 = null;
        ByteArrayOutputStream bos =null;
        try {
            raf2 = new RandomAccessFile("hello2.txt", "rw");
            // 将指针调到角标为3的位置
            raf2.seek(3);

//            // 方式一，使用StringBuilder
//            StringBuilder sb =new StringBuilder("NBA");
//            byte[] buff = new byte[5];
//            int len;
//            while ((len = raf2.read(buff)) != -1) {
//                sb.append(new String(buff, 0, len));
//            }

            // 方式二，使用ByteArrayOutputStream
            bos = new ByteArrayOutputStream();
            bos.write("CBA".getBytes());
            byte[] buff = new byte[5];
            int len;
            while ((len = raf2.read(buff)) != -1) {
                bos.write(buff, 0, len);
            }

            // 指针指回插入位置
            raf2.seek(3);
            raf2.write(bos.toByteArray());

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (raf2 != null) {
                try {
                    raf2.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}