Java IO流学习笔记

Posted 2021-08-13 bfengj

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java IO流学习笔记相关的知识，希望对你有一定的参考价值。

Java IO流学习笔记

前言

开始简单的学习一下Java的IO流，整理一下学习的东西，仅供翻阅和复习方便，学习自廖雪峰的Java教程，内容全部摘抄。

简介

IO是指Input/Output，即输入和输出。以内存为中心：

Input指从外部读入数据到内存，例如，把文件从磁盘读取到内存，从网络读取数据到内存等等。
Output指把数据从内存输出到外部，例如，把数据从内存写入到文件，把数据从内存输出到网络等等。

IO流以byte（字节）为最小单位，因此也称为字节流。

在Java中，InputStream代表输入字节流，OuputStream代表输出字节流，这是最基本的两种IO流。

如果我们需要读写的是字符，并且字符不全是单字节表示的ASCII字符，那么，按照char来读写显然更方便，这种流称为字符流。

Java提供了Reader和Writer表示字符流，字符流传输的最小数据单位是char。

Reader和Writer本质上是一个能自动编解码的InputStream和OutputStream。

使用Reader，数据源虽然是字节，但我们读入的数据都是char类型的字符，原因是Reader内部把读入的byte做了解码，转换成了char。使用InputStream，我们读入的数据和原始二进制数据一模一样，是byte[]数组，但是我们可以自己把二进制byte[]数组按照某种编码转换为字符串。究竟使用Reader还是InputStream，要取决于具体的使用场景。如果数据源不是文本，就只能使用InputStream，如果数据源是文本，使用Reader更方便一些。Writer和OutputStream是类似的。

File对象

在计算机系统中，文件是非常重要的存储方式。Java的标准库java.io提供了File对象来操作文件和目录。

要构造一个File对象，需要传入文件路径：

File f = new File("Java.iml");

File对象有3种形式表示的路径，一种是getPath()，返回构造方法传入的路径，一种是getAbsolutePath()，返回绝对路径，一种是getCanonicalPath，它和绝对路径类似，但是返回的是规范路径。

        System.out.println(f.getPath());
        System.out.println(f.getAbsolutePath());
        System.out.println(f.getCanonicalPath());

规范路径就是把.和..转换成标准的绝对路径后的路径。

文件和目录

File对象既可以表示文件，也可以表示目录。特别要注意的是，构造一个File对象，即使传入的文件或目录不存在，代码也不会出错，因为构造一个File对象，并不会导致任何磁盘操作。只有当我们调用File对象的某些方法的时候，才真正进行磁盘操作。

调用isFile()，判断该File对象是否是一个已存在的文件，调用isDirectory()，判断该File对象是否是一个已存在的目录：

        System.out.println(f.isFile());
        System.out.println(f.isDirectory());

用File对象获取到一个文件时，还可以进一步判断文件的权限和大小：

boolean canRead()：是否可读；
boolean canWrite()：是否可写；
boolean canExecute()：是否可执行；
long length()：文件字节大小。

对目录而言，是否可执行表示能否列出它包含的文件和子目录。

创建和删除文件

当File对象表示一个文件时，可以通过createNewFile()创建一个新文件，用delete()删除该文件：

        File file = new File("hello.txt");
        if(file.createNewFile()){
            System.out.println("文件创建成功");
            if(file.delete()){
                System.out.println("文件删除成功");
            }
        }

File对象提供了createTempFile()来创建一个临时文件，以及deleteOnExit()在JVM退出时自动删除该文件。

        File file1 = File.createTempFile("tmp-",".txt");
        file1.deleteOnExit();
        System.out.println(file1.getAbsolutePath());

遍历文件和目录

当File对象表示一个目录时，可以使用list()和listFiles()列出目录下的文件和子目录名。listFiles()提供了一系列重载方法，可以过滤不想要的文件和目录：

        File file2 = new File(".");
        String[] array1 = file2.list();
        File[] array2 = file2.listFiles();

        File[] fs2 = f.listFiles(new FilenameFilter() { // 仅列出.exe文件
            public boolean accept(File dir, String name) {
                return name.endsWith(".exe"); // 返回true表示接受该文件
            }
        });

和文件操作类似，File对象如果表示一个目录，可以通过以下方法创建和删除目录：

boolean mkdir()：创建当前File对象表示的目录；
boolean mkdirs()：创建当前File对象表示的目录，并在必要时将不存在的父目录也创建出来；
boolean delete()：删除当前File对象表示的目录，当前目录必须为空才能删除成功。

Path

