IO流

发表于 分类于 本文字数： 13k
字节流、字符流、缓冲流、转换流、序列化流、打印流、压缩流

字节流

输入流

InputStream

InputStream是所有字节输入流的父类，常用的方法有如下：

int read()

  按字节读取数据，返回值即为读取到的字节，当返回-1时，文件读取完毕

int read(byte[])

  将读取到的数据放置在byte数组中，返回值为本次读取的字节长度，当返回-1时，文件读取完毕

void close()

  关闭输入流

FileInputStream

FileInputStream是InputStream的子类，用于读取文件的字节流，其有三个构造方法，分别如下：

FileInputStream(File)

  传入文件对象，需要确保该文件存在

FileInputStream(String)

  传入文件路径，需要确保该文件存在

FileInputStream(FileDescriptor)

  传入文件句柄，需要确保该文件存在

按字节读取文件

1
2
3
4
5
6
7
8
9
10
// 创建输入流
try (FileInputStream fis = new FileInputStream(path)){
    int read;
    // 循环读取文件中的所有字节
    while ((read = fis.read()) != -1) {
        System.out.println((char)read);
    }
} catch (IOException e) {
    throw new RuntimeException(e);
}

读取文件字节到byte数组中

1
2
3
4
5
6
7
8
9
10
11
12
13
// 创建输入流
try (FileInputStream fis = new FileInputStream(path)){
    StringBuilder sb = new StringBuilder();
    byte[] buffer = new byte[1024];
    int len;
    // 循环读取文件中的所有字节
    while ((len = fis.read(buffer)) != -1) {
        sb.append(new String(buffer, 0, len));
    }
    System.out.println(sb);
} catch (IOException e) {
    throw new RuntimeException(e);
}

输出流

OutputStream

OutputStream是所有字节输出流的父类，常用的方法有如下：

void write(int)

  写出数据，每次仅写出一个字节

void write(byte[])

  写出数据，将数组中的所有字节写出

void flush()

  刷新输出流

void close()

  关闭输出流

FileOutputStream

FileOutputStream是OutputStream的子类，文件输出流，用于将数据字节流输出到文件，其有五个构造方法分别如下：

FileOutputStream(String)

  传入文件路径，文件不存在时会自动创建，文件存在时会清空内容

FileOutputStream(String, boolean)

  传入文件路径，第二个参数表示是否续写

FileOutputStream(File)

  传入文件对象，文件不存在时会自动创建，文件存在时会清空内容

FileOutputStream(File, boolean)

  传入文件对象，第二个参数表示是否续写

FileOutputStream(FileDescriptor)

  传入文件句柄

按字节写出文件

1
2
3
4
5
6
7
8
9
10
11
12
13
// 创建输出流
try (FileOutputStream fos = new FileOutputStream(path)) {
    // 指定的内容
    String text = "测试文字";
    // 将内容转换成字节流
    byte[] bytes = text.getBytes(StandardCharsets.UTF_8);
    // 将字节一个个写出
    for (byte b : bytes) {
        fos.write(b);
    }
} catch (IOException e) {
    throw new RuntimeException(e);
}

一次性写出

1
2
3
4
5
6
7
8
9
10
11
// 创建输出流
try (FileOutputStream fos = new FileOutputStream(path)) {
    // 指定的内容
    String text = "测试文字";
    // 将内容转换成字节流
    byte[] bytes = text.getBytes(StandardCharsets.UTF_8);
    // 一次性写出
    fos.write(bytes);
} catch (IOException e) {
    throw new RuntimeException(e);
}

字符流

FileReader和FileWriter，其底层是InputStreamReader和OutputStreamWriter实现，后两者在创建时传入InputStream和OutputStream，并且创建时可以指定解码类型

输入流

Reader

Reader是所有字符输入流的父类，常用的方法有如下：

int read()

  按字符读取数据，返回值即为读取到的字符，当返回-1时，文件读取完毕

int read(char[])

  将读取到的数据放置在char数组中，返回值为本次读取的字符长度，当返回-1时，文件读取完毕

void close()

  关闭输入流

