Java语言ch11 IO

字数统计: 2.3k字   |   阅读时长: 10分

IO流顺序读写数据，单向流动，称IO流。IO流以byte（字节）为最小单位，因此也称为字节流。

快速引入

InputStream / OutputStream

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

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

Reader / Writer

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

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

究竟使用Reader还是InputStream，要取决于具体的使用场景。如果数据源不是文本，就只能使用InputStream，如果数据源是文本，使用Reader更方便一些。Writer和OutputStream是类似的。

同步和异步

同步IO是，读写IO时代码必须等待数据返回后才继续执行后续代码，优点是代码编写简单，缺点是CPU执行效率低。

异步IO是，读写IO时仅发出请求，然后立刻执行后续代码，优点是CPU执行效率高，缺点是代码编写复杂。

Java标准库的包java.io提供了同步IO，而java.nio则是异步IO。

InputStream、OutputStream、Reader和Writer都是同步IO的抽象类，对应的具体实现类，以文件为例，有FileInputStream、FileOutputStream、FileReader和FileWriter。

File

Java的标准库java.io提供了File对象来操作文件和目录。

1
2
3
4
5
6
7
8
import java.io.*;

public class Main {
    public static void main(String[] args) {
        File f = new File("C:\\windows");
        System.out.println(f);
    }
}

构造File对象时，既可以传入绝对路径，也可以传入相对路径。

Windows平台使用\作为路径分隔符，在Java字符串中需要用\\表示一个\，前一个\表示转义。

Linux平台使用/作为路径分隔符

1
File f = new File("/usr/bin/javac");

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

规范路径就是把.和..转换成标准路径

因为Windows和Linux的路径分隔符不同，File对象有一个静态变量用于表示当前平台的系统分隔符：

1
System.out.println(File.separator); // 根据当前平台打印"\"或"/"

文件和目录

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

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

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

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

创建和删除文件

createNewFile()创建新文件，delete()删除文件

1
2
3
4
5
6
7
File file = new File("/path/file");
if (file.createNewFile()) {
    // 创建文件已成功
    if (file.delete()) {
        // 删除文件已成功
    }
}

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

1
2
3
4
5
6
7
8
9
import java.io.*;
public class Main {
    public static void main(String[] args) throws IOException {
        File f = File.createTempFile("tmp-", ".txt");
        f.deleteOnExit();  // JVM退出时自动删除
        System.out.println(f.isFile());
        System.out.println(f.getAbsolutePath());
    }
}

遍历文件和目录

File对象表示一个目录时，可以使用list()和listFiles()列出目录下的文件和子目录名。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        File f = new File("C:\\Windows");
        File[] fs1 = f.listFiles();  // 列出所有文件和子目录
        printFiles(fs1);
        File[] fs2 = f.listFiles(new FilenameFilter() {
            
            public boolean accept(File dir, String name) {  // 列出.exe文件
                return name.endsWith(".exe");  // 返回true表示接受该文件
            }
        });
        printFiles(fs2);
    }
    
    static void printFiles(File[] files) {
        System.out.pringln("");
        if (files != null) {
            for (File f : files) {
                System.out.println(f);
            }
        }
        System.out.println("");
    }
}

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

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

Path

位于java.nio.file包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.io.*;
import java.nio.file.*;

public class Main {
    public static void main(String[] args) throws IOException {
        Path p1 = Paths.get(".", "project", "study"); // 构造一个Path对象
        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);
        for (Path p : Paths.get("..").toAbsolutePath()) { // 可以直接遍历Path
            System.out.println("  " + p);
        }
    }
}

使用path适用于目录复杂的拼接、遍历等。

inputStream

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

FileInputStream就是从文件流中读取数据。

1
2
3
4
5
6
7
8
9
10
11
public void readFile() throws IOException {
    InputStream input = new FileInputStream("test.txt");
    for (;;) {
        int n = input.read();  // 反复调用read()方法，直到返回-1
        if (n == -1) {
            break;
        }
        System.out.println(n);
    }
    input.close();  //关闭流
}

InputStream和OutputStream都是通过close()方法来关闭流。

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

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

