java流式IO

July 11, 2022

java

IO 流

注意！这里的 IO 流不是 java.util.stream.* 包提供的流

面向字节(java.io):

InputStream
OutputStream

面向字符和基于 Unicode (java.io):

Reader
Writer

同步非阻塞(java.nio):

Buffer

Package java.io
https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/io/package-summary.html

Package java.nio
https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/nio/package-summary.html

Scanner

java.util.Scanner 实用类可通过正则表达式从流中解析原始类型和字符串。
这个流，是通过构造函数传入 Scanner 类中的。

java

// 构造函数，这里 ? 表示可选
Scanner(File source, ?String charsetName)
Scanner(InputStream source, ?String charsetName)
Scanner(Path source, ?String charsetName)
Scanner(ReadableByteChannel source, ?String charsetName)
Scanner(Readable source)
Scanner(String source)

演示如下，具体 API，参阅https://docs.oracle.com/javase/8/docs/api/java/util/Scanner.html

java

Scanner sc = new Scanner(System.in);
if (sc.hasNext()) {
    String s = sc.next();
}

File

https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/io/File.html
java.io.File 类，其构造函数传入文件路径，实例方法可获取文件信息

java

public class File implements Serializable, Comparable<File>
{
    public File(String pathname);
    public File(String parent, String child);
    public File(File parent, String child);
    public File(URI uri);
    public String getName();
    public String getParent();
    public File getParentFile();
    public String getPath();
    public boolean isAbsolute();
    public String getAbsolutePath()
    public File getAbsoluteFile()
    public String getCanonicalPath() throws IOException;
    public File getCanonicalFile() throws IOException;
    public URI toURI();
    public boolean canRead();
    public boolean canWrite();
    public boolean exists();
    public boolean isDirectory();
    public boolean isFile();
    public boolean isHidden();
    public long lastModified();
    public long length();
    public boolean createNewFile() throws IOException;
    public boolean delete();
    public void deleteOnExit();
    public String[] list();
    public String[] list(FilenameFilter filter);
    public File[] listFiles();
    public File[] listFiles(FilenameFilter filter);
    public File[] listFiles(FileFilter filter);
    public boolean mkdir();
    public boolean mkdirs();
    public boolean renameTo(File dest);
    public boolean setLastModified(long time);
    public boolean setReadOnly();
    public boolean setWritable(boolean writable, boolean ownerOnly);
    public boolean setWritable(boolean writable);
    public boolean setReadable(boolean readable, boolean ownerOnly);
    public boolean setReadable(boolean readable);
    public boolean setExecutable(boolean executable, boolean ownerOnly);
    public boolean setExecutable(boolean executable);
    public boolean canExecute();
    public static File[] listRoots();
    public long getTotalSpace();
    public long getFreeSpace();
    public long getUsableSpace();
    public static File createTempFile(String prefix, String suffix, File directory) throws IOException;
    public static File createTempFile(String prefix, String suffix) throws IOException;
    public int compareTo(File pathname);
    public boolean equals(Object obj) {return (obj instanceof File file) ? compareTo(file) == 0 : false;};
    public int hashCode();
    public String toString() {return getPath();}
    public Path toPath();
}

InputStream 抽象类

https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/io/InputStream.html

java

public abstract class InputStream implements Closeable {
    public InputStream();
    public abstract int read() throws IOException;
    public int read(byte b[]) throws IOException;
    public int read(byte b[], int off, int len) throws IOException;
    public long skip(long n) throws IOException;
    public int available() throws IOException;
    public void close() throws IOException;
    public synchronized void mark(int readlimit);
    public synchronized void reset() throws IOException;
    public boolean markSupported();
    // ! 以下 API 自 java 9
    public byte[] readAllBytes() throws IOException;
    public byte[] readNBytes(int len) throws IOException;
    public long transferTo(OutputStream out) throws IOException;
    // ! 以下 API 自 java 11
    public int readNBytes(byte[] b, int off, int len) throws IOException;
    public static InputStream nullInputStream();
    // ! 以下 API 自 java 12
    public void skipNBytes(long n) throws IOException;
}

FileInputStream 是该类是一个实现

java

InputStream input = new FileInputStream("path/to/file");
try {
    int x = input.read();
} finally {
    input.close();
}

使用 try(resource) 语法，自动 finally 并调用 close()

java

try (InputStream input = new FileInputStream("path/to/file")) {
    int x = input.read();
}// 自动 close (for java.lang.AutoCloseable)

System.in 也是 InputStream 的一个实现

此外，还可以通过字节数组获取一个字节流

java

InputStream input = new ByteArrayInputStream(new byte[] { 72, 101, 108, 108, 111, 33 });

