Java基础之文件IO

概述

Java 的 I/O 操作类在包 java.io 下，大概有将近 80 个类，但是这些类大概可以分成四组，分别是：

按处理数据类型来分：字节流和字符流：

• 基于字节操作的 I/O 接口：InputStream 和 OutputStream
• 基于字符操作的 I/O 接口：Writer 和 Reader

按传输数据的方式：磁盘操作和网络操作

• 基于磁盘操作的 I/O 接口：File
• 基于网络操作的 I/O 接口：Socket

按流的方向来分：输入流和输入流

• 要读的话就用输入流，要写的话，就用输出流

前两组主要是根据传输数据的数据格式，后两组主要是根据传输数据的方式，虽然 Socket 类并不在 java.io 包下，但是我仍然把它们划分在一起，因为我个人认为 I/O 的核心问题要么是数据格式影响 I/O 操作，要么是传输方式影响 I/O 操作，也就是将什么样的数据写到什么地方的问题，I/O 只是人与机器或者机器与机器交互的手段，除了在它们能够完成这个交互功能外，我们关注的就是如何提高它的运行效率了，而数据格式和传输方式是影响效率最关键的因素了。

3.什么时候使用字节流？什么时候使用字符流？

首先需要知道的是，任何数据存在硬盘上时，都是以二进制的形式存储的。而通过使用字节流，可以读取任意文件。字节流一次读取一个字节，而字符流使用了字节流读到一个或者多个字节时，去查找指定的编码表，返回对应的编码。所以字符流只能处理纯文本字符数据，而字节流可以处理更多类型的数据，比如图片，视频，音频文件等。因此，只要是纯文本数据处理，优先考虑使用字符流。其他情况就使用字节流。

基于字节的 I/O 操作接口

概述

基于字节的 I/O 操作接口输入和输出分别是：InputStream 和 OutputStream，InputStream 输入流的类继承层次如下图所示：

图 1. InputStream 相关类层次结构（查看大图）

输入流根据数据类型和操作方式又被划分成若干个子类，每个子类分别处理不同操作类型，OutputStream 输出流的类层次结构也是类似，如下图所示：

图 2. OutputStream 相关类层次结构（查看大图）

示例1：使用字节流，读取和存储图片

首先使用输入流读取图片信息，然后通过输出流写入图片信息：

package org.example.io;  

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

public class TestIOStream {  

    /** 
     *  
     * DOC 将F盘下的test.jpg文件，读取后，再存到E盘下面. 
     *  
     * @param args 
     * @throws Exception 
     */  
    public static void main(String[] args) throws Exception {  
        FileInputStream in = new FileInputStream(new File("F:\\test.jpg"));// 指定要读取的图片  
        File file = new File("E:\\test.jpg");  
        if (!file.exists()) {// 如果文件不存在，则创建该文件  
            file.createNewFile();  
        }  
        FileOutputStream out = new FileOutputStream(new File("E:\\test.jpg"));// 指定要写入的图片  
        int n = 0;// 每次读取的字节长度  
        byte[] bb = new byte[1024];// 存储每次读取的内容  
        while ((n = in.read(bb)) != -1) {  
            out.write(bb, 0, n);// 将读取的内容，写入到输出流当中  
        }  
        out.close();// 关闭输入输出流  
        in.close();  
    }  

}  

示例2: 使用BufferedInputStream和BufferedOuputStream读写图片

使用方式和FileInputStrem和FileOutputStream基本一致：

package org.example.io;  

import java.io.BufferedInputStream;  
import java.io.BufferedOutputStream;  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  

public class TestBufferedString {  

    public static void main(String[] args) throws Exception {  
        // 指定要读取文件的缓冲输入字节流  
        BufferedInputStream in = new BufferedInputStream(new FileInputStream("F:\\test.jpg"));  
        File file = new File("E:\\test.jpg");  
        if (file != null) {  
            file.createNewFile();  
        }  
        // 指定要写入文件的缓冲输出字节流  
        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(file));  
        byte[] bb = new byte[1024];// 用来存储每次读取到的字节数组  
        int n;// 每次读取到的字节数组的长度  
        while ((n = in.read(bb)) != -1) {  
            out.write(bb, 0, n);// 写入到输出流  
        }  
        out.close();// 关闭流  
        in.close();  
    }  

}  

基于字符的 I/O 操作接口

概述

不管是磁盘还是网络传输，最小的存储单元都是字节，而不是字符，所以 I/O 操作的都是字节而不是字符，但是为啥有操作字符的 I/O 接口呢？这是因为我们的程序中通常操作的数据都是以字符形式，为了操作方便当然要提供一个直接写字符的 I/O 接口，如此而已。我们知道字符到字节必须要经过编码转换，而这个编码又非常耗时，而且还会经常出现乱码问题，所以 I/O 的编码问题经常是让人头疼的问题。关于 I/O 编码问题请参考另一篇文章 《深入分析Java中的中文编码问题。

读字符的操作接口中也是 int read(char cbuf[], int off, int len)，返回读到的 n 个字节数，不管是 Writer 还是 Reader 类它们都只定义了读取或写入的数据字符的方式，也就是怎么写或读，但是并没有规定数据要写到哪去，写到哪去就是我们后面要讨论的基于磁盘和网络的工作机制

图 3.Reader 类层次结构（查看大图）

下图是写字符的 I/O 操作接口涉及到的类，Writer 类提供了一个抽象方法 write(char cbuf[], int off, int len) 由子类去实现。

图 4. Writer 相关类层次结构（查看大图）

示例1：使用字符流，读取和存储纯文本文件

存储文件，也就是像一个文件里写内容，既然是写，那就需要使用输出流。而且我们写的是纯文本文件，所以这里使用字符流来操作，java api提供给我们FileWriter这么一个类，我们来试试：(读取文件同理使用FileReader类)