1
2
3
4
5
6
7
8
9
10
11
12
public void readFile() throws IOException {
    InputStream input = null;
    try {
        input = new FileInputStream("src/readme.txt");
        int n;
        while ((n = input.read()) != -1) { // 利用while同时读取并判断
            System.out.println(n);
        }
    } finally {
        if (input != null) { input.close(); }
    }
}

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

1
2
3
4
5
6
7
8
public void readFile() throws IOException {
    try (InputStream input = new FileInputStream("src/readme.txt")) {
        int n;
        while ((n = input.read()) != -1) {
            System.out.println(n);
        }
    } // 编译器在此自动为我们写入finally并调用close()
}

try(resource = ...)中的对象是否实现了java.lang.AutoCloseable接口，如果实现了，就自动加上finally语句并调用close()方法。InputStream和OutputStream都实现了这个接口。

InputStream实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
import java.io.*;
public class Main {
    public static void main(String[] args) throws IOException {
        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

OutputStream还提供了一个flush()方法，它的目的是将缓冲区的内容真正输出到目的地，能强制把缓冲区内容输出。

OutputStream实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
import java.io.*;
public class Main {
    public static void main(String[] args) throws IOException {
        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"));
    }
}

操作zip文件

ZipInputStream是一种FilterInputStream，它可以直接读取zip包的内容，JarInputStream是从ZipInputStream派生，它增加的主要功能是直接读取jar文件里面的MANIFEST.MF文件。

读取zip包

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

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

1
2
3
4
5
6
7
8
9
10
11
12
try (ZipInputStream zip = new ZipInputStream(new FileInputStream(...))) {
    ZipEntry entry = null;
    while ((entry = zip.getNextEntry()) != null) {
        String name = entry.getName();
        if (!entry.isDirectory()) {
            int n;
            while ((n = zip.read()) != -1) {
                ...
            }
        }
    }
}

写入zip包

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

1
2
3
4
5
6
7
8
try (ZipOutputStream zip = new ZipOutputStream(new FileOutputStream(...))) {
    File[] files = ...
    for (File file : files) {
        zip.putNextEntry(new ZipEntry(file.getName()));
        zip.write(getFileDataAsBytes(file));
        zip.closeEntry();
    }
}

读取classpath资源

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

调用getResourceAsStream()就可以直接从classpath读取任意的资源文件。

序列化

1
序列化是指把一个Java对象变成二进制内容，本质上就是一个byte[]数组。

一个Java对象要能序列化，必须实现一个特殊的java.io.Serializable接口，它的定义如下：

1
2
public interface Serializable {
}

Serializable接口没有定义任何方法，它是一个空接口。

序列化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.io.*;
import java.util.Arrays;
public class Main {
    public static void main(String[] args) throws IOException {
        ByteArrayOutputStream buffer = new ByteArrayOutputStream();
        try (ObjectOutputStream output = new ObjectOutputStream(buffer)) {
            // 写入int:
            output.writeInt(12345);
            // 写入String:
            output.writeUTF("Hello");
            // 写入Object:
            output.writeObject(Double.valueOf(123.456));
        }
        System.out.println(Arrays.toString(buffer.toByteArray()));
    }
}

反序列化

1
2
3
4
5
try (ObjectInputStream input = new ObjectInputStream(...)) {
    int n = input.readInt();
    String s = input.readUTF();
    Double d = (Double) input.readObject();
}

Java的序列化允许class定义一个特殊的serialVersionUID静态变量，用于标识Java类的序列化“版本”，通常可以由IDE自动生成。如果增加或修改了字段，可以改变serialVersionUID的值，这样就能自动阻止不匹配的class版本：

1
2
3
public class Person implements Serializable {
    private static final long serialVersionUID = 2709425275741743919L;
}

要特别注意反序列化的几个重要特点：

反序列化时，由JVM直接构造出Java对象，不调用构造方法，构造方法内部的代码，在反序列化时根本不可能执行。

通用的序列化方法，例如JSON。

本文作者： Yao Zhu
发布时间： 2019-09-07
最后更新： 2019-09-15
本文链接： https://juoyo.github.io/posts/9d0114be.html
版权声明： 本作品采用 知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议 进行许可。转载请注明出处！
知识共享许可协议
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码
-->

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

INTJ <br><br> 天真认生，请多指教。