Java---增强IO流

最新推荐文章于 2024-02-17 21:42:08 发布
最新推荐文章于 2024-02-17 21:42:08 发布
阅读量1k 收藏
点赞数
分类专栏： JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cococonger_/article/details/120171468
版权

文章目录

一、缓冲流

比如能够高效读写的缓冲流，能够转换编码的转换流，能够持久化存储对象的序列化流等等。这些功能更为强大的流，都是在基本的流对象基础之上创建而来的，就像穿上铠甲的武士一样，相当于是对基本流对象的一种增强。

1.1、概述

缓冲流，也叫高效流，是对4个基本的FileXxx 流的增强，所以也是4个流，按照数据类型分类：

  • 字节缓冲流：BufferedInputStream，BufferedOutputStream
  • 字符缓冲流：BufferedReader，BufferedWriter

缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。和基本IO流使用的数组原理一样。

1.2、字节缓冲输出流

继承了字节流，可以使用父类的共性成员方法方法

1.2.1、构造方法

  • public BufferedOutputStream(OutputStream out)： 创建一个新的缓冲输出流。
  • public BufferedOutputStream(OutputStream out, int size)： 创建一个新的缓冲输出流。
    • OutputStream out：字节输出流，可以传递FileOutputStream，缓冲流会给它增加一个缓冲区
    • int size：指定缓冲区数组大小，不指定就是默认

1.2.2、使用步骤

  1. 创建一个FileOutputStream对象，构造方法中绑定要输出的目的地

  2. 创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提高写入效率

  3. 使用BufferedOutputStream对象中的方法write，把数据写入到内部的缓冲区中

  4. 使用BufferedOutputStream对象中的方法flush，把缓冲区中的数据刷新到文件中

  5. 释放资源(会先调用flush方法刷新数据，第四步可以省略)，同时关闭基础输出流

    // 继承自OutputStream
public class Demo01BufferedOutputStream {
    public static void main(String[] args) throws Exception {
        // 1. 创建一个FileOutputStream对象，构造方法中绑定要输出的目的地
        FileOutputStream fos = new FileOutputStream("10_IO.txt");
        // 2. 创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        // 3. 使用BufferedOutputStream对象中的方法write，把数据写入到内部的缓冲区中
        bos.write("把数据写入到内部缓冲区中".getBytes());
        bos.flush();
        bos.close();
    }
}

1.3、字节缓冲输入流

1.3.1、构造方法

  • public BufferedInputStream(InputStream in) ：创建一个新的缓冲输入流。
  • public BufferedInputStream(InputStream in, int size) ：创建一个新的缓冲输入流。
    • InputStream in：字节输入流，可以传递FileInputStream，缓冲流会给它增加一个缓冲区
    • int size：指定缓冲区数组大小，不指定就是默认

1.3.2、使用步骤

  1. 创建FileInputStream对象，构造方法中绑定要读取的数据源
  2. 创建BufferedInputStream对象，构造方法中传递FileInputStream对象，提高读取效率
  3. 使用BufferedInputStream对象中的方法read，读取文件
  4. 释放资源，同时关闭基础输入流

1.3.3、效率测试

使用缓冲流文件复制的步骤：

  1. 创建字节缓冲输入流对象，构造方法中传递字节输入流
  2. 创建字节缓冲输出流对象，构造方法中传递字节输出流
  3. 使用字节缓冲输入流对象中的read方法读取文件
  4. 使用字节缓冲输出流对象中的write方法，把读取的数据写入内部缓冲区中
  5. 释放资源(先把缓冲区中的文件刷新到文件中)
    // 7毫秒
public class Demo2CopyFile {
    public static void main(String[] args) throws Exception {
        long s = System.currentTimeMillis();
        FileInputStream fis = new FileInputStream("E:\\money.jpg");
        FileOutputStream fos = new FileOutputStream("E:\\money001.jpg");

        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);

//        int len = 0;
//        while ((len = bis.read()) != -1) {
//            bos.write(len);
//        }

        byte[] bytes = new byte[1027];
        int len = 0;
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0, len);
        }

        bos.close();
        bis.close();

        System.out.println(System.currentTimeMillis() - s + "毫秒");
    }
}