FileReader

FileReader是Reader的子类，用于读取文件的字节流，其有三个构造方法，分别如下：

FileReader(String)

  传入文件对象，需要确保该文件存在

FileReader(File)

  传入文件路径，需要确保该文件存在

FileReader(FileDescriptor)

  传入文件句柄，需要确保该文件存在

每次读取一个字符

1
2
3
4
5
6
7
8
9
10
11
// 创建字符输入流
try (FileReader fr = new FileReader(path)){
    int read;
    // 循环读取文件
    while ((read = fr.read()) != -1) {
        // 输出本轮读取到的字符
        System.out.print((char)read);
    }
} catch (IOException e) {
    throw new RuntimeException(e);
}

一次读取多个字符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 创建字符输入流
try (FileReader fr = new FileReader(path)){
    int len;
    char[] buffer = new char[1024];
    StringBuilder sb = new StringBuilder();
    // 循环读取文件内容
    while ((len = fr.read(buffer)) != -1) {
        // 将本轮读取到的字符累加到sb
        sb.append(new String(buffer, 0, len));
    }
    // 打印
    System.out.println(sb);
} catch (IOException e) {
    throw new RuntimeException(e);
}

输出流

Writer

Writer是所有字符输出流的父类，常用的方法有如下：

void write(int)

  写出数据，每次仅写出一个字符，虽然都是int类型数据，但是该数据是由字符的char对应的int，不同于OutputStream.read(int)的字节流

void write(char[])

  写出数据，将数组中的所有字符写出

write(String)

  写出数据，将字符串写出

void flush()

  刷新输出流

void close()

  关闭输出流

FileWriter

FileWriter是Writer的子类，字符输出流，用于将数据字符流输出到文件，其有五个构造方法分别如下：

FileWriter(String)

  传入文件路径，文件不存在时会自动创建，文件存在时会清空内容

FileWriter(String, boolean)

  传入文件路径，第二个参数表示是否续写

FileWriter(File)

  传入文件对象，文件不存在时会自动创建，文件存在时会清空内容

FileWriter(File, boolean)

  传入文件对象，第二个参数表示是否续写

FileWriter(FileDescriptor)

  传入文件句柄

按字符写出文件

1
2
3
4
5
6
7
8
9
10
11
try (FileWriter fw = new FileWriter(path)){
    String text = "测试内容";
    for (int i = 0; i < text.length(); i++) {
        // 逐个取字符串中的字符，并转换为int类型
        int c = text.charAt(i);
        // 写出
        fw.write(c);
    }
} catch (IOException e) {
    throw new RuntimeException(e);
}

一次性写出多个字符

1
2
3
4
5
6
7
8
9
10
11
12
try (FileWriter fw = new FileWriter(path)){
    // 目标字符串
    String text = "岳阳楼记";
    // 创建长度相当的char数组
    char[] cs = new char[text.length()];
    // 得到目标字符串对应的char数组
    text.getChars(0, text.length(), cs, 0);
    // 一次性写入
    fw.write(cs);
} catch (IOException e) {
    throw new RuntimeException(e);
}

直接写出字符串

1
2
3
4
5
6
7
8
try (FileWriter fw = new FileWriter(path)){
    // 目标字符串
    String text = "小石潭记";
    // 直接写出
    fw.write(text);
} catch (IOException e) {
    throw new RuntimeException(e);
}

缓冲流

字节缓冲流

对基本流进行包装，实现更快速的读写，其底层是一个长度为8096的缓冲区，输入流和输出流进行数据传输时，实际上是缓冲区之间在进行传输，速度远大于内存之间的数据传输

通过如下代码对一个大小为153MB的文件进行传输测试，三次的平均时间为1.1秒，但是其实手动增加buffer的长度，还可以更快

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
try (FileInputStream fis = new FileInputStream(path);
     FileOutputStream fos = new FileOutputStream(path2)){

    // 开始时间
    long start = System.currentTimeMillis();

    // 通过buffer在内存之间倒腾数据
    int len;
    byte[] buffer = new byte[1024];
    while ((len = fis.read(buffer)) != -1) {
        fos.write(buffer, 0, len);
    }

    // 结束时间
    long end = System.currentTimeMillis();

    System.out.println("共 " + (end - start)/1000.0 + " 秒");
} catch (IOException e) {
    throw new RuntimeException(e);
}

