Java IO流

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量137 收藏
点赞数 1
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/super1223/article/details/117159708
版权

目录

序列化和反序列化

序列化： 将数据结构或对象转换成二进制字节流的过程。

反序列化：将在序列化过程中所生成的二进制字节流的过程转换成数据结构或者对象的过程。

序列化和反序列化的作用：将数据结构或对象状态转换成可取用格式（例如存成文件，存于缓冲，或经由网络中发送）的二进制字节流。

1

  • 使用对象流读写引用类型的数据，需要相应类实现Serializable接口，并且有些需要为其指定序列化ID。

  • 不需要序列化的属性和方法可以使用关键字transient修饰，也可以使用static，也不会被序列化。

File类

File类用来代表文件和文件夹。主要作用有两个：获取文件或者文件夹的属性； 实现对文件、文件夹的创建和删除。

File类的常用方法

操作文件：

createNewFile()：创建文件

exists()：判断文件是否存在

delete()：删除文件

length() 获取文件的大小（字节数）

getName()：获取文件名

getAbsolutePath()：获取文件的绝对路径

renameTo(File dest)：重命名文件夹

isFile()：判断是否是一个文件

isHidden()：判断是否是一个隐藏文件

getParent()：获得父目录名

lastModified()：获取最后一次被修改的时间。

static File[] listRoots()列出所有的根目录

list() 返回目录下的文件或者目录名

listFiles() 返回目录下的文件或者目录对象

list(FilenameFilter filter)返回指定当前目录中符合过滤条件的子文件或子目录。

listFiles(FilenameFilter filter)返回指定当前目录中符合过滤条件的子文件或子目录。

操作文件夹：

mkdir()：创建一个单级文件夹

mkdirs()：创建一个多级文件夹

exists()：判断文件夹是否存在

length() 获取文件的大小（字节数）

getName()：获取文件夹名

isDirectory()：判断是否是个目录

isHidden()：判断是否是一个隐藏文件夹

getAbsolutePath()：获取文件夹的绝对路径

lastModified()：获取最后一次被修改的时间。

IO流的分类

  • 按照流的流向分，可以分为输入流和输出流；
  • 按照操作单元划分，可以划分为字节流和字符流；
  • 按照流的角色划分为节点流和处理流。

所有的IO流都是基于这四大抽象类来进行衍生的。

  • InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
  • OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。

所谓输入流和输出流，如何理解呢？

它们的概念可以以程序为中心来定义，很好理解，从源目标输入到程序中，就是输入流，从程序中输出到目的目标，就是输出流。而字节和字符则是根据处理单元来决定的字节流是以byte为单位处理的，而字符流是以char为单位进行处理的。

image-20210807203002794

节点流和处理流

节点流是可以直接操作数据的流，而处理流更多的是在节点流的基础上对数据的处理进行性能优化或者功能拓展。

image-20210807203230222

操作方式划分

687474~1

操作对象划分

687474~2

经典面试题

不管是文件读写还是网络发送接收，信息的最小存储单元都是字节，那为什么 I/O 流操作要分为字节流操作和字符流操作呢？

字符流是由 Java 虚拟机将字节转换得到的，问题就出在这个过程还算是非常耗时，并且，如果我们不知道编码类型就很容易出现乱码问题。所以， I/O 流就干脆提供了一个直接操作字符的接口，方便我们平时对字符进行流操作。如果音频文件、图片等媒体文件用字节流比较好，如果涉及到字符的话使用字符流比较好。

IO流的使用场景

  1. 键盘输入和输出就是使用IO流来实现的。
  2. 数据的持久化要使用IO流来做
  3. 网络通信需要使用IO流

而这些IO流分别能处理的类型如下：

  • FileInputStream和FileOutputStream：处理字节文件
  • FileReader和FileWriter：处理字符文件
  • ByteArrayInputSteam和ByteArrayOutputStream：处理字节数组
  • CharArrayInputStream和CharArrayOutputStream：处理字符数组
  • BufferedInputStream和BufferedOutputStream：对字节流进行缓存性能优化，增加读写效率。
  • BufferedReader和BufferedWriter：对字符流进行缓存性能优化，增加读写效率
  • DateInputStream和DateOutputStream：以字节流为操作单位进行操作基本数据类型和String类型
  • ObjectInputStream和ObjectOutputStream：以字节流为操作单位操作对象类型。
  • InputStreamReader和OutputStream：将字节流转换为字符流
  • PrintStream和PrintWriter：打印流。

