41讲 高级流（缓冲流、转换流、序列化流、打印流、压缩流）

最新推荐文章于 2024-10-16 10:13:45 发布
最新推荐文章于 2024-10-16 10:13:45 发布
阅读量108 收藏
点赞数
分类专栏： Java（无图省流版） 文章标签： java jvm java-ee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lis0bit/article/details/129630227
版权
本文介绍了Java中的缓冲流，包括字节缓冲流和字符缓冲流，以及它们如何提高读写性能。接着讨论了转换流的作用，特别是InputStreamReader和OutputStreamWriter在字符集转换中的应用。然后详细阐述了对象的序列化与反序列化过程，以及处理序列化问题的策略。最后，讲解了打印流的概念和使用，以及如何重定向输出语句。
摘要由CSDN通过智能技术生成

缓冲流

1 缓冲流概述

  • 缓冲流自带长度为8192的缓冲区。字节缓冲流是8k，字符缓冲流是16k。

  • 缓冲流可以显著提高字节流的读写性能，对于字符流的提升不明显，而是带来了两个特有的方法。

体系结构

在这里插入图片描述

2 字节缓冲流

构造方法

方法说明
public BufferedInputStream(InputStream in)把基本字节输入流包装成缓冲流
public BufferedOutputStream(OutputStream out)把基本字节输出流包装成缓冲流

注意

  • 缓冲流对象的默认缓冲区大小8192，可手动指定。
  • 真正“干活”的还是基本流，缓冲流仅提供一个缓冲区
  • 关闭流的时候只需要关闭缓冲流，缓冲流底层会关闭基本流。
public static void main(String[] args) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\test\\aaa.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\test\\bbb.txt"));
        byte[] bytes = new byte[10];
        int len;

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

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

3 字符缓冲流

构造方法

方法说明
public BufferedReader(Reader r)把基本字符输入流包装成缓冲流
public BufferedWriter(Writer w)把基本字符输出流包装成缓冲流

特有方法

方法说明来自类
String readLine()一次读取一行数据，没有数据返回nullBufferedReader
void newLine()各操作系统通用换行BufferedWriter

注意

readLine方法

  • 读到换行符会停止，所以一次读一行数据。
  • 但该方法不会将换行符读取到内存中
public static void main(String[] args) throws IOException {
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\test\\ccc.txt"));
        bw.write("第一行");    //第一行
        bw.newLine();             //换行
        bw.write("第二行");    //第二行
        bw.close();

        BufferedReader br = new BufferedReader(new FileReader("D:\\test\\ccc.txt"));
        String readLine = br.readLine();
        System.out.println(readLine);
        br.close();     //第一行
    }

转换流

1 转换流简述

可以让字节流附加上字符流的特性。只有字符流有转换流。

作用

  • （已淘汰）使用指定字符集读写。可以根据字符集一次读取多个字符，读取数据不会乱码。
  • 让字节流使用字符流中的方法。

2 InputStreamReader

把字节流转换为字符流读入。

2.1 构造方法

方法说明
public InputStreamReader(InputStream in)把基本字符输入流包装成转换流
public InputStreamReader(InputStream in, String charsetName)把基本字符输入流包装成指定字符集的转换流

2.2 使用指定字符集读取数据

读取使用GBK编码的文件

private static void read1() throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("src\\do30ConvertStream\\text.txt"));//使用默认字符集UTF-8
        int b;
        while ((b = isr.read()) != -1) {
            System.out.print((char) b);
            //乱码 �������
        }

        isr.close();
    }

可以创建指定字符集的转换流

private static void read2() throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("src\\do30ConvertStream\\text.txt"), "GBK");//指定GBK字符集
        int b;
        while ((b = isr.read()) != -1) {
            System.out.print((char) b);     //你好世界
        }

        isr.close();
    }

上述方法已在JDK11被淘汰，JDK11以后可使用FileReader中的构造方法：FileReader(File file, Charset charset)//创建指定字符集的字符输入流对象