1.4、字符缓冲输出流

继承了字符输出流，可以使用父类的共性成员方法

1.4.1、构造方法

  • public BufferedWriter(Writer out)：创建一个默认大小输出缓冲区的字符缓冲输出流。

  • public BufferedWriter(Writer out, int size)：创建一个指定大小输出缓冲区的字符缓冲输出流。

    • Writer out：字符输出流，可以传递FileWriter，缓冲流会给它增加一个缓冲区，提高写入效率
    • int size：指定缓冲区大小，不写就使用默认大小

1.4.2、特有方法

public void newLine(): 写入一个行分隔符，会根据不同的操作系统，获取不同的行分隔符

1.4.3、使用步骤

  1. 创建字符缓冲输出流对象，构造方法中传递字符输出流
  2. 调用字符缓冲输出流中的方法write，把数据写入到内存缓冲区中
  3. 调用flush方法，把内存缓冲区中的数据刷新到文件中
  4. 释放资源
    // 字符缓冲输出流
public class Demo03BufferedWriter {
    public static void main(String[] args) throws IOException {
        // 1. 创建字符缓冲输出流对象，构造方法中传递字符输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("11_IO.txt"));
        for (int i = 0; i < 10; i++) {
            // 2. 调用字符缓冲输出流中的方法writer，把数据写入到内存缓冲区中
            bw.write("测试程序");
            bw.newLine();
        }
        // 3. 调用flush方法，把内存缓冲区中的数据刷新到文件中
        bw.flush();
        // 4. 释放资源
        bw.close();
    }
}

1.5、字符缓冲输入流

继承自字符输入流，可以使用父类的共性成员方法

1.5.1、构造方法

  • public BufferedReader(Reader in) ：创建一个默认缓冲区大小的字符缓冲输入流。
  • public BufferedReader(Reader in, int size) ：创建一个指定缓冲区大小的字符缓冲输入流。
    • Reader in：字符输入流，可以传递FileReader，给它增加一个缓冲区，提高读取效率

1.5.2、特有方法

public String readLine()：读取一行数据。
行的终止符号：通过这些字符判断一行终止：换行(’\n’)、回车(’\r’)、或回车后直接跟着换行(’\r\n’)
返回值：包含该行内容的字符串，不包含任何终止符，如果已达到流末尾，返回null

1.5.3、使用步骤

  1. 创建字符缓冲输入流对象，构造方法中传递字符输入流
  2. 使用字符输入流对象中的方法read或readline，读取文本
  3. 释放资源

1.6、练习：文本排序

  1. 创建一个HashMap集合对象，key存储每行文本的序号，value存储每行的文本
  2. 创建字符缓冲输入流对象，构造方法中绑定字符输入流
  3. 创建字符缓冲输出流对象，构造方法中绑定字符输出流
  4. 使用字符缓冲输入流中的readLine方法，逐行读取文本
  5. 对读取到的文本进行切割，获取序号和文本内容
  6. 把切割好的序号和文本内容存储到HashMap集合中(key序号是有序的，会自动排序)
  7. 遍历HashMap集合，获取每一个键值对
  8. 把每一个键值对拼接为一个文本行
  9. 把拼接好的文本行使用字符缓冲输出流中的方法write，写入到文件中
  10. 释放资源

二、转换流

2.1、字符编码和字符集

2.1.1、字符编码

计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。
按照某种规则，将字符存储到计算机中，称为编码 。
反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码 。
比如说，按照A规则存储，同样按照A规则解析，那么就能显示正确的文本符号。
反之，按照A规则存储，再按照B规则解析，就会导致乱码现象。
编码：字符(能看懂的)–字节(看不懂的)
解码：字节(看不懂的)–>字符(能看懂的)

字符编码Character Encoding : 就是一套自然语言的字符与二进制数之间的对应规则。
编码表:生活中文字和计算机中二进制的对应规则

2.1.2、字符集