Java标准库还提供了一个Path对象，它位于java.nio.file包。Path对象和File对象类似，但操作更加简单：

    public static void test3() {
        Path p1 = Paths.get("Java.iml");
        System.out.println(p1);
        Path p2 = p1.toAbsolutePath();
        System.out.println(p2);
        Path p3 = p2.normalize(); // 转换为规范路径
        System.out.println(p3);
        File f = p3.toFile(); // 转换为File对象
        System.out.println(f);
        Path p4 = Paths.get(".");
        System.out.println("-------------------");
        System.out.println(p4.toAbsolutePath()); //D:\\this_is_feng\\Java\\.
        for (Path p: p4.toAbsolutePath()){
            System.out.println(p); 
            //this_is_feng
            //Java
            //.
        }
    }

InputStream

InputStream就是Java标准库提供的最基本的输入流。它位于java.io这个包里。java.io包提供了所有同步IO的功能。

要特别注意的一点是，InputStream并不是一个接口，而是一个抽象类，它是所有输入流的超类。这个抽象类定义的一个最重要的方法就是int read()，签名如下：

public abstract int read() throws IOException;

这个方法会读取输入流的下一个字节，并返回字节表示的int值（0~255）。如果已读到末尾，返回-1表示不能继续读取了。

FileInputStream是InputStream的一个子类。顾名思义，FileInputStream就是从文件流中读取数据。

    // 创建一个FileInputStream对象:
    InputStream input = new FileInputStream("Java.iml");
    for (;;) {
        int n = input.read(); // 反复调用read()方法，直到返回-1
        if (n == -1) {
            break;
        }
        System.out.println(n); // 打印byte的值
    }
    input.close(); // 关闭流

InputStream和OutputStream都是通过close()方法来关闭流。关闭流就会释放对应的底层资源。

所有与IO操作相关的代码都必须正确处理IOException。

如果读取过程中发生了IO错误，InputStream就没法正确地关闭，资源也就没法及时释放。

因此，我们需要用try ... finally来保证InputStream在无论是否发生IO错误的时候都能够正确地关闭。

更好的写法是利用Java 7引入的新的try(resource)的语法，只需要编写try语句，让编译器自动为我们关闭资源：

        try(InputStream input = new FileInputStream("Java.iml")){
            int n;
            while(( n = input.read()) != -1){
                System.out.print((char)n);
            }
        }

实际上，编译器并不会特别地为InputStream加上自动关闭。编译器只看try(resource = ...)中的对象是否实现了java.lang.AutoCloseable接口，如果实现了，就自动加上finally语句并调用close()方法。InputStream和OutputStream都实现了这个接口，因此，都可以用在try(resource)中。

缓冲

在读取流的时候，一次读取一个字节并不是最高效的方法。很多流支持一次性读取多个字节到缓冲区，对于文件和网络流来说，利用缓冲区一次性读取多个字节效率往往要高很多。InputStream提供了两个重载方法来支持读取多个字节：

int read(byte[] b)：读取若干字节并填充到byte[]数组，返回读取的字节数
int read(byte[] b, int off, int len)：指定byte[]数组的偏移量和最大填充数

利用上述方法一次读取多个字节时，需要先定义一个byte[]数组作为缓冲区，read()方法会尽可能多地读取字节到缓冲区，但不会超过缓冲区的大小。read()方法的返回值不再是字节的int值，而是返回实际读取了多少个字节。如果返回-1，表示没有更多的数据了。

ByteArrayInputStream

用FileInputStream可以从文件获取输入流，这是InputStream常用的一个实现类。此外，ByteArrayInputStream可以在内存中模拟一个InputStream：

        byte[] data = { 72, 101, 108, 108, 111, 33 };
        try (InputStream input = new ByteArrayInputStream(data)) {
            int n;
            while ((n = input.read()) != -1) {
                System.out.println((char)n);
            }
        }

OutputStream

和InputStream类似，OutputStream也是抽象类，它是所有输出流的超类。这个抽象类定义的一个最重要的方法就是void write(int b)，签名如下：

public abstract void write(int b) throws IOException;

这个方法会写入一个字节到输出流。要注意的是，虽然传入的是int参数，但只会写入一个字节，即只写入int最低8位表示字节的部分（相当于b & 0xff）。

和InputStream类似，OutputStream也提供了close()方法关闭输出流，以便释放系统资源。要特别注意：OutputStream还提供了一个flush()方法，它的目的是将缓冲区的内容真正输出到目的地。