private static void read3() throws IOException {
        FileReader fr = new FileReader("src\\do30ConvertStream\\text.txt", Charset.forName("GBK"));//指定GBK字符集
        int b;
        while ((b = fr.read()) != -1) {
            System.out.print((char) b);     //你好世界
        }
        fr.close();
    }

2.3 使用字节流读取一行中文

字节流读取中文会出现乱码，且字节流中没有读取一整行数据的方法。所以可以使用转换流，让字节流拥有字符流的特性。

关键代码：BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("路径")));

private static void test() throws IOException {
        //普通的字节流
        FileInputStream fis = new FileInputStream("src\\do30ConvertStream\\newText.txt");
        //转换流：将字节流转换为字符流，使其可以读取中文不乱码
        InputStreamReader isr = new InputStreamReader(fis);
        //缓冲流：可以一次读取一行数据
        BufferedReader br = new BufferedReader(isr);

        String s = br.readLine();
        System.out.println(s);
        br.close();
    }

3 OutputStreamWriter

把字符流转换为字节流写出。

3.1 构造方法

方法说明
OutputStreamWriter(OutputStream out)把基本字符输出流包装成转换流
OutputStreamWriter(OutputStream out, String charsetName)把基本字符输出流包装成指定字符集的转换流

3.2 使用指定字符集写出数据

使用GBK编码写文件

private static void writer1() throws IOException {
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("src\\do30ConvertStream\\text.txt"), "GBK");
        osw.write("你好世界");
        osw.close();
    }

上述方法已在JDK11被淘汰，JDK11以后可使用FileWriter中的构造方法：FileWriter(File file, Charset charset) //创建指定字符集的字符输出流对象(JDK11)

private static void writer2() throws IOException {
        FileWriter fw = new FileWriter("src\\do30ConvertStream\\text.txt", Charset.forName("GBK"));
        fw.write("你好世界");
        fw.close();
    }

序列化流

1 序列化流

序列化流也叫对象操作输出流，可以将Java中的对象写到本地文件中。只有字节流有序列化流。

作用

将对象信息以“看不懂”的形式存到本地文件，当我们不希望一些数据能被修改时，可以使用。

2 序列化流方法

构造方法说明
ObjectOutputStream(OutputStream out)将字节输出流包装成序列化流
特有方法说明
final void writeObject(Object obj)将对象序列化到文件中

3 序列化操作

想让对象序列化，就必须先让该对象JavaBean类实现 Serializable 接口。

如果没有实现 Serializable 接口，会抛出异常 NotSerializableException 。

Serializable 接口时一个标记型接口 ，里面没有抽象方法，只是用来标识该JavaBean类可以被序列化。

import java.io.Serializable;

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

    //省略标准JavaBean
}

private static void test() throws IOException {
        //1 创建对象
        Student s = new Student("张三", 20);
        //2 创建序列化对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("src\\do31ObjectStream\\text.txt"));
        //3 序列化
        oos.writeObject(s);
        //4 关流
        oos.close();
    }

运行结果

�� sr ObjectStream.Studentz���It�� I ageL namet Ljava/lang/String;xp   t 张三

4 反序列化流

反序列化流也叫对象操作输入流。与序列化流对应，反序列化流可以将序列化到本地文件中的对象读取到程序中。

5 反序列化流方法

构造方法说明
ObjectInputStream(InputStream in)将字节输入流包装成反序列化流
特有方法说明
final void readObject(Object obj)将文件中的对象反序列化到程序中

6 反序列化操作

反序列化后的对象是Object类型，需要进一步强转成我们需要的类型。

private static void test() throws IOException, ClassNotFoundException {
        //1 创建反序列化对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("src\\do31ObjectStream\\text.txt"));
        //2 反序列化，并强转
        Student s = (Student) ois.readObject();
        //3 使用对象
        System.out.println(s);
        //4 关流
        ois.close();
    }

运行结果

Student{name = 张三, age = 20}

7 常见问题及操作

7.1 序列号前后不一致

问题描述

当序列化流将对象写到文件后，修改了对象的JavaBean类。再使用反序列化流读取数据就会有异常InvalidClassException。