文件流

字节流

FileInputStream和FileOutputStream是字节流，是以字节为单位来处理流的， 数据源和目的地是文件。

可以使用简单的文件拷贝来看它们的基本使用方式。

@Test
void contextLoads() {
    FileInputStream fis = null;
    FileOutputStream fos = null;
    try {
        fis = new FileInputStream("d:/1.txt");
        fos = new FileOutputStream("d:/2.txt");
        int b = 0;
        while ((b = fis.read()) != -1) {
            fos.write(b);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            fis.close();
            fos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


}

使用缓冲数组提升字节读写效率

我们每次只读取一个字节，这样是十分缓慢的，而使用一个byte类型的缓冲数组，可以每次读取指定数量的字节到缓冲数组中，再从缓冲数组中取出，从而实现我们性能的提升。这个数组最好为2的整数次幂，因为系统底层是以二进制流来处理文件的。

@Test
void contextLoads() {
    FileInputStream fis = null;
    FileOutputStream fos = null;
    try {
        fis = new FileInputStream("d:/1.txt");
        fos = new FileOutputStream("d:/2.txt");
        byte[] b = new byte[1024];

        while ((fis.read(b)) != -1) {
            fos.write(b);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            fis.close();
            fos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


}

字符流

FileWriter和FileReader是字符流，它是以字符char为单位来处理文件的。

@Test
void contextLoads() {
    FileWriter fw = null;
    FileReader fr = null;
    try {
        fw = new FileWriter("d:/2.txt");
        fr = new FileReader("d:/1.txt");
        char[] b = new char[1024];

        while ((fr.read(b)) != -1) {
            fw.write(b);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            fr.close();
            fw.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

使用缓冲数组提升字符读写效率

@Test
void contextLoads() {
    FileWriter fw = null;
    FileReader fr = null;
    try {
        fw = new FileWriter("d:/2.txt");
        fr = new FileReader("d:/1.txt");
        char[] b = new char[1024];

        while ((fr.read(b)) != -1) {
            fw.write(b);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            fr.close();
            fw.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

缓冲流

缓冲流是一种处理流，在节点流处理的基础上进行性能优化，和自定义一个缓冲数组类似，从而提高读写效率，它的输入缓冲区大小8192。

缓冲字节流

BufferedInputStream和BufferedOutputStrem

@Test
void contextLoads() {
    BufferedInputStream br = null;
    BufferedOutputStream bw = null;
    try {
        br = new BufferedInputStream(new FileInputStream("d:/1.txt"));
        bw = new BufferedOutputStream(new FileOutputStream("d:/2.txt"));
        int b = 0;
        while ((b = br.read()) != -1) {
            bw.write(b);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            br.close();
            bw.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

缓冲字符流

BufferedReader和BufferedWriter

@Test
void contextLoads() {
    BufferedWriter bw = null;
    BufferedReader br = null;
    try {
        bw = new BufferedWriter(new FileWriter("d:/2.txt"));
        br = new BufferedReader(new FileReader("d:/1.txt"));
        int b = 0;
        while ((b = br.read()) != -1) {
            bw.write(b);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            br.close();
            bw.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

基本数据流

DataInputStream和DataOutputStream

基本数据流是字节处理流，可以处理八大基本类型和String类型。想一想逻辑性也不可能存在字符流

使用基本数据流来处理基本数据类型，在节点流的基础上进行处理基本数据的处理。

@Test
void contextLoads() {
    DataInputStream in  = null;
    DataOutputStream out = null;
    try {
        in = new DataInputStream(new FileInputStream("d:/1.txt"));
        out = new DataOutputStream(new FileOutputStream("d:/1.txt"));
        out.writeInt(12);
        out.writeChars("a");
        out.writeUTF("你好");
        System.out.println(in.readInt());
        System.out.println(in.readChar());
        System.out.println(in.readUTF());
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            in.close();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

对象操作流

对象操作流ObjectInputStream和ObjectOutputStream是处理字节流。它需要在节点流的基础上进行对象操作，可以处理一切经过序列化的对象，也可以处理基本对象。

// 序列化对象
public class User implements Serializable {
    
    private String name;
    private int age;

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

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

// 写入对象
@Test
void contextLoads() {
    ObjectOutputStream out = null;
    try {
        out = new ObjectOutputStream(new FileOutputStream("d:/1.txt"));
        out.writeInt(12);
        out.writeObject(new User("张三", 12));
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// 读取对象
@Test
void contextLoads1() {
    ObjectInputStream in  = null;
    try {
        in = new ObjectInputStream(new FileInputStream("d:/1.txt"));

        System.out.println(in.readInt());
        System.out.println(in.readObject().toString());
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            in.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

数组操作流

字节数组操作流

ByteArrayOutputStream和ByteArrayInputStream可以将一些字节数据整合为字节数组，也可以将字节数组逐个转换为字节。数据源是字节数组，可以实现各种基本和引用数据类型与字节数组之间的相互转换

@Test
void contextLoads() {
    ByteArrayOutputStream out  = null;
    ByteArrayInputStream in = null;
    try {

        out = new ByteArrayOutputStream();
        // 字节数组输出
        out.write('a');
        out.write('b');
        out.write('c');
        byte[] bytes = out.toByteArray();
        System.out.println(bytes);

        //字节数组写入
        byte[] b = bytes;
        int temp = 0;
        in = new ByteArrayInputStream(b);
        while ((temp=in.read())!=-1){
            System.out.println(temp);
        }

    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            in.close();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

字符数组操作流

CharArrayReader和CharArrayWriter则是字符节点流，可以将字符转换为字符数组，也可以将字符数组转换为逐个字符，用法和字节数组类似，这里不作演示。

转换流

InputStreamReader和OutputStreamWriter是字节转字符转换流，它可以将一个字节流对象转换为字符流对象。

栗子它是一个字符处理流。

@Test
void contextLoads() {
    InputStreamReader ir = null;
    OutputStreamWriter or = null;
    try {
        ir = new InputStreamReader(new FileInputStream("d:/1.txt"));
        or = new OutputStreamWriter(new FileOutputStream("d:/2.txt"));
        int b = 0;
        while ((b = ir.read()) != -1){
            or.write(b);
        }

    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            ir.close();
            or.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

换行操作

不管是写入或者写出的时候，我们都希望能够控制它是否换行写入或者按行读出，而缓存字符流为我们提供了这个方法。

@Test
void contextLoads() {
    BufferedReader bi = null;
    BufferedWriter bo = null;
    try {
        bi = new BufferedReader(new FileReader("d:/1.txx"));
        bo = new BufferedWriter(new FileWriter("d:/1.txt"));
        String b = "";
        // 写入一行
        while ((b = bi.readLine()) != null){
            bo.write(b);
            // 换行
            bo.newLine();
        }

    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            bi.close();
            bo.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

打印控制流

PrintStream和PrintWriter用于打印的一个流，比如我们进场使用的System.out就是PrintStream的一个引用，

public final static PrintStream out = null;

而System.in则是InputStream的一个实现，可以简单的进行实现一下输入和输出。

public final static InputStream in = null;

栗子

@Test
void contextLoads() {
    BufferedReader bi = null;
    BufferedWriter bo = null;
    try {
        InputStream in = System.in;
        bi = new BufferedReader(new InputStreamReader(in));
        bo = new BufferedWriter(new FileWriter("d:/1.txt"));
        String b = "";
        while (!("quit".equals((b = bi.readLine())))){
            bo.write(b);
            bo.newLine();
        }

    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            bi.close();
            bo.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
去海边钓猪
关注
专栏目录
java流和循环 效率_Java stream 和 for循环效率对比问题
weixin_42101641的博客
02-25 1万+
针对同一个集合，用 stream 操作两次得到两个不同条件筛选出来的集合和map，和一次for循环就搞定搞定的效率对比。虽然stream写起来链式操作很舒服，但效率在不同数据量下的体现效果是不一样的，以下为我的测试代码：@Testpublic void testStreamAndFor() {List studentList = new ArrayList<>();// 初始数据量in...
Java IO流（超详细！）
一只小菜鸡
05-07 6万+
一、什么是IO流 I : Input O : Output 通过IO可以完成硬盘文件的读和写。 二、IO流的分类 按照 流的方向 进行分类： 以内存作为参照物： 往内存中去：叫做输入(Input)。或者叫做读(Read)。 从内存中出来：叫做输出(Output)。或者叫做写(Write)。 按照 读取数据方式 不同进行分类： 按照 字节 的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。 这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文
Java IO流学习总结（1万字）
郎涯技术
10-21 524
序列化 vs 反序列化 如果我们需要持久化 Java 对象比如将 Java 对象保存在文件中，或者在网络传输 Java 对象，这些场景都需要用到序列化。 简单来说： 序列化： 将数据结构或对象转换成二进制字节流的过程 反序列化：将在序列化过程中所生成的二进制字节流转换成数据结构或者对象的过程 对于 Java 这种面向对象编程语言来说，我们序列化的都是对象（Object）也就是实例化后的类(Class)，但是在 C++这种半面向对象的语言中，struct(结构体)定义的是数据结构类型，而 class 对应
IO流读文件，和多线程读文件 耗时对比
qq_42553504的博客
04-21 635
import java.io.BufferedInputStream; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; impo
javaIO流详解
weixin_46676497的博客
01-27 2799
java常用io流介绍
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
Java io流 详解
m0_68987535的博客
06-11 4828
"IO流"（Input/Output stream）指的是Java中用于处理输入输出（I/O）数据的机制。在Java中，所有的输入和输出都被抽象为“流”对象，并通过输入流读取数据、输出流写入数据。Java的I/O包提供了丰富的类和方法来支持不同类型的流，输入流和输出流之间可以自由地进行转换。它们分别主要包括字节流和字符流两种类型。其中，字节流是操作二进制数据的流，可以处理任何类型的数据，常见的例如InputStream和OutputStream；
java IO流
D大调奏鸣曲_第七序章_de博客
11-11 8万+
目录 序 一、IO流开篇 1、概念 2、流的分类 3、IO流的作用 4、IO流的使用场景 二、字节流 1、字节流抽象基类 2、字节流写数据 （1）基本步骤 （2）三种方式 （3）两个问题 （4）异常处理 3、字节缓冲流 （1）基本分类&概述 （2）构造方法 （3）代码演示 三、字符流 1、概念 2、分类 （1）字符流体系图 （2）字符输入流（Reader） （3）字符输出流（Writer） 3、字符缓冲流 （1）概念 （2）构造方法 （3）...
Java IO流详解
ss810540895的博客
04-21 1万+
原文 Java IO流详解 1.什么是IO Java中I/O操作主要是指使用Java进行输入，输出操作. Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。 IO又分为流IO（java.io）和块IO(java.nio) Java.io是大多数面向数据流的输入/输出类的主要软件包。此外，Java也对块传输提供支持，在核心库 java.nio中采用的
Java IO流的种类
程序员
02-20 3355
Java IO流的种类
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析 Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的基础。Java中的IO流主要包括两种类型：字节流和字符流。字节流用于处理二进制数据，而...
javaIO流javaIO流javaIO流
07-02
Java IO流是Java平台中用于处理输入输出操作的核心机制，它允许程序与各种数据源（如文件、设备、网络）进行交互。Java IO流体系结构是基于“流”的概念，流是一组有序的数据序列，可以是字节流或字符流。Java IO库...
JAVA IO流缓冲字节流缓冲字符流等流经典代码示例加注释总结.rar
11-30
2、常用21个IO流：FileWriter、FileReader、...3、JAVA IO流经典代码示例，示例从易到难。代码功能涉及字节、字符、字符串、文本文件、图片、音频、视频。演示错误用法和经典用法。 4、代码的结构可查看README文件。
java IO流将一个文件拆分为多个子文件代码示例
08-28
Java IO流将一个文件拆分为多个子文件代码示例 Java IO流是一个文件流处理的基础组件，它提供了基本的文件读取和写入操作。将一个文件拆分为多个子文件是文件处理中一个常见的需求，例如上传大文件时，可以先分割成...
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 466
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 966
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
服务器虚拟化
Hellc007的博客
10-30 1004
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 1042
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值