Java中的IO流

初识 IO 流

IO：即 in 和 out，也就是输入和输出，指应用程序和外部设备之间的数据传递

流（Stream）：是一个抽象的概念，是指一连串的数据（字符或字节），是以先进先出的方式发送信息的通道

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

IO 流的分类

按数据流的方向

• 输入流
• 输出流

按处理数据单位

• 字节流
• 字符流

流动方向与操作相结合

• 字节输入流： InputStream 类
• 字节输出流： OutputStream 类
• 字符输入流：Reader 类
• 字符输出流：Writer 类

输入流与输出流

输入与输出是相对于应用程序而言的，比如文件读写，读取文件是输入流，写文件是输出流，这点很容易搞反

字节流与字符流

字节流和字符流的用法几乎完成全一样

字节流

• 字节流操作的单元是数据单元是 8 位的字节
• 字节流一般用来处理图像、视频、音频、PPT、Word 等一切文件
• 字节流本身没有缓冲区，缓冲字节流相对于字节流，效率提升非常高

字符流

• 字符流操作的是数据单元为 16 位的字符
• 字符流一般只能用于处理纯文本类型的文件，如 TXT 文件等
• 字符流本身就带有缓冲区，缓冲字符流相对于字符流效率提升就不是那么大了

IO 流分类图如下

IO 流对象

File 类

File 类是用来操作文件夹的类，但它不能操作文件中的数据

public class File implements Serializable, Comparable<File> { 

	private File(String pathname, int prefixLength) {
        this.path = pathname;
        this.prefixLength = prefixLength;
    }

	private File(String child, File parent) {
        assert parent.path != null;
        assert (!parent.path.equals(""));
        this.path = fs.resolve(parent.path, child);
        this.prefixLength = parent.prefixLength;
    }
    
    // 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
	public File(String pathname) {
        if (pathname == null) {
            throw new NullPointerException();
        }
        this.path = fs.normalize(pathname);
        this.prefixLength = fs.prefixLength(this.path);
    }

	// 从父路径名字符串和子路径名字符串创建新的 File实例
	public File(String parent, String child) {
        if (child == null) {
            throw new NullPointerException();
        }
        if (parent != null) {
            if (parent.equals("")) {
                this.path = fs.resolve(fs.getDefaultParent(),
                                       fs.normalize(child));
            } else {
                this.path = fs.resolve(fs.normalize(parent),
                                       fs.normalize(child));
            }
        } else {
            this.path = fs.normalize(child);
        }
        this.prefixLength = fs.prefixLength(this.path);
    }

    // 从父抽象路径名和子路径名字符串创建新的 File实例
	public File(File parent, String child) {
        if (child == null) {
            throw new NullPointerException();
        }
        if (parent != null) {
            if (parent.path.equals("")) {
                this.path = fs.resolve(fs.getDefaultParent(),
                                       fs.normalize(child));
            } else {
                this.path = fs.resolve(parent.path,
                                       fs.normalize(child));
            }
        } else {
            this.path = fs.normalize(child);
        }
        this.prefixLength = fs.prefixLength(this.path);
    }
	
	// 通过将给定的 file: URI转换为抽象路径名来创建新的 File实例
	public File(URI uri) {
        // Check our many preconditions
        if (!uri.isAbsolute())
            throw new IllegalArgumentException("URI is not absolute");
        if (uri.isOpaque())
            throw new IllegalArgumentException("URI is not hierarchical");
        String scheme = uri.getScheme();
        if ((scheme == null) || !scheme.equalsIgnoreCase("file"))
            throw new IllegalArgumentException("URI scheme is not \"file\"");
        if (uri.getAuthority() != null)
            throw new IllegalArgumentException("URI has an authority component");
        if (uri.getFragment() != null)
            throw new IllegalArgumentException("URI has a fragment component");
        if (uri.getQuery() != null)
            throw new IllegalArgumentException("URI has a query component");
        String p = uri.getPath();
        if (p.equals(""))
            throw new IllegalArgumentException("URI path component is empty");

        // Okay, now initialize
        p = fs.fromURIPath(p);
        if (File.separatorChar != '/')
            p = p.replace('/', File.separatorChar);
        this.path = fs.normalize(p);
        this.prefixLength = fs.prefixLength(this.path);
    }
}