字符集 Charset：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。
计算机要准确的存储和识别各种字符集符号，需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBK字符集、Unicode字符集等。
当指定了编码，它所对应的字符集自然就指定了，所以编码才是我们最终要关心的。

  • ASCII字符集 ：

    • ASCII（美国信息交换标准代码）是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符（回车键、退格、换行键等）和可显示字符（英文大小写字符、阿拉伯数字和西文符号）。
    • 基本的ASCII字符集，使用7位（bits）表示一个字符，共128字符。ASCII的扩展字符集使用8位（bits）表示一个字符，共256字符，方便支持欧洲常用字符。

  • ISO-8859-1字符集：

    • 拉丁码表，别名Latin-1，用于显示欧洲使用的语言，包括荷兰、丹麦、德语、意大利语、西班牙语等。
    • ISO-8859-1使用单字节编码，兼容ASCII编码。

  • GBxxx字符集：

    • GB就是国标的意思，是为了显示中文而设计的一套字符集。
    • GB2312：简体中文码表。一个小于127的字符的意义与原来相同。但两个大于127的字符连在一起时，就表示一个汉字，这样大约可以组合了包含7000多个简体汉字，此外数学符号、罗马希腊的字母、日文的假名们都编进去了，连在ASCII里本来就有的数字、标点、字母都统统重新编了两个字节长的编码，这就是常说的"全角"字符，而原来在127号以下的那些就叫"半角"字符了。
    • GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等。
    • GB18030：最新的中文码表。收录汉字70244个，采用多字节编码，每个字可以由1个、2个或4个字节组成。支持中国国内少数民族的文字，同时支持繁体汉字以及日韩汉字等。

  • Unicode字符集 ：

    • Unicode编码系统为表达任意语言的任意字符而设计，是业界的一种标准，也称为统一码、标准万国码。
    • 它最多使用4个字节的数字来表达每个字母、符号，或者文字。有三种编码方案，UTF-8、UTF-16和UTF-32。最为常用的UTF-8编码。
    • UTF-8编码，可以用来表示Unicode标准中任何字符，它是电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。所以，我们开发Web应用，也要使用UTF-8编码。它使用一至四个字节为每个字符编码，编码规则：
      1. 128个US-ASCII字符，只需一个字节编码。
      2. 拉丁文等字符，需要二个字节编码。
      3. 大部分常用字（含中文），使用三个字节编码。
      4. 其他极少使用的Unicode辅助字符，使用四字节编码。

2.2、编码引出的问题

在IDEA中，使用FileReader 读取项目中的文本文件。由于IDEA的设置，都是默认的UTF-8编码，所以没有任何问题。但是，当读取Windows系统中创建的文本文件时，由于Windows系统的默认是GBK编码，就会出现乱码。

/*
    FileReader可以读取IDEA默认编码格式(UTF-8)文件
    如果使用FileReader读取系统默认编码格式(中文GBK)文件，就会产生乱码
 */
public class Demo01FileReader {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("GBK格式.txt");
        int len;
        while ((len = fr.read()) != -1) {
            System.out.print((char)len);
        }
        fr.close();
    }
}
// 控制台会打印出乱码

2.3、OutputStreamWriter类

转换流java.io.OutputStreamWriter ，是Writer的子类，是从字符流到字节流的桥梁。
使用指定的字符集将字符编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。
继承了父类的共性方法

2.3.1、构造方法

  • OutputStreamWriter(OutputStream in): 创建一个使用默认字符集的字符流。
  • OutputStreamWriter(OutputStream in, String charsetName): 创建一个指定字符集的字符流。
    • OutputStream in：字节输出流，可以用来写转换之后的字节到文件中
    • String charsetName：指定的编码表名称，不区分大小写