为什么要有flush()？因为向磁盘、网络写入数据的时候，出于效率的考虑，操作系统并不是输出一个字节就立刻写入到文件或者发送到网络，而是把输出的字节先放到内存的一个缓冲区里（本质上就是一个byte[]数组），等到缓冲区写满了，再一次性写入文件或者网络。对于很多IO设备来说，一次写一个字节和一次写1000个字节，花费的时间几乎是完全一样的，所以OutputStream有个flush()方法，能强制把缓冲区内容输出。

通常情况下，我们不需要调用这个flush()方法，因为缓冲区写满了OutputStream会自动调用它，并且，在调用close()方法关闭OutputStream之前，也会自动调用flush()方法。

但是，在某些情况下，我们必须手动调用flush()方法。

实际上，InputStream也有缓冲区。例如，从FileInputStream读取一个字节时，操作系统往往会一次性读取若干字节到缓冲区，并维护一个指针指向未读的缓冲区。然后，每次我们调用int read()读取下一个字节时，可以直接返回缓冲区的下一个字节，避免每次读一个字节都导致IO操作。当缓冲区全部读完后继续调用read()，则会触发操作系统的下一次读取并再次填满缓冲区。

FileOutputStream

        try(OutputStream output = new FileOutputStream("out.txt")){
            output.write((int)'h');
            output.write((int)'e');
            output.write((int)'l');
            output.write((int)'l');
            output.write((int)'o');
        }

同样的，write方法也有重载：

        try(OutputStream output = new FileOutputStream("out.txt")){
            output.write("feng".getBytes(StandardCharsets.UTF_8));
        }

ByteArrayOutputStream

用FileOutputStream可以从文件获取输出流，这是OutputStream常用的一个实现类。此外，ByteArrayOutputStream可以在内存中模拟一个OutputStream：

        byte[] data;
        try (ByteArrayOutputStream output = new ByteArrayOutputStream()) {
            output.write("Hello ".getBytes("UTF-8"));
            output.write("world!".getBytes("UTF-8"));
            data = output.toByteArray();
        }
        System.out.println(new String(data, "UTF-8"));

复制文件

同时操作多个AutoCloseable资源时，在try(resource) { ... }语句中可以同时写出多个资源，用;隔开。

一个复制文件的代码：

    public static void test7() throws IOException{
        try(InputStream input = new FileInputStream("Java.iml");
            OutputStream out = new FileOutputStream("out.txt")){
            int n ;
            StringBuilder sb = new StringBuilder();
            while(( n = input.read())!= -1){
                out.write(n);
            }
        }
    }

Filter模式

为了解决依赖继承会导致子类数量失控的问题，JDK首先将InputStream分为两大类：

一类是直接提供数据的基础InputStream，例如：

FileInputStream
ByteArrayInputStream
ServletInputStream
…

一类是提供额外附加功能的InputStream，例如：

BufferedInputStream
DigestInputStream
CipherInputStream
…

当我们需要给一个“基础”InputStream附加各种功能时，我们先确定这个能提供数据源的InputStream，因为我们需要的数据总得来自某个地方，例如，FileInputStream，数据来源自文件：

InputStream file = new FileInputStream("test.gz");

紧接着，我们希望FileInputStream能提供缓冲的功能来提高读取的效率，因此我们用BufferedInputStream包装这个InputStream，得到的包装类型是BufferedInputStream，但它仍然被视为一个InputStream：

InputStream buffered = new BufferedInputStream(file);

最后，假设该文件已经用gzip压缩了，我们希望直接读取解压缩的内容，就可以再包装一个GZIPInputStream：

InputStream gzip = new GZIPInputStream(buffered);

无论我们包装多少次，得到的对象始终是InputStream，我们直接用InputStream来引用它，就可以正常读取。

上述这种通过一个“基础”组件再叠加各种“附加”功能组件的模式，称之为Filter模式（或者装饰器模式：Decorator）。它可以让我们通过少量的类来实现各种功能的组合。

Java的IO标准库使用Filter模式为InputStream和OutputStream增加功能：

可以把一个InputStream和任意个FilterInputStream组合；
可以把一个OutputStream和任意个FilterOutputStream组合。

Filter模式可以在运行期动态增加功能（又称Decorator模式）。

操作Zip

ZipInputStream是一种FilterInputStream，它可以直接读取zip包的内容。

读取Zip

我们要创建一个ZipInputStream，通常是传入一个FileInputStream作为数据源，然后，循环调用getNextEntry()，直到返回null，表示zip流结束。

一个ZipEntry表示一个压缩文件或目录，如果是压缩文件，我们就用read()方法不断读取，直到返回-1：