通过如下代码三次的平均时间为4.1秒

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
try {
    // 使用缓冲流包装基本流
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(path));
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(path2));

    // 开始时间
    long start = System.currentTimeMillis();

    // 通过len在两个缓冲区之间倒腾数据
    int len;
    while ((len = bis.read()) != -1) {
        bos.write(len);
    }

    // 结束时间
    long end = System.currentTimeMillis();

    System.out.println("共 " + (end - start)/1000.0 + " 秒");

    bis.close();
    bos.close();
} catch (IOException e) {
    throw new RuntimeException(e);
}

通过如下代码三次的平均时间为0.3秒

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
try {
    // 使用缓冲流包装基本流
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(path));
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(path2));

    // 开始时间
    long start = System.currentTimeMillis();

    // 通过buffer在两个缓冲区之间倒腾数据
    int len;
    byte[] buffer = new byte[1024];
    while ((len = bis.read(buffer)) != -1) {
        bos.write(buffer, 0, len);
    }

    // 结束时间
    long end = System.currentTimeMillis();

    System.out.println("共 " + (end - start)/1000.0 + " 秒");

    bis.close();
    bos.close();
} catch (IOException e) {
    throw new RuntimeException(e);
}

字符缓冲流

字符缓冲流提供了一些比较重要的方法

如下读取时逐行读取

1
2
3
4
5
6
7
8
9
10
11
12
13
try {
    BufferedReader br = new BufferedReader(new FileReader(path));

    String line;
    // 逐行读取
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }

    br.close();
} catch (IOException e) {
    throw new RuntimeException(e);
}

如下写出时直接换行

1
2
3
4
5
6
7
8
9
10
11
12
try {
    BufferedWriter bw = new BufferedWriter(new FileWriter(path2));

    bw.write("第一行");
    // 换行
    bw.newLine();
    bw.write("第二行");

    bw.close();
} catch (IOException e) {
    throw new RuntimeException(e);
}

转换流

输入流

转换流的输入流实际上是字符流，因为InputStreamReader继承Reader（InputStreamReader同时也是FileReader的父类），因此转换流可以被缓冲流包装，获得更快的读取速度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 读取GBK格式文件
try (FileInputStream fis = new FileInputStream(path2);
     // 转换流，读取GBK格式
     InputStreamReader isr = new InputStreamReader(fis, Charset.forName("GBK"));
     // 使用缓冲流，包装转换流
     BufferedReader br = new BufferedReader(isr)) {
    int len;
    char[] buffer = new char[1024];
    StringBuilder sb = new StringBuilder();
    while ((len = br.read(buffer)) != -1) {
        sb.append(new String(buffer, 0, len));
    }
    System.out.println(sb);
} catch (IOException e) {
    throw new RuntimeException(e);
}

在JDK 11之后，可以使用字符流直接指定编码

1
2
3
4
5
6
7
8
9
try (FileReader fr = new FileReader(path2, Charset.forName("GBK"))){
    char[] buffer = new char[1024];
    int len;
    while ((len = fr.read(buffer)) != -1) {
        System.out.print(new String(buffer, 0, len));
    }
} catch (IOException e) {
    throw new RuntimeException(e);
}

输出流

转换流的输出流也是字符流，OutputStreamWriter继承Writer（OutputStreamWriter同时也是FileWriter的父类），可以被缓冲流包装

1
2
3
4
5
6
7
8
9
10
// 写出GBK格式文件
try (FileOutputStream fos = new FileOutputStream(path2);
     // 转换流，写出GBK格式
     OutputStreamWriter osw = new OutputStreamWriter(fos, Charset.forName("GBK"))){
    String text = "一个成熟的铠甲勇士，是不会被过去所打败的";
    // 写出
    osw.write(text);
} catch (IOException e) {
    throw new RuntimeException(e);
}