2.3.2、使用步骤

  1. 创建一个OutputStreamWriter对象，构造方法中传递字节输出流和指定的编码表名称

  2. 使用OutputStreamWriter中的方法write，把字符转换为字节存储到缓冲区中(编码)

  3. 使用OutputStreamWriter中的方法flush，把内存缓冲区中的字节刷新到文件中(使用字节流写字节的过程)

  4. 释放资源

    public class Demo02OutputStreamWriter {
    public static void main (String[] args) throws IOException {
        write_utf_8();
        write_gbk();
    }

    /**
     * 使用转换流OutputStreamWriter写GBK格式的文件
     */
    private static void write_gbk() throws IOException {
        // 1. 创建一个OutputStreamWriter对象，构造方法中传递字节输出流和指定的编码表名称
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"), "gbk");
        // 2. 使用OutputStreamWriter中的方法write，把字符转换为字节存储到缓冲区中(编码)
        osw.write("你好");
        // 3. 使用OutputStreamWriter中的方法flush，把内存缓冲区中的字节刷新到文件中(使用字节流写字节的过程)
        osw.flush();
        // 4. 释放资源
        osw.close();
    }

    /**
     * 使用转换流OutputStreamWriter写UTF-8格式的文件
     */
    private static void write_utf_8() throws IOException {
        // 1. 创建一个OutputStreamWriter对象，构造方法中传递字节输出流和指定的编码表名称
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"), "UTF-8");
        // 2. 使用OutputStreamWriter中的方法write，把字符转换为字节存储到缓冲区中(编码)
        osw.write("你好");
        // 3. 使用OutputStreamWriter中的方法flush，把内存缓冲区中的字节刷新到文件中(使用字节流写字节的过程)
        osw.flush();
        // 4. 释放资源
        osw.close();
    }
}

2.4、InputStreamReader类

转换流java.io.InputStreamReader，是Reader的子类，是从字节流到字符流的桥梁。
它读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。
继承自父类的共性方法

2.4.1、构造方法

  • InputStreamReader(InputStream in): 创建一个使用默认字符集的字符流。
  • InputStreamReader(InputStream in, String charsetName): 创建一个指定字符集的字符流。
    • InputStream in：字节输入流，用来读取文件中保存的字节
    • String charsetName：指定的编码表名称，不区分大小写

2.4.2、使用步骤

  1. 创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称
  2. 使用InputStreamReader对象中的方法read读取文件
  3. 释放资源

注意：构造方法中指定的编码表名称要和文件的编码相同，否则会发生乱码

public class Demo03InputStreamReader {
    public static void main(String[] args) throws IOException {
        read_utf_8();
        read_gbk();
    }

    /**
     * 使用InputStream读取GBK格式的文件
     */
    private static void read_gbk() throws IOException {
        // 1. 创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称
        InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"), "gbk");
        // 2. 使用InputStreamReader对象中的方法read读取文件
        int len = 0;
        while ((len = isr.read()) != -1) {
            System.out.println((char)len);
        }
        isr.close();
    }

    /**
     * 使用InputStream读取UTF-8格式的文件
     */
    private static void read_utf_8() throws IOException {
        // 1. 创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称
        InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"), "utf-8");
        // 2. 使用InputStreamReader对象中的方法read读取文件
        int len = 0;
        while ((len = isr.read()) != -1) {
            System.out.println((char)len);
        }
        isr.close();
    }
}

2.5、练习：转换文件的编码

将GBK编码的文本文件，转换为UTF-8编码的文本文件。

分析：

  1. 创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称GBK

  2. 创建OutputStreamWriter对象，构造方法中传递字节输出流和指定的编码表名称UTF-8

  3. 使用InputStreamReader对象中的方法read读取文件

  4. 使用OutputStreamWriter对象中的方法write，把读取的数据写入到文件中

  5. 释放资源

    public class Demo04Test {
    public static void main(String[] args) throws IOException {
        // 1. 创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称GBK
        InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"), "gbk");
        // 2. 创建OutputStreamWriter对象，构造方法中传递字节输出流和指定的编码表名称UTF-8
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("text-utf-8.txt"), "utf-8");
        //3. 使用InputStreamReader对象中的方法read读取文件
        int len = 0;
        while ((len = isr.read()) != -1) {
            osw.write(len);
        }
        osw.close();
        isr.close();
    }
}

三、序列化流

3.1、概述

Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的数据、对象的类型和对象中存储的属性等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。
反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。对象的数据、对象的类型和对象中存储的数据信息，都可以用来在内存中创建对象。

3.2、ObjectOutputStream类