package org.example.io;  

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

public class TestFileWriter {  

    public static void main(String[] args) throws Exception {  
        writeToFile();  
        readFromFile();  
    }  

    /** 
     * DOC 从文件里读取数据. 
     *  
     * @throws FileNotFoundException 
     * @throws IOException 
     */  
    private static void readFromFile() throws FileNotFoundException, IOException {  
        File file = new File("E:\\helloworld.txt");// 指定要读取的文件  
        FileReader reader = new FileReader(file);// 获取该文件的输入流  
        char[] bb = new char[1024];// 用来保存每次读取到的字符  
        String str = "";// 用来将每次读取到的字符拼接，当然使用StringBuffer类更好  
        int n;// 每次读取到的字符长度  
        while ((n = reader.read(bb)) != -1) {  
            str += new String(bb, 0, n);  
        }  
        reader.close();// 关闭输入流，释放连接  
        System.out.println(str);  
    }  

    /** 
     * DOC 往文件里写入数据. 
     *  
     * @throws IOException 
     */  
    private static void writeToFile() throws IOException {  
        String writerContent = "hello world,你好世界";// 要写入的文本  
        File file = new File("E:\\helloworld.txt");// 要写入的文本文件  
        if (!file.exists()) {// 如果文件不存在，则创建该文件  
            file.createNewFile();  
        }  
        FileWriter writer = new FileWriter(file);// 获取该文件的输出流  
        writer.write(writerContent);// 写内容  
        writer.flush();// 清空缓冲区，立即将输出流里的内容写到文件里  
        writer.close();// 关闭输出流，施放资源  
    }  

}  

测试结果：

hello world,你好世界

示例2: 通过BufferedReader和BufferedWriter来读写文件

package org.example.io;  

import java.io.BufferedReader;  
import java.io.BufferedWriter;  
import java.io.File;  
import java.io.FileNotFoundException;  
import java.io.FileReader;  
import java.io.FileWriter;  
import java.io.IOException;  

public class TestBufferedWriter {  

    public static void main(String[] args) throws Exception {  
        write();  
        read();  
    }  

    /** 
     * DOC 读取信息. 
     *  
     * @throws FileNotFoundException 
     * @throws IOException 
     */  
    private static void read() throws FileNotFoundException, IOException {  
        File file = new File("E:\\a.txt");// 指定要读取的文件  
        // 获得该文件的缓冲输入流  
        BufferedReader bufferedReader = new BufferedReader(new FileReader(file));  
        String line = "";// 用来保存每次读取一行的内容  
        while ((line = bufferedReader.readLine()) != null) {  
            System.out.println(line);  
        }  
        bufferedReader.close();// 关闭输入流  
    }  

    /** 
     * DOC 写入信息. 
     *  
     * @throws IOException 
     */  
    private static void write() throws IOException {  
        File file = new File("E:\\a.txt");// 指定要写入的文件  
        if (!file.exists()) {// 如果文件不存在则创建  
            file.createNewFile();  
        }  
        // 获取该文件的缓冲输出流  
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file));  
        // 写入信息  
        bufferedWriter.write("你好世界");  
        bufferedWriter.newLine();// 表示换行  
        bufferedWriter.write("hello world");  
        bufferedWriter.flush();// 清空缓冲区  
        bufferedWriter.close();// 关闭输出流  
    }  

}  

字节与字符的转化接口

概述

另外数据持久化或网络传输都是以字节进行的，所以必须要有字符到字节或字节到字符的转化。字符到字节需要转化，其中读的转化过程如下图所示：

InputStreamReader 类是字节到字符的转化桥梁，InputStream 到 Reader 的过程要指定编码字符集，否则将采用操作系统默认字符集，很可能会出现乱码问题。StreamDecoder 正是完成字节到字符的解码的实现类。也就是当你用如下方式读取一个文件时：

 try { 
            StringBuffer str = new StringBuffer(); 
            char[] buf = new char[1024]; 
            FileReader f = new FileReader("file"); 
            while(f.read(buf)>0){ 
                str.append(buf); 
            } 
            str.toString(); 
 } catch (IOException e) {}

FileReader 类就是按照上面的工作方式读取文件的，FileReader 是继承了 InputStreamReader 类，实际上是读取文件流，然后通过 StreamDecoder 解码成 char，只不过这里的解码字符集是默认字符集。

写入也是类似的过程如下图所示：

通过 OutputStreamWriter 类完成，字符到字节的编码过程，由 StreamEncoder 完成编码过程。

示例：使用转换流InputStreamReader和OutputStreamWriter

当字节流和字符流之间需要转化的时候，或者要对字节数据进行编码转换的时候，就需要使用转换流

package org.example.io;  

import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.InputStreamReader;  
import java.io.OutputStreamWriter;  

public class TestStreamReader {  

    public static void main(String[] args) throws Exception {  
        File file = new File("E:\\b.txt");  
        if (!file.exists()) {  
            file.createNewFile();  
        }  
        OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream(file), "GBK");  
        out.write("hello world,你好世界");  
        out.close();  

        InputStreamReader in = new InputStreamReader(new FileInputStream(file), "gbk");  
        char[] cc = new char[1024];  
        int n = 0;  
        String str = "";  
        while ((n = in.read(cc)) != -1) {  
            str += new String(cc, 0, n);  
        }  
        in.close();  
        System.out.println(str);  
    }  

}  

参考

深入分析 Java I/O 的工作机制：
https://www.ibm.com/developerworks/cn/java/j-lo-javaio/

深入分析 Java 中的中文编码问题
http://www.ibm.com/developerworks/cn/java/j-lo-chinesecoding/

java IO流
http://blog.csdn.net/a107494639/article/details/7586365