在JDK 11之后，可以使用字符流直接指定编码

1
2
3
4
5
6
try (FileWriter fw = new FileWriter(path2, Charset.forName("UTF-8"))){
    String text = "一个成熟的铠甲勇士，是不会被过去所打败的";
    fw.write(text);
} catch (IOException e) {
    throw new RuntimeException(e);
}

序列化流

序列化流可以将所有实现了Serializable接口的对象序列化到本地，实现永久保存；如果对象中的某个属性不需要序列化，则必须使用transient修饰

1
2
3
4
5
6
7
// 实现 Serializable 接口
public class MyKey implements Serializable {
    private int value;
    private String content;
    // 该属性不会被序列化
    private transient String name;
}

将对象反序列化到本地

1
2
3
4
5
6
7
8
9
MyKey myKey = new MyKey(100, "value");

try (FileOutputStream fos = new FileOutputStream(path2);
     ObjectOutputStream oos = new ObjectOutputStream(fos)){

    oos.writeObject(myKey);
} catch (IOException e) {
    throw new RuntimeException(e);
}

执行反序列化时，readObject()通过serialVersionUID来验证序列化对象中的版本号和对应类中的版本号是否匹配，可以通过手动添加serialVersionUID来解决由类中增加属性而导致的UID变动

1
2
3
4
5
public class MyKey implements Serializable {
    private static final long serialVersionUID = -1683431510498494091L;
    private int value;
    private String content;
}

将本地存储的文件反序列化为对象

1
2
3
4
5
6
7
8
9
try (FileInputStream fis = new FileInputStream(path2);
     ObjectInputStream ois = new ObjectInputStream(fis)){
    // 反序列化对象
    MyKey key = (MyKey) ois.readObject();
    // 输出
    System.out.println(key);
} catch (IOException | ClassNotFoundException e) {
    throw new RuntimeException(e);
}

打印流

字节打印流

常用构造器

1
2
3
4
PrintStream(OutputStream | File | String)   关联字节输出流/文件/文件路径
PrintStream(String, Charset)                指定字符编码
PrintStream(OutputStream, boolean)          自动刷新
PrintStream(OutputStream, boolean, String)  指定字符编码且自动刷新

常用成员方法

1
2
3
void println(V)                 打印任意数据，自动刷新，自动换行
void print(V)                   打印任意数据，不换行
void printf(String, Object...)  带有占位符的打印语句，不换行

使用方法其实跟System.out.println()差不多，字节打印流的自动刷新默认是开启的

1
2
3
4
5
6
7
8
9
10
11
12
try (PrintStream ps = new PrintStream(new FileOutputStream(path2))) {
    // 输出并换行
    ps.println("忘了当初怎么接近");
    ps.println("反正别有用心");
    // 光输出，不换行
    ps.print("付出些零花的感情");
    ps.println();
    ps.print("换你的信任");
    ps.println();
} catch (FileNotFoundException e) {
    throw new RuntimeException(e);
}

打印流可以设置输出的文件的字符编码方式

1
2
3
4
5
6
7
8
9
10
try (FileOutputStream fos = new FileOutputStream(path2);
     // 设置自动刷新，并设置编码方式
     PrintStream ps = new PrintStream(fos, true, "UTF-8")) {
    // 设置系统日志输出地址
    System.setOut(ps);
    // 将会输出在 path2 中
    System.out.println("一个成熟的铠甲勇士，是不会被过去打败的");
} catch (IOException e) {
    throw new RuntimeException(e);
}

且实际上System.out.println()也是字节打印流

1
2
3
4
5
6
7
8
try (PrintStream ps = new PrintStream(new FileOutputStream(path2))) {
    // 设置系统日志输出地址
    System.setOut(ps);
    // 将会输出在 path2 中
    System.out.println("一个成熟的铠甲勇士，是不会被过去打败的");
} catch (FileNotFoundException e) {
    throw new RuntimeException(e);
}

字符打印流

字符打印流感觉跟字节打印流差不多，底层多了一个缓冲区效率更高一点，自动刷新默认是关闭的