java.io.ObjectOutputStream 类，是OutputStream的子类
将Java对象的原始数据类型以流的方式写出到文件，实现对象的持久存储。

3.2.1、构造方法

public ObjectOutputStream(OutputStream out)： 创建一个指定OutputStream的ObjectOutputStream。

  • OutputStream out：字节输出流

3.2.2、特有方法

public final void writeObject (Object obj) : 将指定的对象写出。

3.2.3、使用步骤

  1. 创建一个ObjectOutputStream对象，构造方法中传递字节输出流
  2. 使用ObjectOutputStream对象中的方法writeObject，把对象写入到文件中
  3. 释放资源

注意：

  1. 序列化和反序列化的时候，会抛出NotSerializableException没有序列化异常
  2. 类通过实现Serializable接口启用序列化功能，未实现此接口的类将无法使其任何状态序列化及反序列化
  3. Serializable接口也叫标记型接口
  4. 要进行序列化和反序列化的类必须实现Serializable接口，就会给类添加一个标记
  5. 当我们进行序列化和反序列化的时候，就会检测类上是否有这个标记，如果有就可以序列化和反序列化
  6. 如果没有这个标记，就会抛出NotSerializableException没有序列化异常
public class Demo01ObjectOutputStream {
    public static void main(String[] args) throws IOException {
        // 1. 创建一个ObjectOutputStream对象，构造方法中传递字节输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
        // 2. 使用ObjectOutputStream对象中的方法writeObject，把对象写入到文件中
        oos.writeObject(new Person("小明", 18));
        // 3. 释放资源
        oos.close();
    }
}



public class Person implements Serializable {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

3.3、ObjectInputStream类

ObjectInputStream反序列化流，继承了InputStream
将之前使用ObjectOutputStream序列化的原始数据恢复为对象

3.3.1、构造方法

public ObjectInputStream(InputStream in)： 创建一个指定InputStream的ObjectInputStream。

  • InputStream in：字节输入流

3.3.2、特有方法

  • public final Object readObject () : 读取一个对象。

3.3.3、使用步骤

  1. 创建ObjectInputStream对象，构造方法中传递字节输入流
  2. 使用ObjectInputStream对象中的方法readObject，读取保存对象的文件
  3. 释放资源
  4. 使用读取出来的对象

readObject方法会抛出ClassNotFoundException(Class文件找不到异常)
当不存在对象的class文件时抛出此异常

反序列化的前提：

  1. 该类必须实现java.io.Serializable 接口
  2. 必须存在类对应的class文件
public class Demo02ObjectInputStream {
    public static void main(String[] args) throws Exception {
        // 1. 创建ObjectInputStream对象，构造方法中传递字节输入流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"));
        // 2. 使用ObjectInputStream对象中的方法readObject，读取保存对象的文件
        Object object = ois.readObject();
        // 3. 释放资源
        ois.close();

        System.out.println(object);
        
        Person person = (Person) object;
        System.out.println(person.getName() + person.getAge());
    }
}

3.3.4、瞬态关键字

static

  • 静态优先于非静态加载到内存中(静态优先于对象进入到内存中)
  • 被static修饰的成员变量，不能被序列化，序列化的都是对象，但是static的成员变量被所有对象共享
    transient：瞬态关键字
  • 被transient修饰的成员变量，不能被序列化

3.3.5、反序列化操作

另外，当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个InvalidClassException异常。

比如将实体类中的某个属性权限修饰符修改以后，直接进行反序列化
发生这个异常的原因如下：

  • 该类的序列版本号与从流中读取的类描述符的版本号不匹配
  • 该类包含未知数据类型
  • 该类没有可访问的无参数构造方法

Serializable 接口给需要序列化的类，提供了一个序列版本号。serialVersionUID 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。

3.4、序列化集合

在文件中保存多个对象的时候，可以把多个对象保存到一个集合中，对集合进行序列化和反序列化
分析：

  1. 定义存储Person对象的集合Arraylist

  2. 向Arraylist集合中存储Person对象

  3. 创建一个序列化流ObjectOutputStream对象

  4. 使用ObjectOutputStream对象中的方法writeObject，对集合进行序列化

