IO流【Java】

最新推荐文章于 2026-06-29 16:52:08 发布
原创 最新推荐文章于 2026-06-29 16:52:08 发布 · 1.1k 阅读 · 18 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
编程技术学习笔记

当前文章被收录于：

编程技术学习笔记
24 篇文章 0 人学习

主要记录自己学习的过程，讲学到的知识点进行归纳总结，方便自己以后回顾，有问题请帮我指正，非常感谢你的观看。

订阅专栏 查看详情

IO流

1.认识IO流

I:input，称为输入流，将字节或者字符从硬盘/网络中读取到内存中
O：output，称为输出流，把字节或者字符从Java程序中写入到网络或者硬盘中

  • 作用：读写文件数据

    IO流分类：
  • 流的方向：输入和输出流
  • 按流的内容：字节流和字符流

那么主要分类有：字节输入流、字符输入流、字节输出流、字符输出流
在这里插入图片描述

2.字节流

1) 字节输入流

  • FileInputStream

文件字节输入流读取文件数据的步骤：

  • 1.创建文件字节输入流管道与文件接通：InputStream fs = new FileInputStream(filePath);
  • 2.开始读取文件中的字节并输出:
    • 每次读取一个字节：int b; while((b = fs.read()) != -1) { String str = new String((char) b));}
    • 读取指定长度的字节数组：byte[] b = new byte(10); int len; while((len = fs.read(b)) != -1) { String str = new String(b, 0, len)}; //将读取到的字节数组转成字符串输出，读取多少倒出多少
    • 读取所有字节： byte[] bytes = fs.readAllBytes(); String str = new String(bytes); 适用于存在汉字读取，当文件内容过大时，可能导致内存溢出
package com.itheima.demo.demo1.filestream;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;

public class fileInputStream {
    public static void main(String[] args) throws Exception {
        //目标：从文件中读取字节
        //1.与文件建立管道
        InputStream is = new FileInputStream("C:\\Users\\zlb\\IdeaProjects\\untitled\\src\\com\\itheima\\demo\\demo1\\filestream\\inputStream.txt");

        //2.从文件中开始读取数据
        //a. 读取单个字节
        int b;
        while ((b = is.read()) != -1) {
            System.out.print((char) b);
        }
        System.out.println("======================================");
        //b.读取字节数组
        InputStream is1 = new FileInputStream("C:\\Users\\zlb\\IdeaProjects\\untitled\\src\\com\\itheima\\demo\\demo1\\filestream\\inputStream.txt");
        byte[] buffer = new byte[3];
        //定义一个len表示读取到的字节长度
        int len;
        while ((len = is1.read(buffer)) != -1) {
            //从0开始倒出来，读取到多长的字节倒多长
            System.out.print(new String(buffer, 0, len));
        }
        System.out.println("=========================================");

        InputStream is2 = new FileInputStream("C:\\Users\\zlb\\IdeaProjects\\untitled\\src\\com\\itheima\\demo\\demo1\\filestream\\inputStream.txt");
        byte[] bytes = is2.readAllBytes();
        System.out.println(new String(bytes));
    }
}

2) 字节输出流

  • FileOuputStream

字节输出流将字节写入到文件中的步骤

  • 创建字节输出流，指定写出文件路径，第二个参数填true则代表是追加管道，不会覆盖原本内容
  • 开始将字节写出到文件
    • 只写一个字节
    • 写一个字节数组
    • 写字节数组中的一部分出去
  • 关闭输出流管道： os.close()，写完之后关闭，即时释放资源，减少性能占用
package com.itheima.demo.demo1.filestream;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class fileOutputStream {
    public static void main(String[] args) throws Exception {
        //目标： 将字节写入到文件中
        //1、创建字节输出流，指定文件名建立输出管道
//        OutputStream os = new FileOutputStream("untitled/src/output.txt");  //覆盖管道
        OutputStream os = new FileOutputStream("output.txt",true); //追加管道
        //2、将字节写道文件中
        //a.写入一个字节
        os.write(97);
        os.write('b');
        os.write("\r\n".getBytes()); //换行
        //b.写入一个字节数组
        byte[] bytes = "hello world".getBytes();
        os.write(bytes);
        os.write("\r\n".getBytes());
        //c.写入一个字节数组中的一部分
        os.write(bytes, 0, 3);
        //3.关闭管道
        os.close();
    }
}

