Java I/O 流详解，让你的思绪更流畅

最新推荐文章于 2024-03-08 10:32:28 发布
最新推荐文章于 2024-03-08 10:32:28 发布
阅读量4k 收藏 9
点赞数 5
分类专栏： java基础 文章标签： Java I/O流详解 FIleOutputStream FileWriter FileInputStream FileReader
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42013035/article/details/103332956
版权

 

目录

字节流

1.FileOutputStream与FileInputStream

2.BufferedOutputStream与BufferedInputStream

3.ObjectOutputStream与ObjectInputStream

4.DateInputStream与DateOutputStream

字符流

1.FiletWriter与FiletReader

2.BufferedWriter与BufferedReader

3.OutputStreamWriter与InputStreamReader

前言：

java.io包官方对其表述是：
Provides for system input and output through data streams, serialization and the file system

可以将Java I/O 大分为两类，字符流和字节流，字符流处理的单元为2个字节的Unicode字符，而字节流处理单元为1个字节，字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好！如果是音频文件、图片、歌曲，就用字节流好点。

I/O体系的基本结构如下（详细结构下文说明）：

 

字节流

字节输出流由抽象类 OutputStream 及其实现类构成，具体结构如下：

字节输入流由抽象类 InputStream 及其实现类构成，具体结构如下：

 

1.FileOutputStream与FileInputStream

用于将数据以字节流的方式读写，FileOutputStream用于写原始字节流，例如图像数据。如要编写字符流，请考虑使用 FileWriter，同样可以使用FileReader代替 FileInputStream。IDEA的默认编码格式为UTF-8，数字与字母使用一个字节，常用汉字三个字节。

示例代码：