  5. 创建一个反序列化ObjectInputStream对象

  6. 使用ObjectInputStream对象中的方法readObject，读取文件中保存的集合

  7. 把Object类型的集合转换为ArrayList类型

  8. 遍历ArrayList集合

  9. 释放资源

    public class Demo03Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 1. 定义存储Person对象的集合Arraylist
        List<Person> list = new ArrayList<>();
        // 2. 向Arraylist集合中存储Person对象
        list.add(new Person("张三", 18));
        list.add(new Person("李四", 19));
        list.add(new Person("王五", 20));
        // 3. 创建一个序列化流ObjectOutputStream对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("persons.txt"));
        // 4. 使用ObjectOutputStream对象中的方法writeObject，对集合进行序列化
        oos.writeObject(list);
        // 5. 创建一个反序列化ObjectInputStream对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("persons.txt"));
        // 6. 使用ObjectInputStream对象中的方法readObject，读取文件中保存的集合
        Object o = ois.readObject();
        // 7. 把Object类型的集合转换为ArrayList类型
        ArrayList<Person> list2 = (ArrayList<Person>) o;
        // 8. 遍历ArrayList集合
        for (Person person : list2) {
            System.out.println(person);
        }
        // 9. 释放资源
        ois.close();
        oos.close();
    }
}

四、打印流

4.1、概述

平时我们在控制台打印输出，是调用print方法和println方法完成的，这两个方法都来自于java.io.PrintStream类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式。

4.2、PrintStream类

继承了OutputStream，拥有继承自父类的成员方法
特点：

  • 只负责数据的输出，不负责数据的读取
  • 与其他输出流不同，PrintStream永远不会抛出IOException
  • 有特有的方法，print和println方法，都可以输出任意类型的值

4.3、构造方法

  • public PrintStream(String fileName)： 输出的目的地是一个文件
  • public PrintStream(File file)： 输出的目的地是一个文件路径
  • public PrintStream(OutputStream out)： 输出的目的地是一个输出流

注意：

  1. 如果使用继承自父类的write方法写数据，查看数据的时候会查询编码表 97->a
  2. 如果使用自己特有的方法print/println方法写数据，写的数据原样输出 97->97
public class Demo01PrintStream {
    public static void main(String[] args) throws FileNotFoundException {
        System.out.println("hello world");

        // 创建打印流PrintStream，构造方法中绑定要输出的目的地
        PrintStream ps = new PrintStream("ps.txt");
        // 使用继承自父类的write方法写数据
        ps.write(97);

        // 使用自己特有的方法print/println方法写数据
        ps.println(97);
        // 释放资源
        ps.close();
    }
}

可以改变输出语句的目的地(打印流的流向)
输出语句默认在控制台输出
使用System.setOut(PrintStream out)改变输出的目的地为参数传递的打印流的目的地