原因

序列化流写入对象的同时，也会将该对象在这一刻的所有信息封装成的序列号一同写入文件。而修改JavaBean类，会使该对象的序列号发生改变。当反序列化流读取数据时发现两次序列号不一致 ，就会抛出异常。

处理思路

  • 固定序列号 ：在JavaBean类中手动定义序列号。

注意！一定要在JavaBean类中的所有属性、方法等全部做完之后 ，再生成序列号！

序列号固定格式： private static final long serialVersionUID = ?

操作方法 1： 在实现了InvalidClassException的JavaBean类中手动书写序列号

import java.io.Serializable;

public class Student implements Serializable {
    // 手动书写序列号
    private static final long serialVersionUID = 1L;
    
    private String name;
    private int age;

    //省略标准JavaBean
}

操作方法 2： IDEA自动生成

首先需要设置IDEA，让其可以自动生成：

  1. 打开IDEA的设置

  2. 在设置中搜索 Serializable

  3. 勾选如下两个选项，应用即可

在这里插入图片描述

设置完成后，在JavaBean类中可以看到类名被“标注”了。

将鼠标悬停在类名上，会有弱警告：“这个类没有定义序列号”。

在这里插入图片描述

单击类名，按下 alt + enter ，选择如下解决方案，IDEA就自动生成了一个序列号

在这里插入图片描述

在这里插入图片描述

7.2 序列化跳过某属性

需求描述

不想将JavaBean类中的某些属性序列化到文件。用户的一些敏感信息（如密码，银行卡号等），为了安全起见，不希望在网络操作中被传输。

实现方法

给不想序列号的属性添加 transient 关键字。

关键字

transient 瞬态的

  1. 一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。
  2. transient关键字只能修饰变量，而不能修饰方法和类。
  3. 如果是自定义类变量，则该类需要实现Serializable接口。
  4. 被transient关键字修饰的变量不再能被序列化，而静态变量不论是否被transient修饰，均不能被序列化。
public class Student implements Serializable {
    @Serial
    private static final long serialVersionUID = 8841963093773026223L;
    private String name;
    
    //transient修饰的age属性
    private transient int age;
    
    //省略标准JavaBean
}

重新运行上述的序列号和反序列化代码。

运行结果

Student{name = 张三, age = 0}

age的值为默认初始值0，可见age属性没有参与序列化操作。

7.3 反序列化多个对象

问题描述

当序列化多个对象后，想将对象再反序列化出来，可能会有“不知道具体序列化了多少个对象”的问题。而readObject(Object obj)方法读取不到数据后会抛出异常EOFException，所有不能使用循环读取。

解决方法

ArrayList集合实现了Serializable接口。将要序列化的对象储存到ArrayList集合中，再序列化ArrayList集合，反序列化时只需要读取ArrayList集合即可。

import java.io.*;
import java.util.ArrayList;

public class ObjectStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        oos();
        ois();
    }

    private static void oos() throws IOException {
        Student s1 = new Student("张三", 20);
        Student s2 = new Student("李四", 21);
        Student s3 = new Student("王五", 22);

        //1 将要序列化的对象储存到ArrayList集合中
        ArrayList<Student> list = new ArrayList<>();
        list.add(s1);
        list.add(s2);
        list.add(s3);

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("src\\do31ObjectStream\\text.txt"));
        // 2 序列化ArrayList集合
        oos.writeObject(list);
        oos.close();
    }

    private static void ois() throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("src\\do31ObjectStream\\text.txt"));

        //3 反序列化ArrayList集合
        ArrayList<Student> studentArrayList = (ArrayList<Student>) ois.readObject();
        for (Student s : studentArrayList) {
            System.out.println(s);
        }
        ois.close();
    }
}

class Student implements Serializable {
    @Serial
    private static final long serialVersionUID = 8841963093773026223L;
    private String name;
    private int age;
    
    //省略标准JavaBean
}

运行结果

Student{name = 张三, age = 20}
Student{name = 李四, age = 21}
Student{name = 王五, age = 22}