public class Main {
    public static void main(String[] args) {
        File file = new File("src/test.txt");
        /*
        字节流的写出
         */
        try (
                FileOutputStream fileOutputStream = new FileOutputStream(file, false)//将append设置为true 表示每次再文件后添加数据
        ) {
            String string = "你的名字";
            byte[] bytes = string.getBytes();
            fileOutputStream.write(bytes);
        } catch (IOException e) {
            e.printStackTrace();
        }
        /*
        字节流的读入
         */
        try (
                FileInputStream fileInputStream = new FileInputStream(file)
        ) {
            /*int count = 0;//记录该字节流读取的字节数
            while (fileInputStream.read() != -1) {  //read操作类似于指针,逐次读取字节流中的字节，当无可读字节时，返回—1
                count++;
            }
            System.out.println(count);//此处输出值为12，再uft-8,汉字使用3个字节编码*/
            byte[] bytes = new byte[20];
            int i = fileInputStream.read(bytes);//将字节流中的数据逐次写入bytes中，并返回总共读取的字节数
            String string = new String(bytes);
            System.out.println(string);
            System.out.println(i);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

结果如下：

2.BufferedOutputStream与BufferedInputStream

缓冲字节流，在流中间提供一个缓冲区，提高数据读取和写入的速度

示例代码：

public class Main {
    public static void main(String[] args) {
        File file=new File("src/test.txt");
        StringBuilder stringBuilder=new StringBuilder();
        for (int i=0;i<100000;i++){
            stringBuilder.append("你难道没有见过江流奔涌的样子吗？\n");
        }
        String string=stringBuilder.toString();
        byte[] bytes=string.getBytes();
        /*
        缓冲输出字节流,它是对输出字节流的包装
         */
        try {
            if(!file.exists()) file.createNewFile();
            OutputStream outputStream=new FileOutputStream(file);
            long date1=System.currentTimeMillis();
            outputStream.write(bytes);
            outputStream.flush();
            long date2=System.currentTimeMillis();
            System.out.println("输出字节流使用时间："+(date2-date1));
            BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(outputStream,1024);//设置缓冲区大小为1024个字节
            long date3=System.currentTimeMillis();
            bufferedOutputStream.write(bytes);
            bufferedOutputStream.flush();
            long date4=System.currentTimeMillis();
            System.out.println("缓冲输出字节流使用时间："+(date4-date3));
            bufferedOutputStream.close();
            outputStream.close();
        }catch (Exception e){
            e.printStackTrace();
        }
        /*
        缓冲输入字节流，它是对输入字节流的包装
         */
        try{
            InputStream inputStream=new FileInputStream(file);
            long date1=System.currentTimeMillis();
            byte[] bytes1=new byte[10000000];
            inputStream.read(bytes1);
            long date2=System.currentTimeMillis();
            System.out.println("输入字节流使用时间："+(date2-date1));
            String string1=new String(bytes1);
            BufferedInputStream bufferedInputStream=new BufferedInputStream(inputStream,1024);
            long date3=System.currentTimeMillis();
            byte[] bytes2=new byte[10000000];
            bufferedInputStream.read(bytes2);
            long date4=System.currentTimeMillis();
            System.out.println("缓冲输入字节流使用时间："+(date4-date3));
            bufferedInputStream.close();
            inputStream.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

运行结果：

可见，当数据量较大时，缓冲流可以提高读写效率

 

3.ObjectOutputStream与ObjectInputStream

对象输出输入流，用于对象的序列化与反序列化，一个对象要想被序列化则必须实现Serializable ​​接口，如果要设置该对象中的某个属性是不可序列化的，则需使用 transient 关键字声明该属性是短暂的，对它的赋值将不会被序列化，序列化文件以xxx.ser后缀。

整个过程都是Java虚拟机（JVM）独立的，也就是说，在一个平台上序列化的对象可以在另一个完全不同的平台上反序列化该对象

示例代码：

import java.io.*;

/**
 * @Author: QianQian
 * @CreateDate: 2019/11/30 17:17
 */
public class Main {
    public static void main(String[] args) {
        File file=new File("src/student1.ser");
        Student student=new Student("康康",19);
        student.setScore(100);
        System.out.println(student.toString());
        /*
        对象的序列化
         */
        try{
            if(!file.exists()) file.createNewFile();
            OutputStream outputStream=new FileOutputStream(file);
            ObjectOutputStream objectOutputStream=new ObjectOutputStream(outputStream);
            objectOutputStream.writeObject(student);
            objectOutputStream.close();
            outputStream.close();
        }catch (IOException e){
            e.printStackTrace();
        }
        /*
        对象的反序列化
         */
        try{
            InputStream inputStream=new FileInputStream(file);
            ObjectInputStream objectInputStream=new ObjectInputStream(inputStream);
            Student student1= (Student) objectInputStream.readObject();
            System.out.println(student1.toString());
            objectInputStream.close();
            inputStream.close();
        }catch (Exception e){
            e.printStackTrace();
        }

    }
}

class Student implements Serializable{
    private String name;
    private int age;
    private transient int score;

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

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

    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;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }
}

运行结果：

4.DateInputStream与DateOutputStream

数据输入输出流可以将Java的基本类型写入到文件或读取，与机器本身的环境无关

注意：该流读取的顺序要和写入的顺序一致，否则无法保证数据的准确性

示例代码：

public class Main {
    public static void main(String[] args) {
        File file=new File("src/test.txt");
        try(
                FileOutputStream fileOutputStream=new FileOutputStream(file);
                DataOutputStream dataOutputStream=new DataOutputStream(fileOutputStream);
                ){
            dataOutputStream.writeInt(23);
            dataOutputStream.writeBoolean(true);
            dataOutputStream.writeFloat(3.2312f);
            dataOutputStream.writeUTF("hello world");
            dataOutputStream.flush();
        }catch (IOException e){
            e.printStackTrace();
        }
        try(
                FileInputStream fileInputStream=new FileInputStream(file);
                DataInputStream dataInputStream=new DataInputStream(fileInputStream);
                ){
            //要按照写入的顺序依次读取，否则会抛出异常
            System.out.println(dataInputStream.readInt());
            System.out.println(dataInputStream.readBoolean());
            System.out.println(dataInputStream.readFloat());
            System.out.println(dataInputStream.readUTF());
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

运行结果：

 

字符流

字符输出流是抽象类Writer及其实现类组成：

字符输入流是抽象类Reader及其实现类组成：

1.FiletWriter与FiletReader

此类方便读写字符类文件，以字符为单位进行读写，该类的构造函数默认字符编码和缓冲区大小都是可以接受的，如果要自己定义编码方式和缓冲区大小，则可通过OutputStreamWriter使用FileOutputStream构建一个FileWriter。

代码示例：

public class Main {
    public static void main(String[] args) {
        File file=new File("src/test.txt");
       try(
               FileWriter fileWriter=new FileWriter(file,false)
               ){
           String string="你难道没有见过江流奔涌的样子吗？";
           fileWriter.write(string);
       }catch (IOException e){
           e.printStackTrace();
       }
       try(
               FileReader fileReader=new FileReader(file)
               ){
           char[] chars=new char[100];
           int len=fileReader.read(chars);
           System.out.println(new String(chars,0,len));
       }catch (IOException e){
           e.printStackTrace();
       }
    }
}

2.BufferedWriter与BufferedReader

输入与输出的字符缓冲流，可以用以包装FileWriter和FileReader, 提高字符流的读写效率，提供了一个newLine（）方法，它使用平台自己的系统属性line.separator定义的行分隔符概念。 并非所有平台都使用换行符（'\ n'）来终止行。 因此，调用此方法来终止每个输出行，因此优选直接写入换行符

示例代码：

public class Main {
    public static void main(String[] args) {
        File file=new File("src/test.txt");
       try(
               FileWriter fileWriter=new FileWriter(file,false);
               BufferedWriter bufferedWriter=new BufferedWriter(fileWriter,1024)//指定缓冲区大小
               ){
           String string="你难道没有见过江流奔涌的样子吗？";
           bufferedWriter.write(string);
           bufferedWriter.newLine();
           bufferedWriter.write(string);
       }catch (IOException e){
           e.printStackTrace();
       }
       try(
               FileReader fileReader=new FileReader(file);
               BufferedReader bufferedReader=new BufferedReader(fileReader)
               ){
           String string=null;
           while((string=bufferedReader.readLine())!=null){//判断读取的一行是否为空
               System.out.println(string);
           }
       }catch (IOException e){
           e.printStackTrace();
       }
    }
}

运行结果：

3.OutputStreamWriter与InputStreamReader

这两个个类是字节流转化为字符流的桥梁，在转换时可以指定字符流的编码形式，否则使用平台的默认字符集

代码示例：

public class Main {
    public static void main(String[] args) {
        File file=new File("src/test.txt");
        String string="你难道没有见过江流奔涌的样子吗？";
       try(
               FileOutputStream fileOutputStream=new FileOutputStream(file,false);
               OutputStreamWriter outputStreamWriter=new OutputStreamWriter(fileOutputStream,"gbk");//设置输出字符流的编码方式为GBK
               BufferedWriter bufferedWriter=new BufferedWriter(outputStreamWriter)
               ){
           bufferedWriter.write(string);
       }catch (IOException e){
           e.printStackTrace();
       }
       try(
               FileInputStream fileInputStream=new FileInputStream(file);
               InputStreamReader inputStreamReader=new InputStreamReader(fileInputStream,"gbk");//设置输入字符流的编码方式也为GBK，否则读取乱码
               BufferedReader bufferedReader=new BufferedReader(inputStreamReader);
               ){
           System.out.println(bufferedReader.readLine());
       }catch (IOException e){
           e.printStackTrace();
       }
    }
}

运行结果：（因为IDEA的默认编码方式为UTF-8,所以文件里的数据显示乱码，但如果同样使用GBK的方式读取数据，那么数据依然可以正常显示）

                                              

 

swingfer
关注
专栏目录
java I/O和NI/O 详解
topdeveloperr的博客
09-04 2702
目录 I/O概述 字符流 字节流 理解I/O超类结构 FileInputStream详解  FileOutputStream详解 File类 新I/O Java NIO: Channels and Buffers Channels  NIO FileChannel SocketChannel ServerSocketChannel Buffers Java NIO: ...
JAVA输入/输出流详细讲解
热门推荐
weixin_45536242的博客
07-09 1万+
应用程序经常需要访问文件和目录，读取文件信息或写入信息到文件，即从外界输入数据或者向外界传输数据，这些数据可以保存在磁盘文件、内存或其他程序中。在Java中，对这些数据的操作是通过I/O技术来实现的。所谓I/O技术，就是数据的输入（Input）、输出（Output）技术。本章将对Java的 I/O系统进行讲解，包括I/O的体系结构、流的概念、字节流、处理字节流的基本类InputStream和OutputStream、字符流、处理字符流的基本类Reader和Writer、文件管理、序列化和反序列化等。12.1
java I/O流详解
weixin_67573348的博客
06-24 874
java i/o详解
BIO、NIO、AIO，同步、异步、阻塞、非阻塞的概念
每天迈出一小步!
11-18 332
同步异步、阻塞非阻塞 同步 ： 自己亲自出马持银行卡到银行取钱（使用同步IO时，Java自己处理IO读写）； 异步 ： 委托一小弟拿银行卡到银行取钱，然后给你（使用异步IO时，Java将IO读写委托给OS处理，需要将数据缓冲区地址和大小传给OS(银行卡和密码)，OS需要支持异步IO操作API）； 阻塞 ： ATM排队取款，你只能等待（使用阻塞IO时，Java调用会一直阻塞到读写完成才返回）； 非阻塞 ： 柜台取款，取个号，然后坐在椅子上做其它事，等号广播会通知你办理，没到号你就不能去，你可以不断问大堂经理排
java i o流_Java I/O流详解
weixin_31998371的博客
02-20 396
Java中把不同的数据源与程序间的数据传输都抽象表述为"流"(Stream),java.io包中定义了多种I/O流类型实现数据I/O功能。I/O流分类:输入流(Input Stream)和输出流(Output Stream)节点流(Node Stream)和处理流(Processing Stream)字符流(Character Stream)和字节流(Byte Stream)输入流和输出流按照数据...
JAVA I/O流(超详细)
最新发布
wu_ry的博客
03-08 1489
File类能够实现对文件和目录的创建、删除等基础性操作，但是无法实现对文件内容的操作，也就是无法实现对文件的读写。而java中的I/O流能够方便地实现数据的输入和输出，是实现文件读写的基础。流，是指一连串流动的字符，是以先进先出的方式发送和接收数据的通道。既然是流，必然有源端和目的的端，它们可以是计算机内存的某些区域，也可以是磁盘、文件等，甚至可以是Internet上的某个统一资源定位符。所谓I/O流就是实现数据输入和输出的流，在I/O流的基础上，可以实现对文件的读写操作。那么文件的读写指什么？
核心java系列——I/O流详解(一)
牧码心
11-26 933
流的概念流是一系列有顺序的字节的集合，是网络传输的载体，流可以包装成基本数据类型或对象，流有输入和输出，输入时是从流从数据源流向程序输出时是流从程序传向数据源，而数据源可以是内存，文件，网络或程序等。
Java I/O学习（附实例和详解）
小宝鸽
03-06 6379
一、Java I/O类结构以及流的基本概念在阅读Java I/O的实例之前我们必须清楚一些概念，我们先看看Java I/O的类结构图：Java I/O主要以流的形式进行读写数据。流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。根据处理数据的数据类型的不同可以分为：字符流和
全网最详细的 I/O 多路复用解析
程序员囧辉
05-11 1万+
看完起飞
如何完成一次 IO - Linux I/O详解
liyifan687的博客
06-14 3027
如何完成一次 IO 哪个男孩不想来一场异步非阻塞的甜蜜恋爱？ 21 点，你打开微信，开心地对女孩说：“晚上好”。女孩说：“我在洗澡”。 你抱着手机等待晚点聊，此刻，你是阻塞的，也是同步的。为什么？ 写在前面 谈起 IO, Javaer 会说起 BIO、NIO、AIO，也会提到同步异步、阻塞非阻塞。但到底什么是 IO, IO又是怎么完成的？ 1. 什么是 I/O 学术的说 I/O 是信息处理系统（计算机）与外界（人或信息处理系统）间的通信。如计算机，即 CPU 访问任何寄存器和 Cache 等封装以外的
详解 Java I/O（笔记）
菜鸟踩坑
08-11 315
什么是I/O？ IO（输入/输出）是比较抽象的，看不到明显的运行效果，但输入和输出是所有程 序都必需的部分。使用输入机制，允许程序读取外部数据（包括来自磁盘、光盘等存 储设备的数据、来自网络的数据）、用户输入数据；使用输出机制，允许程序记录运 行状态，将程序数据输出到磁盘、光盘等存储设备中和网络其他设备中。 Java的IO通过java.io包下的类和接口来支持，在java.io包下主要包括输入流、输 出流两种IO流，每种输入、输出流又可分为字节流和字符流两大类。其中字节流以字 节为单位来处理输入、输出操
Java中I/O模式详解
来日可期的博客
07-09 788
一、计算机的组成 现代计算机是由硬件、操作系统组成，操作系统通过内核与硬件交互。操作系统可以划分为：内核与应用两部分，内核提供进程管理、内存管理、网络等底层功能，封装了与硬件交互的接口，通过系统调用提供给上层应用使用。 二、用户空间与内核空间 由于CPU某些指令比较危险，如果错用会导致系统崩溃，为了保护系统，操作系统将内存空间划分为了两部分： 内核空间（Kernel space ） 用户空间（User space） 当进程运行在内核空间时，它就处于内核态；当进程运行在用户空间时，它就处于用户态。 其实
Java流详解
qq_15762347的博客
05-20 386
一、流的概念        流(stream)的概念源于UNIX中管道(pipe)的概念。在UNIX中，管道是一条不间断的字节流，用来实现程序或进程间的通信，或读写外围设备、外部文件等。        一个流，必有源端和目的端，它们可以是计算机内存的某些区域，也可以是磁盘文件，甚至可以是Internet上的某个URL。         流的方向是重要的，根据流的方向，流可分为两类：输入流
java 流详解
weixin_41359273的博客
06-30 320
1.流的分类 1）操作数据单位：字节流，字符流 2）数据的流向：输入流，输出流 3）流的角色：节点流，处理流 四个最基本的抽象基类InputStream,OutputStream,Writer,Reader 流分类图 2.FileWriter和FileReader(字符流)基本使用 package com.yl.pdfdemo.day08.p4; import org.junit.Test; import java.io.File; import java.io.FileReader; import
java 流详解_Java中的流详解
weixin_35130561的博客
03-07 1271
一、Java中流的原理流是个抽象的概念，是对输入输出设备的抽象，Java程序中，对于数据的输入/输出操作都是以“流”的方式进行。设备可以是文件，网络，内存等。四种基本流InputStream，OutputStream，Reader，Writer又分别有更具体的子类，分为文件流，缓冲流，数据流，转换流，Print流，Object流等，都分别有特定的功能或用来操作特定的数据。二、字节流2.1 Inpu...
Java中I/O使用入门详解(1)
lawfree的博客
12-28 448
本文介绍了 FileInputStream,FileOutputStream等常用输入输出流的使用方式,(来自于以前的学习笔记,现整理出来和大家分享). 通俗易懂,老少皆宜O(∩_∩)O~
Java学习总结-流
choudanjing5788的博客
01-29 525
一、JAVA流式输入/输出原理 　　 　　流是用来读写数据的，java有一个类叫File，它封装的是文件的文件名，只是内存里面的一个对象，真正的文件是在硬盘上的一块空间，在这个文件里面存放着各种各样的数据，我们想读文件里面的数据怎么办呢？是通过一个流的方式来读，咱们要想从程序读数据，对于...
详解Java 流(Stream)、文件(File)和IO（一）
r1037的博客
10-13 804
一、关于Java I/OJava.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。 Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。 一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。 Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。如前所述，一个流被
Java—I/O
wintershii的博客
07-30 1230
Java—IO 1. IO: java的IO是实现输入和输出的基础，可以方便地实现数据的输入和输出操作。在java中把不同的输入/输出源(键盘，文件，网络连接等)抽象的表述为 “流”(Stream)。通过流的形式允许java程序使用相同的方式来访问不同的输入/输出源。 2.IO分类： 1&gt; 按流向分：输入流，输出流 输入流：只能从中读取数据，不能写入数据 输出流，只能向...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值