直接看例子即可，用法就是这样：

    public static void test8() throws IOException{
        try(ZipInputStream zip = new ZipInputStream(new FileInputStream("1.zip"))){
            ZipEntry entry = null;
            while ((entry = zip.getNextEntry()) != null){
                String name = entry.getName();
                System.out.println(name);
                if(!entry.isDirectory()){
                    int n;
                    while ((n = zip.read())!= -1){
                        System.out.print((char)n);
                    }
                }
                System.out.println();
            }
        }
    }

写入Zip

ZipOutputStream是一种FilterOutputStream，它可以直接写入内容到zip包。我们要先创建一个ZipOutputStream，通常是包装一个FileOutputStream，然后，每写入一个文件前，先调用putNextEntry()，然后用write()写入byte[]数据，写入完毕后调用closeEntry()结束这个文件的打包。

    public static void test9() throws IOException{
        try(ZipOutputStream zip = new ZipOutputStream(new FileOutputStream("out.zip"))){
            File file = new File("out.txt");
            zip.putNextEntry(new ZipEntry(file.getName()));

            zip.write(getFileDataAsBytes(file));
            zip.closeEntry();
        }
    }

上面的代码没有考虑文件的目录结构。如果要实现目录层次结构，new ZipEntry(name)传入的name要用相对路径。

关于getFileDataAsBytes()，我写了2种：

    public static byte[] getFileDataAsBytes(File file) throws IOException {
        byte[] data;
        try(InputStream input = new FileInputStream(file);
            ByteArrayOutputStream out = new ByteArrayOutputStream()){
            int n;
            while ((n = input.read())!= -1){
                out.write(n);
            }
            data = out.toByteArray();
        }
        return data;
    }

    public static byte[] getFileDataAsBytes(File file) throws IOException {
        try(InputStream input = new FileInputStream(file)){
            StringBuilder sb = new StringBuilder();
            int n;
            while((n = input.read())!=-1){
                sb.append((char)n);
            }
            return sb.toString().getBytes(StandardCharsets.UTF_8);
        }
    }

第一个是参考别人的，第二个是自己写的，觉得还是思维太局限了叭，我觉得第一个可能会更好。

读取classpath资源

在classpath中的资源文件，路径总是以／开头，我们先获取当前的Class对象，然后调用getResourceAsStream()就可以直接从classpath读取任意的资源文件。

调用getResourceAsStream()需要特别注意的一点是，如果资源文件不存在，它将返回null。因此，我们需要检查返回的InputStream是否为null，如果为null，表示资源文件在classpath中没有找到：

try (InputStream input = getClass().getResourceAsStream("/default.properties")) {
    if (input != null) {
        // TODO:
    }
}

如果我们把默认的配置放到jar包中，再从外部文件系统读取一个可选的配置文件，就可以做到既有默认的配置文件，又可以让用户自己修改配置：

Properties props = new Properties();
props.load(inputStreamFromClassPath("/default.properties"));
props.load(inputStreamFromFile("./conf.properties"));

这样读取配置文件，应用程序启动就更加灵活。

序列化

不总结了，把IO流这部分学完之后会专门学习一下Java的序列化和反序列化。

Reader

内容跟InputStream比较类似了。

Reader是Java的IO库提供的另一个输入流接口。和InputStream的区别是，InputStream是一个字节流，即以byte为单位读取，而Reader是一个字符流，即以char为单位读取：

InputStream	Reader
字节流，以`byte`为单位	字符流，以`char`为单位
读取字节（-1，0~255）：`int read()`	读取字符（-1，0~65535）：`int read()`
读到字节数组：`int read(byte[] b)`	读到字符数组：`int read(char[] c)`

java.io.Reader是所有字符输入流的超类，它最主要的方法是：

public int read() throws IOException;

这个方法读取字符流的下一个字符，并返回字符表示的int，范围是0~65535。如果已读到末尾，返回-1。

FileReader

FileReader是Reader的一个子类，它可以打开文件并获取Reader。

        Reader reader = new FileReader("Java.iml");
        int n;
        while( (n = reader.read())!= -Java 学习笔记 - IO篇：常见的IO流Stream以及相互关系
 Java IO流 学习笔记
 Java IO流 学习笔记
 java学习笔记 --- IO
 Java学习笔记之：Java 流
 Java 学习笔记 - IO篇：常见的流Stream通道Channl以及相互关系

Java IO流 学习笔记

Java IO流 学习笔记

前言

简介

File对象

文件和目录

创建和删除文件

遍历文件和目录

Path

InputStream

缓冲

ByteArrayInputStream

OutputStream

FileOutputStream

ByteArrayOutputStream

复制文件

Filter模式

操作Zip

读取Zip

写入Zip

读取classpath资源

序列化

Reader

FileReader

Java IO流学习笔记

Java IO流学习笔记