打印流

1 打印流概述

  • 打印流只能操作文件目的地，不能操作数据源。即打印流只能写，不能读。

  • 打印流可以将数据原样写出。比如写’97’，在文件中写入的就是’97’而不是’a’

  • 可以自动刷新，自动换行。打印流打印数据 = 写出 + 换行 + 刷新

2 字节打印流

构造方法

方法说明
PrintStream(OutputStream out / File f / String Pathname)关联字节输出流/文件对象/文件路径
PrintStream(OutputStream out, boolean autoFlush)自动刷新与否
PrintStream(String fileName, Charset c)指定字符编码
PrintStream(OutputStream out, boolean autoFlush, String encoding / Charset c)自动刷新与否，并指定字符编码
  • 即使字节打印流关联的不是字节输出流，构造方法底层也会先跟据给定的文件对象或路径创建字节输出流对象，再关联字节输出流。
  • 字节流底层没有缓冲区，所以自动刷新与否都一样，都是直接写入文件。

特有方法

方法说明
void println(Xxx x)原样写出数据。自动刷新、自动换行
void print(Xxx x)原样写出数据。不换行
void printf(String format, Object... args)原样写出数据。可以使用占位符、不换行

占位符： 如 %d(整形)、 %s(字符串占位符)、 %f(浮点数占位符)

private static void test() throws FileNotFoundException {
    	//创建字节打印流对象
        PrintStream ps = new PrintStream(new FileOutputStream("src\\do32printStream\\text.txt"), true, Charset.forName("UTF-8"));

    	//原样写出数据
        ps.println("99");
        ps.print("a");
        ps.printf("%s World", "Hello");

        ps.close();
    }

运行结果

//text.txt中的内容
99
aHello World

3 字符打印流

构造方法

方法说明
PrintWriter(Writer out / File f / String Pathname)关联字符输出流/文件对象/文件路径
PrintWriter(Writer out, boolean autoFlush)关联字符输出流，自动刷新与否
PrintWriter(OutputStream out, boolean autoFlush)关联字节输出流，自动刷新与否
PrintWriter(String fileName, Charset c)指定字符编码
PrintWriter(OutputStream out, boolean autoFlush, Charset c)关联字节输出流，自动刷新与否，并指定字符编码

字符流底层有缓冲区，想要自动刷新需要手动开启，且只有关联字符输出流或字节输出流时才能开启自动刷新。

特有方法

方法说明
void println(Xxx x)原样写出数据。自动刷新、自动换行
void print(Xxx x)原样写出数据。不换行
void printf(String format, Object... args)原样写出数据。可以使用占位符、不换行
private static void test() throws IOException {
    	//创建字符打印流对象
        PrintWriter pw = new PrintWriter(new FileWriter("src\\do32printStream\\text.txt"));
    
    	//原样写出数据
        pw.println("99");
        pw.print("a");
        pw.printf("%s World", "Hello");

        pw.close();
    }

运行结果

//text.txt中的内容
99
aHello World

4 输出语句原理

输出语句其实就是一个特殊的字节打印流。

该打印流在虚拟机启动时自动创建。其默认写出的位置不是某个文件，而是控制台。

public final class System {
    public static final PrintStream out = null;
}

System.out 就是创建一个PrintStream对象，而println()是PrintStream类中的方法。

private static void test() {
        PrintStream ps = System.out;
        ps.println("HelloWorld");
    }

在这里插入图片描述

如果我们提前关闭该流，控制台将不会再打印数据。

在这里插入图片描述

5 输出语句重定向

可以改变虚拟机的输出语句流的位置，让输出语句不再输出到控制台，而是写入文件。

private static void test() throws FileNotFoundException {
        System.out.println("第一条输出语句");
        PrintStream ps = new PrintStream("D:\\text.txt");
    	//重定向
        System.setOut(ps);
        System.out.println("第二条输出语句");
    }

在控制台中只输出了第一条语句

在这里插入图片描述

在”D:\text.txt“中，有第二条输出语句

在这里插入图片描述

压缩流

