Java IO

1. Java IO基本认识

java io分别为java in和java out，指应用程序和外部设备之间的数据交换。Java是通过流(Stream)来处理的，也就是一连串的数据以先进先出的发送信息的通道。

当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样。

流的特性有下面几点：

• 先进先出：先写入输出流的数据最先被输入流读取到；
• 顺序存取：可以一个接一个地往流中写入一串字节，读出时也将按写入顺序读取一串字节，不能随机访问中间的数据。（RandomAccessFile除外）；
• 只读或只写：每个流只能是输入流或输出流的一种，不能同时具备两个功能，输入流只能进行读操作，对输出流只能进行写操作。在一个数据传输通道中，如果既要写入数据，又要读取数据，则要分别提供两个流。

2. 传输方式划分

按照传输方式划分有两种：

2.1 字节型

字节流用来处理二进制文件，例如图片啊、MP3 啊、视频等。

2.2 字符型

字符流主要用来处理文本文件。

IO类核心四个抽象类主要有以下4个：

InputStream 类

• int read(); //用来读取数据
• int read(byte b[], int off, int len)；//从第 off 位置开始读，读取 len 长度的字节，然后放入数组 b 中
• long skip(long n)：跳过指定个数的字节;
• int available()：返回可读的字节数;
• void close()：关闭流，释放资源。

OutputStream类

• id write(int b)： 写入一个字节，虽然参数是一个 int 类型，但只有低 8 位才会写入，高 24 位会舍弃;
• void write(byte b[], int off, int len)： 将数组 b 中的从 off 位置开始，长度为 len 的字节写入;
• void flush()： 强制刷新，将缓冲区的数据写入;
• void close()：关闭流。

Reader 类

• int read()：读取单个字符；
• int read(char cbuf[], int off, int len)：从第 off 位置开始读，读取 len 长度的字符，然后放入数组 b 中；
• long skip(long n)：跳过指定个数的字符；
• int ready()：是否可以读了；
• void close()：关闭流，释放资源。

Writer 类

• void write(int c)： 写入一个字符；
• void write( char cbuf[], int off, int len)： 将数组 cbuf 中的从 off 位置开始，长度为 len 的字符写入；
• void flush()： 强制刷新，将缓冲区的数据写入；
• void close()：关闭流。

private char[] writeBuffer;

/**
 * Size of writeBuffer, must be >= 1
 */
private static final int WRITE_BUFFER_SIZE = 1024;

public void write(String str, int off, int len) throws IOException {
    synchronized (lock) {
        char cbuf[];
        if (len <= WRITE_BUFFER_SIZE) {
            if (writeBuffer == null) {
                writeBuffer = new char[WRITE_BUFFER_SIZE];
            }
            cbuf = writeBuffer;
        } else {    // Don't permanently allocate very large buffers.
            cbuf = new char[len];
        }
        str.getChars(off, (off + len), cbuf, 0);
        write(cbuf, 0, len);
    }
}

3. 操作对象划分

3.1 文件

文件流也就是直接操作文件的流，可以细分为字节流（FileInputStream 和 FileOuputStream）和字符流（FileReader 和 FileWriter）。

FileInputStream 的例子：

int b;
FileInputStream fis1 = new FileInputStream("fis.txt");
// 循环读取
while ((b = fis1.read())!=-1) {
    System.out.println((char)b);
}
// 关闭资源
fis1.close();

FileOutputStream 的例子：

FileOutputStream fos = new FileOutputStream("fos.txt");
fos.write("mitu".getBytes());
fos.close();

FileReader 的例子:

int b = 0;
FileReader fileReader = new FileReader("read.txt");
// 循环读取
while ((b = fileReader.read())!=-1) {
    // 自动提升类型提升为 int 类型，所以用 char 强转
    System.out.println((char)b);
}
// 关闭流
fileReader.close();

FileWriter 的例子：

FileWriter fileWriter = new FileWriter("fw.txt");
char[] chars = "mitu".toCharArray();
fileWriter.write(chars, 0, chars.length);
fileWriter.close();

针对文件的读写操作，使用文件流配合缓冲流就够用了，但为了提升效率，频繁地读写文件并不是太好，那么就出现了数组流，有时候也称为内存流。

ByteArrayInputStream 的例子：

InputStream is =new BufferedInputStream(
        new ByteArrayInputStream(
                "mitu".getBytes(StandardCharsets.UTF_8)));
//操作
byte[] flush =new byte[1024];
int len =0;
while(-1!=(len=is.read(flush))){
    System.out.println(new String(flush,0,len));
}
//释放资源
is.close();

ByteArrayOutputStream 的例子：

ByteArrayOutputStream bos =new ByteArrayOutputStream();
byte[] info ="mitu".getBytes();
bos.write(info, 0, info.length);
//获取数据
byte[] dest =bos.toByteArray();
//释放资源
bos.close();

3.2 缓冲

由于CPU 很快，它比内存和硬盘运行快得多。那也就意味着，程序和内存交互会很快，和硬盘交互相对就很慢，这样就会导致性能问题。

为了减少程序和硬盘的交互，提升程序的效率，就引入了缓冲流，也就是类名前缀带有 Buffer 的那些，比如说 BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter。

缓冲流在内存中设置了一个缓冲区，只有缓冲区存储了足够多的带操作的数据后，才会和内存或者硬盘进行交互。简单来说，就是一次多读/写点，少读/写几次，这样程序的性能就会提高。

3.73对象序列化/反序列化

序列化本质上是将一个 Java 对象转成字节数组，然后可以将其保存到文件中，或者通过网络传输到远程。

ByteArrayOutputStream buffer = new ByteArrayOutputStream();
try (ObjectOutputStream output = new ObjectOutputStream(buffer)) {
    output.writeUTF("mitu");
}
System.out.println(Arrays.toString(buffer.toByteArray()));

与其对应的，有序列化，就有反序列化，也就是再将字节数组转成 Java 对象的过程。

try (ObjectInputStream input = new ObjectInputStream(new FileInputStream(
        new File("demo.txt")))) {
    String s = input.readUTF();
}

3.84转换

InputStreamReader 是从字节流到字符流的桥连接，它使用指定的字符集读取字节并将它们解码为字符。

InputStreamReader isr = new InputStreamReader(
        new FileInputStream("demo.txt"));
char []cha = new char[1024];
int len = isr.read(cha);
System.out.println(new String(cha,0,len));
isr.close();

OutputStreamWriter 将一个字符流的输出对象变为字节流的输出对象，是字符流通向字节流的桥梁。

File f = new File("test.txt") ;
Writer out = new OutputStreamWriter(new FileOutputStream(f)) ; // 字节流变为字符流  
out.write("hello world!!") ;    // 使用字符流输出  
out.close() ;