字节流

InputStream

InputStream 与 OutputStream 是两个抽象类，是字节流的父类，所有具体的字节流实现类都是分别继承了这两个类

InputStream 类有很多的实现子类，下面列举了一些比较常用的

• InputStream：InputStream 是所有字节输入流的抽象基类，前面说过抽象类不能被实例化，实际上是作为模板而存在的，为所有实现类定义了处理输入流的方法
• FileInputSream：文件输入流，一个非常重要的字节输入流，用于对文件进行读取操作
• FilterInputStream：装饰者类，具体的装饰者继承该类，这些类都是处理类，作用是对节点类进行封装，实现一些特殊功能
• DataInputStream：数据输入流，它是用来装饰其它输入流，作用是“允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型”
• BufferedInputStream：缓冲流，对节点流进行装饰，内部会有一个缓存区，用来存放字节，每次都是将缓存区存满然后发送，而不是一个字节或两个字节这样发送，效率更高
• ObjectInputStream：对象输入流，用来提供对基本数据或对象的持久存储。通俗点说，也就是能直接传输对象，通常应用在反序列化中。它也是一种处理流，构造器的入参是一个 InputStream 的实例对象

OutputStream

OutputStream 类继承关系图

OutputStream 类继承关系与 InputStream 类似，需要注意的是 PrintStream

字符流

与字节流类似，字符流也有两个抽象基类，分别是 Reader 和 Writer。其他的字符流实现类都是继承了这两个类

以 Reader 为例，它的主要实现子类如下图

• InputStreamReader：从字节流到字符流的桥梁（InputStreamReader 构造器入参是 FileInputStream 的实例对象），它读取字节并使用指定的字符集将其解码为字符。它使用的字符集可以通过名称指定，也可以显式给定，或者可以接受平台的默认字符集
• BufferedReader：从字符输入流中读取文本，设置一个缓冲区来提高效率。BufferedReader 是对 InputStreamReader 的封装，前者构造器的入参就是后者的一个实例对象
• FileReader：用于读取字符文件的便利类，new FileReader(File file) 等同于 new InputStreamReader(new FileInputStream(file, true),"UTF-8")，但 FileReader 不能指定字符编码和默认字节缓冲区大小
• StringReader ：从 String 中读取数据的介质流

Writer 与 Reader 结构类似，方向相反，不再赘述。唯一有区别的是，Writer 的子类PrintWriter

IO 流方法

字节输入流 InputStream 主要方法

• read()：从此输入流中读取一个数据字节
• read(byte[] b)：从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中
• read(byte[] b, int off, int len)：从此输入流中将最多 len 个字节的数据读入一个 byte 数组中
• close()：关闭此输入流并释放与该流关联的所有系统资源

字节输出流 OutputStream 主要方法

• write(byte[] b)：将 b.length 个字节从指定 byte 数组写入此文件输出流中
• write(byte[] b, int off, int len)：将指定 byte 数组中从偏移量 off 开始的 len
  个字节写入此文件输出流
• write(int b)：将指定字节写入此文件输出流
• close()：关闭此输入流并释放与该流关联的所有系统资源

字符输入流 Reader 主要方法

• read()：读取单个字符
• read(char[] cbuf)：将字符读入数组
• read(char[] cbuf, int off, int len)：将字符读入数组的某一部分
• read(CharBuffer target)：试图将字符读入指定的字符缓冲区
• flush()：刷新该流的缓冲
• close()：关闭此流，但要先刷新它

字符输出流 Writer 主要方法

• write(char[] cbuf)：写入字符数组
• write(char[] cbuf, int off, int len)：写入字符数组的某一部分
• write(int c)：写入单个字符
• write(String str)：写入字符串
• write(String str, int off, int len)：写入字符串的某一部分
• flush()：刷新该流的缓冲
• close()：关闭此流，但要先刷新它