1 压缩流概述

压缩流用于将文件/文件夹压缩为.zip 文件。解压缩流用于将.zip 文件解压成普通文件。

压缩流继承于字节流。

继承体系

在这里插入图片描述

2 压缩流

压缩流只能将文件/文件夹压缩为 .zip 类型。

压缩的本质就是把每一个文件/文件夹封装成ZipEntry对象放到 .zip 文件夹中。

2.1 构造方法

方法说明
ZipOutputStream(OutputStream out)根据字节输出流创建压缩流对象
ZipOutputStream(OutputStream out, Charset charset)根据字节输出流创建压缩流对象，可指定字符集

2.2 特有方法

方法说明
void putNextEntry(ZipEntry e)编写新的ZIP文件条目并将流定位到条目数据的开头。 如果仍然有效，则关闭当前条目。 如果没有为条目指定压缩方法，将使用默认压缩方法，如果条目没有设置修改时间，则使用当前时间。
void closeEntry()关闭当前 ZIP 条目并定位流以读取下一个条目。

2.3 压缩

ZipEntry的构造方法

ZipEntry的构造方法说明
ZipEntry(String name)根据路径创建ZipEntry对象，如果路径中某个文件夹不存在，会创建一个该文件夹
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class zipOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //需要压缩的文件夹
        File src = new File("D:\\test");
        //压缩后的文件夹的父级路径
        File destParentFile = src.getParentFile();	// test
        //压缩后的文件夹的完整路径
        File dest = new File(destParentFile, src.getName() + ".zip"); // D:\\test.zip

        toZip(src, dest);
    }

    private static void toZip(File src, File dest) throws IOException {
        //1.创建压缩流
        ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(dest));
        //2.获取需要压缩的文件夹里的每一个文件，将其变成ZipEntry对象，放到压缩包中
        String name = src.getName();
        toZipEntry(src, zos, name);
        //3.释放资源
        zos.close();
    }

    /**
     * 获取需要压缩的文件夹里的每一个文件，将其变成ZipEntry对象，放到压缩包中
     * @param src  数据源
     * @param zos  压缩流
     * @param name 压缩包内部的路径
     */
    private static void toZipEntry(File src, ZipOutputStream zos, String name) throws IOException {
        //1.进入src文件夹并遍历
        File[] files = src.listFiles();
        for (File file : files) {
            if (file.isFile()) {
                //2.如果是文件，将其变成ZipEntry对象，放到压缩包中
                //创建ZipEntry对象，用来表示需要压缩的每一个文件/文件夹
                ZipEntry entry = new ZipEntry(name + "\\" + file.getName());
                //把ZipEntry对象放到压缩包中
                zos.putNextEntry(entry);
                //将文件中的数据写到压缩包对应的文件中
                FileInputStream fis = new FileInputStream(file);
                int b;
                while ((b = fis.read()) != -1) {
                    zos.write(b);
                }
                fis.close();
                zos.closeEntry();
            } else {
                //3.如果是文件夹，递归
                toZipEntry(file, zos, name + "\\" + file.getName());
            }
        }
    }
}

3 解压缩流

解压缩流只能解压 .zip 的压缩文件/文件夹。

压缩包里的每一个文件都是ZipEntry对象，

解压的本质就是把每一个ZipEntry对象按照层级拷贝到本地的另一个文件夹中。

3.1 构造方法

方法说明
ZipInputStream(InputStream in)根据字节输入流创建解压缩流对象
ZipInputStream(InputStream in, Charset charset)根据字节输入流创建解压缩流对象，可指定字符集

3.2 特有方法

方法说明
ZipEntry getNextEntry()获取下一个ZipEntry对象，如果没有返回null
void closeEntry()关闭当前 ZIP 条目并定位流以读取下一个条目。

3.3 解压