OutputStream 抽象类

https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/io/OutputStream.html

java

public abstract class OutputStream implements Closeable, Flushable {
    public OutputStream();
    public abstract void write(int b) throws IOException;
    public void write(byte b[]) throws IOException;
    public void write(byte b[], int off, int len) throws IOException;
    public void flush() throws IOException;
    public void close() throws IOException;
    // ! 以下 API 自 java 11
    public static OutputStream nullOutputStream()
}

与 InputStream 相同，OutputStream 也有类似的实现类：FileOutputStream，ByteArrayOutputStream

java

try (OutputStream output = new FileOutputStream("path/to/file")) {
    output.write("Hello,world!".getBytes("UTF-8"));
}
/* -------------------------------------------------- */
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"));

序列化，反序列化

序列化指将 Java 对象转换为二进制数据，二进制数据可以视作 byte[]数组。
需要序列化的 Java 对象必须实现java.io.Serializable接口，即

java

class Clazz implements java.io.Serializable {
    // ... ...
}

注意，如果对象的属性是对象，属性对应类也必须实现 java.io.Serializable 接口。
java.io.Serializable 是一个空接口，仅用做标记，jvm 会为我们完成对象转换为二进制的操作

具体操作由 ObjectInputStream 和 ObjectOutputStream 类提供

Reader 和 Writer 抽象类

Reader 和 Writer 抽象类（与 InputStream 和 OutputStream 面向字节不同的是）提供了面向字符的接口
Java 提供的字符流类型 char 是 16 bits （2 bytes）的 Unicode 字符

这两个抽象类可以方便地操作字符串 String 和字符数组 char[]

与 FileInputStream 和 FileOutputStream 对应的类有 FileReader 和 FileWriter

参见 https://www.jishuchi.com/read/onjava8/12029
https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/io/Reader.html
https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/io/Writer.html

将 InputStream/OutputStream 转换为 Reader/Writer

java

// 假设其它API返回InputStream，但我们希望作为Reader处理（出于演示目的不使用FileReader）
InputStream input = new FileInputStream("filename.txt");
InputStreamReader reader = new InputStreamReader(input, StandardCharsets.UTF_8);

OutputStream output = new FileOutputStream("filename.txt");
OutputStreamWriter writer = new OutputStreamWriter(output);

PrintStream 和 PrintWriter

java.io.OutputStream <- java.io.FilterOutputStream <- java.io.PrintStream

PrintStream 类提供了两组重载方法，print 和 println，用于打印各种数据。System.out 和 System.err 都是该类的实现。

java.io.Writer <- java.io.PrintWriter

PrintWriter 与 PrintStream 基本一致，区别主要在于其面向字符而非字节

FilterInputStream 和 FilterOutputStream

关于 FilterInputStream 和 FilterOutputStream 类，通过装饰器模式实现了对 InputStream 和 OutputStream 类的包装

BufferedInputStream 和 BufferedOutputStream 类：提供了缓冲功能

ZipInputStream
https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/zip/ZipInputStream.html

GZIPInputStream
https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/zip/GZIPInputStream.html

JarInputStream
https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/jar/JarInputStream.html

java

// 在java中，我们将一个更基础的Stream作为功能性Stream的构造函数的参数，来实现类似于管道的功能
InputStream file = new FileInputStream("test.gz");
InputStream buffered = new BufferedInputStream(file);
InputStream gzip = new GZIPInputStream(buffered);
// 在java中这种模式称作Filter模式

// 如果我们自己要实现一个包装层，应当继承 FilterInputStream 抽象类，实现其方法
class MyInputStream extends FilterInputStream {}
// 相较于直接继承其它已有的InputStream实现类，继承 FilterInputStream 类更有利于维护

文档：https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/io/FilterInputStream.html

FilterReader 和 FilterWriter

BufferedReader 和 BufferedWriter 类：提供了缓存功能

（类似于 FilterInputStream 和 FilterOutputStream）

Path, Paths, PathMatcher (glob 支持)

Package java.nio.file
https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/nio/file/package-summary.html

Path 类表示文件系统中的某一路径，并提供了一些实用方法用于解析该路径

Paths 类提供了静态方法，用于将路径或 URI 类转换为 Path 类

java

Path Paths.get(String first, String... more)
Path Paths.get(URI uri)

PathMatcher 类表示一个 glob 或 regex ，用于进行文件查找，提供一个实例方法 matches(Path path) 返回是否匹配

java

PathMatcher matcher = FileSystems.getDefault().getPathMatcher("glob:**/*.{tmp,txt}");
Files.walk(test).filter(matcher::matches).forEach(System.out::println);