1
2
// 再往下大同小异，不想写了
PrintWriter pw = new PrintWriter(new FileWriter(path2), true);

压缩流

解压缩，当出现中文命名的文件时，需要为解压缩流设置字符编码

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
File zipFile = new File(path);
// 创建一个解压缩流
try (ZipInputStream zip = new ZipInputStream(new FileInputStream(zipFile), Charset.forName("GBK"))){
    // 使用循环，从解压缩流中获取压缩包中的每个文件
    ZipEntry zipEntry;
    while ((zipEntry = zip.getNextEntry()) != null) {
        // 得到压缩包中的文件，在解压缩后的地址
        File file = new File(zipFile.getParent(), zipEntry.getName());
        if (zipEntry.isDirectory()) {
            // 创建文件夹
            file.mkdirs();
        } else {
            // 写出文件
            FileOutputStream fos = new FileOutputStream(file);
            byte[] buffer = new byte[1024];
            int len;
            // 从解压缩流中读取待写出的数据
            while ((len = zip.read(buffer)) != -1) {
                fos.write(buffer, 0, len);
            }
        }
    }
} catch (IOException e) {
    throw new RuntimeException(e);
}

压缩文件时，新建的ZipEntry(Stirng)对象，路径最后带\\那就是在压缩包中添加文件夹，不带就是在压缩包中添加文件，多级目录会被一次性创建，如将new ZipEntry("a\\b\\c\\")提交进压缩包，会在压缩包中一次性创建这三个目录

如下代码，添加单个文件或单个文件夹进压缩包

1
2
3
4
5
6
7
8
9
10
11
12
13
try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(destZipFile), Charset.forName("GBK"))){
    // 在压缩包里添加一个“滕王阁序.txt”文件
    zos.putNextEntry(new ZipEntry("滕王阁序.txt"));

    // 向压缩包中的“滕王阁序.txt”文件写数据
    String text = "落霞与孤鹜齐飞，秋水共长天一色。";
    zos.write(text.getBytes(Charset.forName("GBK")));

    // 在压缩包里添加一个“folder”文件夹
    zos.putNextEntry(new ZipEntry("folder\\"));
} catch (IOException e) {
    throw new RuntimeException(e);
}

如下代码，通过遍历的方式，将一个文件，或一个文件夹中的所有文件添加到压缩包；如果是文件，则直接添加到压缩包；如果是文件夹，在压缩包中添加对应的文件夹并继续遍历

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
// 待压缩的文件
File srcFile = new File(path);
// 文件压缩后的压缩包
File zipFile = new File(srcFile.getParent(), srcFile.getName() + ".zip");
// 开始压缩
try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipFile), Charset.forName("GBK"))){
    toZip(srcFile, srcFile.getName(), zos);
} catch (IOException e) {
    throw new RuntimeException(e);
}


/**
 * 将一个文件或文件夹中的所有文件压缩
 * @param srcFile   待压缩的文件
 * @param zipPath   待压缩的文件，压缩后在压缩包中的路径
 * @param zos       压缩流
 */
public static void toZip(File srcFile, String zipPath, ZipOutputStream zos) throws IOException {
    // 判断待压缩的文件是否是文件夹
    if (srcFile.isDirectory()) {
        // 在压缩包里添加一个文件夹
        ZipEntry entry = new ZipEntry(zipPath + "\\");
        System.out.println(entry);
        zos.putNextEntry(entry);
        // 继续遍历文件夹
        File[] files = srcFile.listFiles();
        for (File file : files) {
            toZip(file, zipPath + "\\" + file.getName(), zos);
        }
    } else {
        // 在压缩包里添加一个文件
        ZipEntry entry = new ZipEntry(zipPath);
        System.out.println(entry);
        zos.putNextEntry(entry);
        // 写入数据到添加的文件
        FileInputStream fis = new FileInputStream(srcFile);
        int len;
        byte[] buffer = new byte[1024];
        while ((len = fis.read(buffer)) != -1) {
            zos.write(buffer, 0, len);
        }
    }
}