3) 文件复制

  • 任何文件的底层都是字节，字节流做复制，就是将源文件的字节一个不漏的读取并写入到新文件中，主要复制之后的文件格式一致就一定能复制成功
package com.itheima.demo.demo1.filestream;

import java.io.*;
import java.sql.SQLOutput;

public class fileCopy {
    public static void main(String[] args) {
        try {
            copyFile("C:\\Users\\zlb\\Pictures\\family.jpg", "qiya.jpg");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }


    }
    public static void copyFile(String src, String dest) throws Exception {
        InputStream is = new FileInputStream(src);
        OutputStream os = new FileOutputStream(dest);
        byte[] buf = new byte[1024];
        int len = 0;
        while ((len = is.read(buf)) != -1) {
            is.read(buf, 0, len);
            os.write(buf, 0, len);
        }
        //关闭流
        os.close();
        is.close();
        System.out.println("复制成功！");
    }
}

4) 资源释放

情形：普通关闭流只是在操作完之后，直接进行关闭，但是如果代码在中间过程出现异常，就会直接跳出，而没有执行流的关闭，导致资源浪费
关闭方式

  • try-catch-finally: 太臃肿，不美观

package com.itheima.demo.demo1.filestream;

import java.io.*;
import java.sql.SQLOutput;

public class fileCopy {
    public static void main(String[] args) {
       copyFile("C:\\Users\\zlb\\Pictures\\family.jpg", "qiya.jpg");



    }
    public static void copyFile(String src, String dest){
        InputStream is = null;
        OutputStream os = null;
        try {
            is = new FileInputStream(src);
            os = new FileOutputStream(dest);
            byte[] buf = new byte[1024];
            int len = 0;
            while ((len = is.read(buf)) != -1) {
                is.read(buf, 0, len);
                os.write(buf, 0, len);
            }
            is.close();
            os.close();
            System.out.println("复制成功！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(is != null) {
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(os != null) {
                    os.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            } 
        }
    }
}
  • try-with-resource: 从JDK7开始添加了新功能：try可以自动调用（）中资源的close()方法
    在这里插入图片描述
package com.itheima.demo.demo1.filestream;

import java.io.*;
import java.sql.SQLOutput;

public class fileCopy {
    public static void main(String[] args) {
       copyFile("C:\\Users\\zlb\\Pictures\\family.jpg", "qiya.jpg");



    }
    public static void copyFile(String src, String dest){
        try (
                InputStream is = new FileInputStream(src);
                OutputStream os = new FileOutputStream(dest);
                )
        {
            byte[] buf = new byte[1024];
            int len = 0;
            while ((len = is.read(buf)) != -1) {
                is.read(buf, 0, len);
                os.write(buf, 0, len);
            }
            is.close();
            os.close();
            System.out.println("复制成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.字符流

1) 文件字符输入流

  • FileReader

从文件中读取字符到内存的程序中
步骤：

  • 创建FileReader对象与源文件建立管道
  • 每次可以读取一个字符或者读取一个字符数组
package com.itheima.demo.demo1.filestream;

import java.io.*;

public class FIleReader {
    public static void main(String[] args) throws IOException {
        try (
                Reader is = new FileReader("fileReader.txt")
        ) {
            char[] buf = new char[1024];
            int len;
            while ((len = is.read(buf)) != -1) {
                System.out.print(new String(buf, 0, len));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2) 文件字符输出流

  • FileWriter

以内存为基准，把内存中的数据以字符的形式写出到文件中

package com.itheima.demo.demo1.filestream;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class FIleWriter {
    public static void main(String[] args) {
        try (
                //1.创建FileWriter对象，与源文件创建管道
                Writer fw = new FileWriter("fileWriter.txt", true)
        ) {
            //2.写入
            //a.写入一个字符
            fw.write('啊');
            fw.write('\n');
            //b.写入字符串
            fw.write("hello");
            fw.write('\n');
            //c.写入字符串的一部分
            fw.write("world",2, 2);
            fw.write('\n');
            //d.写入字符数组
            char[] chars = "hello".toCharArray();
            fw.write(chars);
            fw.write('\n');
            //e.写入字符数组中的一部分
            fw.write(chars,2,chars.length-2);
            fw.write('\n');
            //3.刷新，将字符缓冲区中的字符刷新到文件中，这里可以不需要，因为关流前会执行刷新
            fw.flush();
            //4.关流，将流关闭，这里也不需要，使用了try-with-resource
            fw.close(); 
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4.缓冲流

缓冲流是为了提高原本流的性能。
在这里插入图片描述

1) 缓冲字节流

  • 缓冲字节输入流：BufferedInputStream
  • 缓冲字节输出流：BufferedOutputStream

为什么可以提升性能：自带8KB缓冲池，一次性读取8KB的字节到内存中，然后在内存中从缓冲字节输入流中读取字节数组长度的字节到缓冲字节输出流中，当读取够8KB时，缓冲字节输出流会统一将8KB的字节输出到文件中。这样减少了内存与磁盘（IO操作效率低）之间的IO操作次数，大大提升IO效率
在这里插入图片描述


package com.itheima.demo.demo1.filestream;

import java.io.*;
import java.sql.SQLOutput;

public class fileCopy {
    public static void main(String[] args) {
       copyFile("C:\\Users\\zlb\\Pictures\\family.jpg", "qiya.jpg");



    }
    public static void copyFile(String src, String dest){
        try (
        		//1.创建字节输入流，源源文件接通
                InputStream is = new FileInputStream(src);
                //2.创建缓冲字节输入流，包装低级的字节输入流
                InputStream bis = new BufferedInputStream(is);
                OutputStream os = new FileOutputStream(dest);
                OutputStream bos = new BufferedOutputStream(os);
                )
        {
            byte[] buf = new byte[1024];
            int len = 0;
            while ((len = is.read(buf)) != -1) {
                bis.read(buf, 0, len);
                bos.write(buf, 0, len);
            }
            bis.close();
            bos.close();
            System.out.println("复制成功！");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

2) 缓冲字符流

  • 缓冲字符输入流：BufferedReader
    • 新增功能： 读取一行：readLine()，每次读取一行，没有数据可读时则返回null
  • 缓冲字符输出流：BufferedWriter
    • 新增功能：换行：newLine()

5.性能分析

在这里插入图片描述

在这里插入图片描述
字节数组的长度并不是越大越好，适用在一定大小。

6.其他流

1) 字符输入转换流

解决不同编码格式下，字符流读取文本内容乱码的问题

  • InputStreamReader
    在这里插入图片描述
package com.itheima.demo.demo1.filestream;

import java.io.*;

public class InputStreamReader {


    public static void main(String[] args) {
        //目标：使用字符输入转换流解决不同编码格式读取乱码的问题
        //从GBK编码格式下的文件读取数据到UTF-8编码格式的代码中
        try (
                //先提取文件的元素字节流：此时读取的是GBK格式下的字节
                InputStream is = new FileInputStream("C:\\Users\\zlb\\IdeaProjects\\untitled\\fileReader.txt");
                //指定字符集把原始字节流转换成字符输入流
                Reader isr = new java.io.InputStreamReader(is,"GBK");
                //创建缓冲输入流包装低级的字符输入流
                BufferedReader br = new BufferedReader(isr);
        ) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }

        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2) 打印流

  • PrintStram：字节打印流
  • PrintWriter:字符打印流
    二者作用基本一致：能实现打印什么东西出去就是什么东西

package com.itheima.demo.demo1.filestream;

import java.io.PrintStream;

public class printStream {
    public static void main(String[] args) {
        try (
                PrintStream ps = new PrintStream("C:\\Users\\zlb\\IdeaProjects\\untitled\\src\\com\\itheima\\demo\\demo1\\filestream\\inputStream.txt")
        ) {
            ps.println("Hello World");
            ps.println(97);
            ps.println('1');
            ps.println(99.24);
        }catch (Exception e){
            e.printStackTrace();
        }

    }
}

3) 特殊数据流

允许把数据和其类型一并写出去

  • DataOnputStream
package com.itheima.demo.demo1.filestream;

import java.io.*;

public class dataOutputStream {
    public static void main(String[] args) {
        try (
                OutputStream os = new FileOutputStream("output.txt");
                OutputStream bos = new BufferedOutputStream(os);
                DataOutputStream dos = new DataOutputStream(bos)
        ) {
            dos.writeUTF("Hello World");
            dos.writeBoolean(true);
            dos.writeByte(23);
            dos.writeDouble(1.0);
            dos.writeInt(23);
            dos.writeFloat(3.0f);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  • DataInputStream
package com.itheima.demo.demo1.filestream;

import java.io.*;

public class dataOutputStream {
    public static void main(String[] args) {
        try (
                InputStream is = new FileInputStream("output.txt");
                InputStream bis = new BufferedInputStream(is);
                DataInputStream dis = new DataInputStream(bis);

        ) {
            System.out.println(dis.readUTF());
            System.out.println(dis.readBoolean());
            System.out.println(dis.readByte());
            System.out.println(dis.readDouble());
            System.out.println(dis.readInt());
            System.out.println(dis.readFloat());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

7.IO框架

框架：是一个预先写好的代码库或者一组工具，旨在简化和加速开发过程

  • 框架形式：一般是把类或者接口编译成class形式，再压缩成一个.jar结尾的文件发行

IO框架：封装了Java提供的对文件、数据进行操作的代码，对外提供了更简单的方式来对文件进行操作，对数据进行读写等
commons-io框架
使用教程：

  • 去commons-io官网，下载对应的zip文件
  • 解压之后复制到项目中新建的lib文件夹内
  • 在这里插入图片描述
  • 与项目产生联系：
  • 在这里插入图片描述

常用的API


实战小案例
在这里插入图片描述
在这里插入图片描述
*注：上述内容均是学习黑马程序员IO流过程中的学习笔记，图片是课上PPT直接截图的，仅作为学习交流使用，不作为商业用途，如有侵权，联系删除。

标签
#java #开发语言 #nio
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流】IO流详解
m0_55908255的博客
05-02 1649
IO，即InputOutput，也就是输入和输出，指应用程序和外部设备之间的数据传递，常见的外部设备包括磁盘文件、管道、网络连接Java中是通过流处理IO的，那么什么是流？流（Stream），是一个抽象的概念，是指一连串的数据（字符或字节），是以先进先出的方式发送信息的通道当Java程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是磁盘文件、内存、网络连接等等。类似地，当Java程序需要写入数据的时候，就会开启一个通向目的地的流。
Java IO流知识点总结
weixin_43836337的博客
04-06 1833
I（Input）O（Output） 通过IO可以处理程序与外部环境之间的数据传输。
Java IO流之IO流基础
Mr.mooye
03-30 2819
IO流介绍 IO基础之File类 IO流之字符流 IO流之字节流 IO流之Scanner类
Java——IO流
pangyaqi的博客
02-15 1691
存储和读取数据的解决方案IO流和File是息息相关的。
Java的File与IO流
m0_73077892的博客
04-06 1790
File类位于java.io包下，是文件和目录路径名的抽象表示，提供了一系列对文件和文件夹本身操作的方法，它不能读写数据。read(字节数组)一次性读取多个字节，注意要判断实际读取的字节到底有多少，以免错误地读取字节数组之前遗留的数据。默认缓冲池大小为8KB。注意：File类是路径名的抽象表示，构建一个File实例并不会创建一个文件，不管文件是否存在，都可以创建任意文件名的File实例。[] listFiles() 一级文件对象数组，包含隐藏文件，无权限访问则为null，主调为文件也为null。
java IO流学习总结
热门推荐
coder150806的博客
09-09 5万+
学习了几天的java IO流，下面我来谈谈对java 输入输出流IO的个人见解吧！ 转载自：https://blog.csdn.net/zhaoyanjun6/article/details/54292148/ java流类结构图 一.流的概念： 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。它的特性是进行数据传输； 例如从水源地长江把水导入自来水厂，然后又从自...
java中的IO流
冲出仁川，走出马德里，故事还会再继续
09-26 2449
如果new的File对象所表示的文件或目录并不存在，那么并不会应位new了一个File对象，操作系统就在对应的路径下创建所对应的文件和目录，它仅仅是在JVM的堆中new了一个File对象而已。java为了避免这种类型安全性问题的发生，使序列化接口类在每次编译时，自动生成一个序列化版本ID，用以区别不同的版本，当序列化和反序列化的版本不一致时，就会失败，抛出异常。然而，有些修改并不影响对象的反序列化，如类中加入了新的实例变量，而序列化的数据中并没有新实例变量的值，那么它在反序列化的过程中可以使默认值。
java基础——IO流
2403_87486006的博客
02-16 777
是字节输入流，用于从文件中读取字节数据。int data;= -1) {
java io流不关闭有什么后果_Java IO流
weixin_39563827的博客
11-21 2300
一、基本概念 IO是Java对数据的操作是通过流的方式，数据传输是需要通道的，而IO流就是数据传输的通道。IO流可以形象的比喻为运送货物的传输带。IO流用来处理设备之间的数据传输，上传文件和下载文件，Java用于操作流的对象都在IO包中。总结一下，Java IO输入机制就是为了允许程序读取外部数据（包括来自于磁盘、光盘等存储设备的数据）和用户输入的数据。 Java的IO流通过java...
Java IO流
rmkloveme
05-09 1337
Java IO 也称为IO流，IO = 流，它的核心就是对文件的操作，对于 字节 、字符类型的输入和输出流。 IO是指对数据流的输入和输出，也称为IO流，IO流主要分为两大类，字节流和字符流。字节流可以处理任何类型的数据，如图片，视频等，字符流只能处理字符类型的数据。 IO流的本质是数据传输，并且流是单向的。 常用的字节流FileInputStream、FileOutputStream、ObjectInputStream、ObjectOutputStream。 IO分阻塞型IO和非阻塞型IO（.
Java-IO流基础
2402_88479893的博客
11-25 1096
当程序需要读取数据源的数据时，就会通过IO流对象开启一个通向数据源的流，通过这个IO流对象的相关方法可以顺序读取数据源中的数据。IO流相当于一个管道。
java io流
勿在浮沙筑高台
02-08 1万+
java IO流 什么是IO流 io是input/output的简称。在我们大学学习计算原理的时候，我们知道计算的组成： 输入设备，输出设备，存储器（内存，外存），运算器，控制器。 程序 = 数据结构 + 算法 ； 程序需要处理能够读取输入的数据，并且经过程序处理之后需要输出到存储器进行持久化。 java对输入输出进行了封装，给我们提供了一系列的api，使我们脱离于对最底层硬件的操...
java io流_Java——IO流超详细总结
weixin_39838362的博客
02-12 2147
该系列博文会告诉你如何从入门到进阶，一步步地学习Java基础知识，并上手进行实战，接着了解每个Java知识点背后的实现原理，更完整地了解整个Java技术体系，形成自己的知识框架。在初学Java时，IO流是我遇到的一个很头疼的东西，Java IO 体系看起来类很多，感觉很复杂，但其实是 IO 涉及的因素太多了。在设计 IO 相关的类时，编写者也不是从同一个方面考虑的，所以会给人一种很乱的感觉，并且还...
Java中的IO流
YIYIYI
05-13 771
Java中的IO流
一款针对Spring漏洞框架进行快速利用的图形化工具
最新发布
LiBai'S BLOG
06-29 334
一款针对Spring漏洞框架进行快速利用的图形化工具。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值