/**
     * 解压缩
     * @param src  数据源
     * @param dest 目的地
     */
    private static void unzip(File src, File dest) throws IOException {
        //1.创建解压缩流对象
        ZipInputStream zis = new ZipInputStream(new FileInputStream(src));

        //2.
        ZipEntry entry;
        while ((entry = zis.getNextEntry()) != null) {
            System.out.println(entry);
            if (entry.isDirectory()) {
                //文件夹：在目的地创建一个同样的文件夹
                File file = new File(dest, entry.getName());
                file.mkdirs();
            } else {
                //文件：拷贝到目的地的相同层级下
                FileOutputStream fos = new FileOutputStream(new File(dest, entry.getName()));
                int b;
                while ((b = zis.read()) != -1) {
                    fos.write(b);
                }
                fos.close();
                //关闭当前 ZIP 条目并定位流以读取下一个条目
                zis.closeEntry();
            }
        }
        zis.close();
    }
Lis0bit
关注
专栏目录
【Java基础知识 36】选择最适合自己的NIO， 一探流技术
学Java，找哪吒
08-15 3667
本文为您讲解了 Java I/O、NIO 以及其他一些流的基本概念、用法和区别。Java I/O 和 NIO 可以完成很多复杂的输入输出操作，包括文件操作、网络编程、序列化等。其他流技术可以实现压缩、读写字节数组等功能。在进行开发时，根据具体需求选择不同的流技术可以提高程序效率和开发效率。
【Java IO流】缓冲流和对象流的解析和应用实例
StuLearn-LJC的博客
03-17 1257
Java 中的高级流指的是建立在基本字节流或字符流之上的流，它们提供了更高级别的功能以简化 I/O 操作。除缓冲流和对象流外，常见的高级流还有：数据流、打印流、压缩流、转换流等。
java之IO篇高级流——缓冲流、转化流、序列化流、打印流、压缩流
2202_75483664的博客
08-05 993
上一篇IO流就介绍了File和基本流，这节介绍好用的高级流。还有IO流的心得：随用随创建，什么时候不用什么时候关闭目录前言一、缓冲流1.体系图2.字节缓冲流（1）用法（2）底层原理3.字符缓冲流（1）用法二、转换流1.作用2.示例三、序列化流和反序列化流1.序列化流ObjectOutputStream2.反序列化流ObjectInputStream3.关键细节四、打印流1.字节打印流PrintStream2.字符打印流PrintWriter3.和标准输出流的关系五、压缩流和解压缩流。
【JavaSE系列】IO流
记录了个人在学习生活中的所思所想，在反思自己的同时希望也能够帮到你
09-28 1089
在Java编程中，输入输出（I/O）操作是处理数据流的核心部分。无论是从文件读取数据、将数据写入到磁盘，还是通过网络进行通信，都需要使用I/O流来实现。Java提供了丰富的I/O流类库，它们不仅能够高效地处理各种类型的数据，还提供了灵活的方式来装饰和扩展这些基本功能。本篇博客旨在介绍Java I/O流的基础知识，包括其分类、体系结构以及如何使用不同类型的流来完成日常开发中的常见任务。IO流指的是程序中数据的流动。数据可以从内存流动到硬盘，也可以从硬盘流动到内存。
Java文件处理io流
weixin_45203607的博客
03-31 1430
java文件处理io流 File 文件操作 方法 简介 boolean exists() 判断文件和目录是否存在 boolean isFile() 判断是否是文件 boolean isDirectory() 判断是否是目录 String getPath() 返回当前路径 String getAbsolutePath() 返回此对象的绝对路径 String getName 返回文件名称 String getParent() 返回路径的上
21 Java 中的缓冲流、转换流、序列化流、打印流
朱古力的博客
05-14 349
文章目录缓冲流、转换流、序列化流、打印流一、缓冲流1. 缓冲流的原理2. BufferedOutputStream字节缓冲输出流3. BufferedInputStream字节缓冲输入流4. BufferedWriter字符缓冲输出流5. BufferedRead字符缓冲输入流二、转换流1. OutputStreamWriter2. InputStreamReader三、序列化流1. 序列化与反序列化的概述2. 对象的序列化流3. 对象的反序列化流4. 瞬态关键字5. 反序列化的InvalidClassEx
Java IO流进阶之常用流（二）
qq_41590178的博客
06-24 2833
Scanner类 Scanner类作为专门的输入数据类，不仅能完成输入数据操作还能方便 对输入数据进行验证。 Scanner类的常用方法 public Scanner(File source) 从文件这接收数据 public Scanner(InputStream source) 从指定的字节输入流中接收内容 public boolean hasNext(Pattern ...
Java必备基础十六——输入与输出流相关类详细介绍
Pandafz的博客
09-29 2755
真正能让你走远的，都是自律、积极和勤奋
JavaIO流详解
热门推荐
itqcyyl的博客
08-09 2万+
转载：https://www.cnblogs.com/LittleHann/p/3678685.html Java输入、输入、IO流 类层次关系梳理 本文主要关注在Java编程中涉及到的IO相关的类库、方法。以及对各个层次(抽线、接口继承)的流之间的关系进行梳理   相关学习资料 http://baike.baidu.com/view/1007958.htm?noadapt=1 h...
流与反射
Float Dream
07-05 1815
#File ```java public class IO1 {     public static void main(String[] args) {         String path = "e:" + File.separator +"testJava"; //File.separator是根据系统产生相应的斜杠（为了跨平台），设置文件夹路径和名字         F
IOstream_javaIOl流_
10-02
- 对象序列化：ObjectInputStream和ObjectOutputStream允许将Java对象转换为字节流进行持久化存储或网络传输。 - 数据操作：DataInputStream和DataOutputStream提供方法读写基本数据类型，如int、float等。 - 复用流...
Java-IO流高级-例题 & 例题源码 & PPT教学文档（黑马程序员详细版）.rar
07-24
对象流如ObjectInputStream和ObjectOutputStream，支持序列化和反序列化对象，使得对象可以被保存到文件或在网络上传输。 6. **过滤流（Filter Stream）** 过滤流可以附加在其他流上，提供额外的功能，如数据校验...
IO流面试题共5页.pdf.zip
10-28
**流的使用**：涉及如何使用FileInputStream和FileOutputStream进行文件操作，使用BufferedReader和BufferedWriter进行缓冲，使用DataInputStream和DataOutputStream处理基本数据类型，以及如何使用...
11 Java文件处理之写入、读取：IO流（中）：高级流（缓冲流、转换流、序列化流和反序列化流、打印流）
smalltorch的博客
09-17 378
前面学FileReader和FileWriter字符流：对于中文只能处理当前平台的编码方式进行编码和解码，不能指定编码格式进行编码解码。这个指定编码的功能，在本节的高级流（转换流）上就会得到处理。另外，高级流都是在上节的四中基本流上面进一步封装而来的，可以说前面基本流是他们的爸爸。缓冲流（提供缓冲区，加快读取写入速度，减少和硬盘交互次数）转换流（可以指定编码格式）基本流—>缓冲流转换流（都是字符流）序列化流和反序列化流（都是字节流）打印流（不能读，只能写，只有输出流）
【Java学习】第28节：IO流 (缓冲流、转换流、打印流、打印流)&序列化
m0_46013789的博客
05-23 1095
Java是一种广泛使用的编程语言，由Sun Microsystems（现在是Oracle Corporation）首次推出。它是一种跨平台的编程语言，意味着您可以编写一次代码，然后在多个不同的计算机系统上运行，而无需对其进行修改。Java被广泛用于开发各种类型的应用程序，包括企业级应用、移动应用、Web应用、游戏等。
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 228
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 286
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
2024.10月12日--- SpringMVC异常处理
whisper_Java 的博客
10-12 910
*** 用户【】 IP[]* 在【时间】* 操作【Controller.find】 发生如下异常*/@OverrideSystem.out.println("---------执行了自定义异常处理器------------");// 根据不同的异常类型，设置不同的响应状态码// 可以添加更多的自定义处理逻辑//}else {// 记录日志或其他处理逻辑// 可以将异常信息放入模型中供视图展示。
Backend - Java 基础
是萝卜干呀的博客
10-11 835
知识量决定了未来能走多远
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值