public class Demo02PrintStream {
    public static void main(String[] args) throws FileNotFoundException {
        System.out.println("控制台输出");
        PrintStream ps = new PrintStream("目的地是打印流.txt");
        System.setOut(ps);// 输出语句的目的地改变为打印流的目的地
        System.out.println("在打印流的目的地中输出");
        ps.close();
    }
}
Clam.
关注
专栏目录
提高Java IO操作的性能
01-12
提高Java IO操作的性能 虽然抱怨Java程序性能不佳的呼声由来已久，但实际上，如果开发者在整个开发周期内都能够关注性能问题，Java程序完全可以和C/C++程序一样快。本文分析了Java IO应用中一些常见的性能问题。
缓冲流+转换流+序列化流+打印流
sgw101的博客
09-25 737
文章目录一.缓冲流1.1 概述1.2 字节缓冲流1.2.1 构造方法1.2.2 效率测试1.3 字符缓冲流1.3.1 构造方法1.3.2 特有方法1.4 练习:文本排序1.4.1 案例分析1.4.2 案例实现二.转换流2.1 字符编码和字符集2.1.1 字符编码2.1.2 字符集2.2 编码引出的问题2.3 InputStreamReader类2.3.1 构造方法2.3.2 指定编码读取2.4 O...
java缓冲区输入输出流，提高执行效率，拷贝文件
weixin_40228600的博客
10-27 497
缓冲区实现拷贝文件
java-字符缓冲流(提高读写效率)
U12Euphoria的博客
09-27 839
BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途。BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。默认值足够大，可用于大多数用途。使用字符缓冲流读取文件中的数据，排序后再次写到本地文件。
Java中的IO流及其“增强流”
m0_51257288的博客
10-26 231
1 IO流 I代表输入，O代表输出，流代表数据流。 根据数据的流向分为：输入流和输出流。（内存与其他设备之间） 根据数据的类型分为：字节流和字符流。 2 字节流 不管是文件，图片，视频，在计算机中都是以二进制储存，所以字节流可以传输任何文件。 2.1 OutputStream字节输出流 OutputStream是所有字节输出流的父类。常用方法有： public void close();//关闭此输出流并释放与此流相关联的任何系统资源。 public void flush();//刷新此输出流并强制任何缓冲
Java-IO流.docx
02-28
Java的IO流是Java编程中用于处理输入输出操作的核心机制。在Java中，流是一组有序的数据序列，可以是字节或字符，用于在不同数据源之间传输数据。流主要分为两大类：输入流（Input Stream）和输出流（Output Stream...
Java IO commons-io-2.5.jar
04-02
Java IO 是Java编程语言中处理输入/输出流的重要部分，它是连接程序与外部世界的桥梁，允许数据在程序和外部资源之间流动。`commons-io-2.5.jar` 是Apache Commons项目的一部分，它提供了一系列增强和扩展了Java标准...
java-io-decorator.pdf
10-27
Decorator模式在Java IO流中起到了关键作用，它允许在运行时动态地给对象添加新的功能，而无需通过继承的方式创建大量子类。这一模式的核心思想是创建一个装饰者类，它也实现相同的接口，持有被装饰对象的引用，并在...
java-IO.rar_io_java IO
09-21
Java中的IO操作基于流（Stream）的概念，流是数据的序列，可以是字节流或字符流。流的方向分为输入流（Input Stream）和输出流（Output Stream），它们分别用于数据的读取和写入。 2. **基本流类型** - 字节流：...
Io框架 commons-io
01-07
Apache Commons IO 是一个Java库，专门用于处理输入/输出（Io）操作。...无论是在文件系统操作，还是在网络通信，甚至是对象的序列化和反序列化， Commons IO 都能提供便利的功能，极大地增强了Java的IO处理能力。
java io 性能_java io性能分析
weixin_42506884的博客
02-16 443
摘要：本文大多技术围绕调整磁盘文件 I/O,但是有些内容也同样适合网络 I/O 和窗口输出。第一部分技术讨论底层的I/O问题，然后讨论诸如压缩，格式化和串行化等高级I/O问题。然而这个讨论没有包含应用设计问题，例如搜索算法和数据结构，也没有讨论系统级的问题，例如文件高速缓冲。Java语言采取两种截然不同的磁盘文件结构。一个是基于字节流，另一个是字符序列。在Java 语言中一个字符有两个字节表示，而...
深入理解Java NIO：提高I/O操作性能
最新发布
crud的xiaodu
02-17 384
Java NIO提供了一种与传统I/O模型基本不同的I/O操作方式。它支持面向缓冲区的I/O处理、非阻塞I/O操作，以及选择器用于多路复用I/O通道。这些特性使NIO成为构建高性能I/O操作、尤其是需要高速读写、大量并发连接处理的网络应用的理想选择。
零拷贝：Java中提高IO性能的秘密武器
m0_49151953的博客
04-19 192
接下来，我们使用transferFrom方法将源通道中的数据直接传输到目标通道中，从而实现了零拷贝。在传统的IO操作中，数据需要从内核缓冲区拷贝到用户缓冲区，然后再从用户缓冲区拷贝到网络缓冲区。在Java中，IO操作是一个非常重要的部分，但是IO操作通常是应用程序的性能瓶颈之一。在Java中，我们可以使用Java NIO（New IO）来实现零拷贝。Java NIO提供了一种新的IO操作方式，它可以在没有中间缓冲区的情况下直接从通道中读取或写入数据。使用零拷贝可以减少CPU的使用，提高IO操作的效率。
加速文件读写，JAVA IO 效率提升之道
devil_wing的专栏
09-24 1058
针对操作系统中的设备驱动程序、文件系统以及网络协议堆栈而出现的各种零拷贝技术极大地提升了特定应用程序的性能，并且使得这些应用程序可以更加有效地利用系统资源。这种性能的提升就是通过在数据拷贝进行的同时，允许 CPU 执行其他的任务来实现的。MMAP就是将用户的虚拟地址空间映射到内核的数据地址空间，从而避免用户空间和内核空间的数据复制。sendfile用于将文件发送到socket的场景，比如经典的下载文件场景，就可以通过sendfile系统调用实现高效的文件下载。所以，所谓的零拷贝，指的就是CPU的零拷贝。
java 强制转换 效率_Java 性能优化：35 个小细节，让你提升 Java 代码的运行效率...
weixin_39807954的博客
02-13 747
代码优化细节1、尽量指定类、方法的final修饰符2、尽量重用对象3、尽可能使用局部变量4、及时关闭流5、尽量减少对变量的重复计算6、尽量采用懒加载的策略，即在需要的时候才创建7、慎用异常8、不要在循环中使用try…catch…，应该把其放在最外层9、如果能估计到待添加的内容长度，为底层以数组方式实现的集合、工具类指定初始长度10、当复制大量数据时，使用System.arraycopy()命令11...
提升Java代码的运行效率小技巧
qq_43842093的博客
03-18 1296
我认为，代码优化的最重要的作用应该是：**避免未知的错误。**在代码上线运行的过程中，往往会出现很多我们意想不到的错误，因为线上环境和开发环境是非常不同的，错误定位到最后往往是一个非常小的原因。然而为了解决这个错误，我们需要先自验证、再打包出待替换的class文件、暂停业务并重启，对于一个成熟的项目而言，最后一条其实影响是非常大的，这意味着这段时间用户无法访问应用。因此，在写代码的时候，从源头开始注意各种细节，权衡并使用最优的选择，将会很大程度上避免出现未知的错误，从长远看也极大的降低了工作量。代码优化的目
Java--IO流
weixin_64274578的博客
07-03 814
Java IO流
java 性能优化：35 个小细节，让你提升 java 代码的运行效率
weixin_JimZemlin的博客
07-12 2784
代码优化 ，一个很重要的课题。可能有些人觉得没用，一些细小的地方有什么好修改的，改与不改对于代码的运行效率有什么影响呢？这个问题我是这么考虑的，就像大海里面的鲸鱼一样，它吃一条小虾米有用吗？没用，但是，吃的小虾米一多之后，鲸鱼就被喂饱了。代码优化也是一样，如果项目着眼于尽快无BUG上线，那么此时可以抓大放小，代码的细节可以不精打细磨；但是如果有足够的时间开发、维护代码，这时候就必须考虑每个可以优化的细节了，一个一个细小的优化点累积起来，对于代码的运行效率绝对是有提升的。代码优化的目标是减小代码的体积提高代码
缓冲流的使用
一步一脚印的博客
07-06 609
缓冲流： Java缓冲流本身并不具有IO流的读取与写入功能，只是在别的流(节点流或其他处理流)上加上缓冲功能提高效率，就像是把别的流包装起来一样，因此缓冲流是一种处理流(包装流)。 当对文件或者其他数据源进行频繁的读写操作时，效率比较低，这时如果使用缓冲流就能够更高效的读写信息。因为缓冲流是先将数据缓存起来，然后当缓存区存满后或者手动刷新时再一次性的读取到程序或写入目的地。 BufferedInputStream和BufferedOutputStream这两个...
Android应用设计与Java IO流
"Android应用程序设计I-Java IO流" 在Android应用程序设计中，理解并掌握Java的IO流是至关重要的，因为这关乎到如何在应用中有效地读取、写入和处理数据。Java IO流提供了在不同数据源之间传输数据的机制，包括设备...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值