Java IO流

最新推荐文章于 2025-05-30 08:05:08 发布
最新推荐文章于 2025-05-30 08:05:08 发布
阅读量906 收藏 29
点赞数 8
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_73613360/article/details/139396080
版权

Java IO流

1.流的分类

  • 按操作数据单位不分为：字节流(8 bit)二进制文件 字符流(按字符)文本文件
  • 按数据流的流向不同分为：输入流(读取) 输出流(写入)
  • 按流的角色的不同分为：节点流 处理流/包装流
抽象基类字节流字符流
输入流InputStreamReader
输出流OutputStreamWriter

  • Java的IO流的类 都是从以上4个抽象基类派生的

  • 由着4个类派生出来的子类名称都是以其父类名作为子类名后缀

image-20240505234557489

2.常用的类

  • InputStream：字节输入流
    • InputStream抽象类是所有类字节输入流的超类

FileInputStream：文件输入流

image-20240524133931032

  package hspedu.File;
  
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.IOException;
  
  
  public class FileInputStream_ {
      public static void main(String[] args) {
          readFile01();
          readFile02();
      }
  
      /*演示FileInputStream (字节输入流 文件-->程序)
       * 单个字节的读取 效率比较低
       *  ->使用read(byte[] b) */
      static public void readFile01(){
          String filePath="D:\\Java\\hspedu\\hello.txt";
          int readData=0;
          FileInputStream fileInputStream = null;
  
          try {
              /*创建FileInputStream对象 用于读取文件*/
              fileInputStream = new FileInputStream(filePath);
              /*从该输入流读取一个字节的数据 如果没有输入可用 此方法将阻止
              * 如果返回-1 表示读取完毕*/
              while ((readData=fileInputStream.read())!=-1){
                  System.out.print((char)readData);//转成char显示
              }
          } catch (IOException e) {
              throw new RuntimeException(e);
          } finally {
              //一定要关闭文件流 释放资源
              try {
                  fileInputStream.close();
              } catch (IOException e) {
                  throw new RuntimeException(e);
              }
  
          }
  
      }
  
      /*使用read(byte[] b) 读取文件 提高效率
      * */
      static public void readFile02(){
          String filePath="D:\\Java\\hspedu\\hello.txt";
          /*字节数组*/
          byte[] buf=new byte[8];//一次读取8个字节
          int readLen=0;
          FileInputStream fileInputStream = null;
  
          try {
              /*创建FileInputStream对象 用于读取文件*/
              fileInputStream = new FileInputStream(filePath);
              /*从该输入流读取最多b.length字节的数据到字节数组 如果没有输入可用 此方法将阻止
               * 如果返回-1 表示读取完毕
               * 如果读取正常 返回实际读取的字节数*/
              while ((readLen=fileInputStream.read(buf))!=-1){
                  System.out.print(new String(buf,0,readLen));//转成char显示
              }
          } catch (IOException e) {
              throw new RuntimeException(e);
          } finally {
              //一定要关闭文件流 释放资源
              try {
                  fileInputStream.close();
              } catch (IOException e) {
                  throw new RuntimeException(e);
              }
  
          }
  
      }
  }
  • BufferedInputStream：缓冲字节输入流
  • ObjectInputStream：对象字节输入流
  • OutputStream：字节输出流

FileOutputStream

package hspedu.File;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStream01 {
    public static void main(String[] args) {
        writeFile();
    }

    /*演示使用FileOutputStream 将数据写入文件
    * 如果文件不存在 则创建该文件*/
    static public void writeFile(){

        /*创建FileOutputStream对象*/
        String filePath="D:\\Java\\hspedu\\a.txt";
        FileOutputStream fileOutputStream=null;
        try {
            /*1.new FileOutputStream(filePath) 创建方式 当写入内容时 会覆盖原来的内容
            * 2.new FileOutputStream(filePath,true) 创建方式 当写入内容时 会追加到文件后面*/
            fileOutputStream=new FileOutputStream(filePath,true);
            /*1.写入一个字节*/
//            fileOutputStream.write('H');

            /*2.写入多个字符串*/
/*            String str="hello,world";
            *//*str.getBytes() 可以把 字符串->字节数组*//*
            fileOutputStream.write(str.getBytes());*/

            /*3.写入字符串指定范围的数据
            * write(byte[] b,int off,int len) 将len字节从位于off 指定字节数组*/
            String str="hello,world";
            fileOutputStream.write(str.getBytes(),0,str.length());

            System.out.println("写入成功");
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {

            try {
                fileOutputStream.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
  • 使用FileInputStream和FileOutputStream完成文件拷贝
package hspedu.File;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileCopy {
    public static void main(String[] args) {
        /*完成 文件拷贝 将""D:\GoogleDownload\1.jpg"" 拷贝到D:\Java\hspedu */

        /*1.创建文件的输入流 将文件读入到程序
         * 2.创建文件的输出流 将读取到的文件数据 写入到指定的文件*/

        String srcFilePath = "D:\\GoogleDownload\\1.jpg";
        String destFilePath="D:\\Java\\hspedu\\2.jpg";

        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;

        try {
            fileInputStream = new FileInputStream(srcFilePath);
            fileOutputStream=new FileOutputStream(destFilePath);

            /*定义一个字节数组 提高读取效果*/
            byte[] buf=new byte[1024];
            int readLen;
            while ((readLen=fileInputStream.read(buf))!=-1){
                /*读取到后就写入文件 通过fileOutputStream 边读边写*/
                fileOutputStream.write(buf,0,readLen);
            }
            System.out.println("拷贝成功");

        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            /*关流 释放资源*/
            try {
                if (fileInputStream != null) {
                    fileInputStream.close();
                }

                if (fileOutputStream != null) {
                    fileOutputStream.close();
                    }
            } catch (IOException e) {
                System.out.println(e.getMessage());
            }
        }
    }
}

FileReader

image-20240506131059223

  • 相关方法
    • new FileReader(File/String)
    • read:每次获取单个字符 返回该字符 如果到文件末尾 返回-1
    • read(char[ ]):批量读取多个字符到数组 返回读取到的字符数 如果到文件末尾 返回-1
      • new String(char[]):将char[]转换成String
      • new String(char[],off,len):将char[]的指定部分转化成String
  • 样例代码：
package hspedu.File;


import java.io.FileReader;
import java.io.IOException;

public class FileReader01_ {
    public static void main(String[] args) {
//        readFile01();
        readFile02();
    }


    /*单个字符读取*/
    static public void readFile01() {
        String FilePath = "D:\\Java\\hspedu\\story.txt";
        FileReader fileReader = null;
        int data;
        /*1.创建fileReader对象*/
        try {
            fileReader = new FileReader(FilePath);
            /*循环读取 使用read 单个字符读取*/
            while ((data = fileReader.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                if (fileReader != null) {
                    fileReader.close();
                }
            } catch (IOException e) {
                System.out.println(e.getMessage());
            }
        }
    }


    /*字符数组读取*/
    static public void readFile02() {
        String FilePath = "D:\\Java\\hspedu\\story.txt";
        FileReader fileReader = null;

        int readLen=0;
        char[] buf=new char[8];

        /*1.创建fileReader对象*/ 
        try {
            fileReader = new FileReader(FilePath);
            /*循环读取 使用read(buf) 返回的是实际读取到的字符数
            * 返回-1 说明文件结束*/
            while ((readLen = fileReader.read(buf)) != -1) {
                System.out.print(new String(buf,0,readLen));
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                if (fileReader != null) {
                    fileReader.close();
                }
            } catch (IOException e) {
                System.out.println(e.getMessage());
            }
        }
    }
}

FileWriter 继承于Writer

image-20240506131336219

  • 相关方法
    • new FileWriter(File/String):覆盖模式 相当于流的指针在首端
      • FileWriter类的构造函数会在打开文件时自动创建文件。当你使用new FileWriter(FilePath)创建FileWriter对象时，如果指定的文件不存在，Java会尝试创建该文件。因此，即使在代码中没有显式地创建文件的操作，执行程序后文件也会被创建。
    • new FileWriter(File/String,true):追加模式 相当于流的指针在尾端
    • write(int):写入单个字符
    • write(char[]):写入指定数组
    • write(char[],off,len):写入指定数组的指定部分
    • write(string):写入整个字符串
    • write(string,off,len):写入字符串的指定部分
    • String类：toCharArray:将String转换成char[]

FileWriter使用后 必须要关闭(close)或刷新(flush) 否则写入不到指定的文件

  • 样例代码：
package hspedu.File;

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

public class FileWriter_ {
    public static void main(String[] args) {

        String FilePath = "D:\\Java\\hspedu\\note.txt";
        /*创建FileWriter对象*/
        FileWriter fileWriter = null;

        char[] chars={'a','b','c'};

        try {
            fileWriter = new FileWriter(FilePath);//覆盖模式
            //1.write(int):写入单个字符
            fileWriter.write('H');
            //2.write(char[]):写入指定数组
            fileWriter.write(chars);
            //3.write(char[],off,len):写入指定数组的指定部分(指定部分的len表示5个字符)
            fileWriter.write("双刀流天下第一".toCharArray(),0,5);
            //4.write(string):写入整个字符串
            fileWriter.write("你好双刀流!!!");
            //5.write(string,off,len):写入字符串的指定部分*/
            fileWriter.write("双刀流天下第一",0,2);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {

            /*==FileWriter使用后 必须要关闭(close)或刷新(flush) 否则写入不到指定的文件==*/
            try {
                if(fileWriter!=null){
                    fileWriter.close();
                }
            } catch (IOException e) {
                System.out.println(e.getMessage());
            }
        }
        System.out.println("程序结束!");
    }
}

3.节点流和处理流

image-20240506150809863

  • 处理流BufferedReader和BufferedWriter

  • BufferedReader和BufferedWriter属于字符流 是按照字符来读取数据得到

  • 关闭时处理流 只需要关闭外层流

  • BufferedReader 字符流

package hspedu.File;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/*更高效*/
public class BufferedReader_ {
    public static void main(String[] args) throws IOException {

        String FilePath="D:\\Java\\hspedu\\story.txt";

        /*创建bufferedReader*/
        /*因为 FileReader 是 Reader 的子类，可以直接传递给 BufferedReader 的构造方法作为参数*/
        BufferedReader bufferedReader = new BufferedReader(new FileReader(FilePath));

        /*读取*/
        String line;//按行读取
        while ((line=bufferedReader.readLine())!=null){
            System.out.println(line);
        }

        /*关流 关外层流(BufferedReader) 底层会自动关闭节点流*/
        bufferedReader.close();

    }
}
  • **BufferedWriter **字符流
package hspedu.File;


import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriter_ {
    public static void main(String[] args) throws IOException {
        String FilePath="D:\\Java\\hspedu\\ok.txt";

        /*创建BufferedWriter对象*/
        /*覆盖方式写入*/
//      BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(FilePath));

        /*追加方式写入*/
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(FilePath,true));

        bufferedWriter.write("Hello syhsyh");
        /*插入换行*/
        bufferedWriter.newLine();
//      bufferedWriter.write("\n");


        bufferedWriter.write("Hello syhsyh");


        /*关闭外层流即可 底层自动关闭new FileWriter(FilePath)*/
        bufferedWriter.close();
    }
}
  • BufferedReader和BufferedWriter 进行文本/字符文件的拷贝
package hspedu.File;

import java.io.*;

public class BufferedCopy_ {
    public static void main(String[] args) {

        /*BufferedReader和BufferedWriter 操作的是字符文件
        * 不可操作 二进制文件(声音 视频 word) 可能会导致文件损坏*/
        String srcFilePath="D:\\Java\\hspedu\\story.txt";
        String destFilePath="D:\\Java\\hspedu\\b.txt";

        BufferedReader br=null;
        BufferedWriter bw=null;
        String line;

        try {
            br=new BufferedReader(new FileReader(srcFilePath));
            bw=new BufferedWriter(new FileWriter(destFilePath));

            while ((line=br.readLine())!=null){
                bw.write(line);
                bw.newLine();
            }
            System.out.println("完成");
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            try {
                assert br != null;
                br.close();
                assert bw != null;
                bw.close();
            } catch (IOException e) {
                System.out.println(e.getMessage());
            }
        }
    }
}
  • BufferedInputStream 字节流

image-20240507020957951

image-20240507021025756

  • BufferedOutputStream 字节流

image-20240507021105564

image-20240507021311679

  • 使用BufferedInputStream和BufferedOutputStream进行二进制文件的拷贝
package hspedu.File;

import java.io.*;
/*使用BufferedInputStream和BufferedOutputStream进行二进制文件的拷贝*/
public class BufferedCopy02_ {
    public static void main(String[] args) {

        /*BufferedInputStream和BufferedOutputStream既可以操作文本文件 也可以操作二进制文件*/
        String srcFilePath="D:\\Java\\hspedu\\2.jpg";
        String destFilePath="D:\\Java\\hspedu\\3.jpg";

        /*创建对象*/
        BufferedInputStream bis=null;
        BufferedOutputStream bos=null;

        try {
            /*因为FileInputStream继承了InputStream*/
            bis=new BufferedInputStream(new FileInputStream(srcFilePath));
            bos=new BufferedOutputStream(new FileOutputStream(destFilePath));

            /*循环读取文件 写入destFilePath*/
            byte[] buff=new byte[1024];
            int readLen;
            while((readLen= bis.read(buff))!=-1){
                bos.write(buff,0,readLen);
            }

            System.out.println("完成");
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {

            /*关流*/
            try {
                if(bis!=null) {
                    bis.close();
                }
                if(bos!=null) {
                    bos.close();
                }
            } catch (IOException e) {
                System.out.println(e.getMessage());
            }
        }

    }
}
  • 对象处理流

image-20240507023507609

  • 推荐实现Serializable(中文:可序列化的)接口

image-20240507023532005

  • ObjectOutputStream
  • image-20240507024105758
    • 提供序列化功能
  • ObjectInPutStram
  • image-20240507024008453
    • 提供反序列化功能
Massive.
关注
Java IO流（超详细！）
一只小菜鸡
05-07 6万+
一、什么是IO流 I : Input O : Output 通过IO可以完成硬盘文件的读和写。 二、IO流的分类 按照 流的方向 进行分类： 以内存作为参照物： 往内存中去：叫做输入(Input)。或者叫做读(Read)。 从内存中出来：叫做输出(Output)。或者叫做写(Write)。 按照 读取数据方式 不同进行分类： 按照 字节 的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。 这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文
javaIO流详解
weixin_46676497的博客
01-27 3570
java常用io流介绍
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 16万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
Java io流 详解
m0_68987535的博客
06-11 5096
"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）...
JavaIO流：模型
栗筝i的博客
11-24 4057
IO 的字面意思是读/写数据，IO 模型是读/写数据的方式。常用到的读/写数据方式有：同步阻塞 IO、同步非阻塞 IO、IO 多路复用、信号驱动、异步 IO 本篇内容包括：Java IO 与 IO 模型、五种 IO 模型、三种 Java IO 模型。
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 3460
Java IO流的种类
java IO流之BufferedReader和BufferedWriter
学习笔记，相关教程 分享
04-03 6376
笑霸能看懂的学习笔记
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析 Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的基础。Java中的IO流主要包括两种类型：字节流和字符流。字节流用于处理二进制数据，而...
JAVA IO流缓冲字节流缓冲字符流等流经典代码示例加注释总结.rar
11-30
2、常用21个IO流：FileWriter、FileReader、...3、JAVA IO流经典代码示例，示例从易到难。代码功能涉及字节、字符、字符串、文本文件、图片、音频、视频。演示错误用法和经典用法。 4、代码的结构可查看README文件。
javaIO流javaIO流javaIO流
07-02
Java IO流是Java平台中用于处理输入输出操作的核心机制，它允许程序与各种数据源（如文件、设备、网络）进行交互。Java IO流体系结构是基于“流”的概念，流是一组有序的数据序列，可以是字节流或字符流。Java IO库...
java IO流将一个文件拆分为多个子文件代码示例
08-28
Java IO流将一个文件拆分为多个子文件代码示例 Java IO流是一个文件流处理的基础组件，它提供了基本的文件读取和写入操作。将一个文件拆分为多个子文件是文件处理中一个常见的需求，例如上传大文件时，可以先分割成...
【Netty系列】Netty 框架介绍
技术改变世界
05-28 526
Netty是一个基于 Java NIO（Non-blocking I/O）的异步事件驱动网络应用框架，旨在快速开发高性能、高可靠性的网络服务器和客户端。它简化了 TCP/UDP 等协议的编程，并提供了高度可定制的组件，适用于高并发场景（如游戏服务器、即时通讯、分布式系统等）。
Github 2025-05-30Java开源项目日报Top10
最新发布
老孙正经胡说
05-30 845
根据Github Trendings的统计，今日(2025-05-30统计)共有10个项目上榜。
计算机组成原理——cache
Yan_ks的博客
05-27 920
本文介绍了cache的工作原理及优化策略。主要内容包括：1)局部性原理(时间/空间局部性)，以程序示例说明访问顺序对性能的影响；2)cache组成与访问流程，包括命中率计算和地址映射关系；3)三种映射方式(直接、全相联、组相联)的实现原理；4)替换算法(LRU、随机、FIFO)的选择标准；5)两种写策略组合(全写+非写分配、回写+写分配)的特点及应用场景。通过cache设计有效利用局部性原理，可显著提升CPU访存效率。
springboot--实战--大事件--用户接口开发
m0_73856804的博客
05-27 1806
定义了一种简洁的、自包含的格式，用于通信双方以JSON数据格式安全的传输信息。组成：第一部分：Header（头），记录令牌类型、签名算法等。例如,算法用于防篡改第二部分：Payload（有效载荷），携带一些自定义信息，默认信息。例如。而外在表示为一段无规律的64个可打印字符原因：借助base64编码方式（Base64：是一种基于64个可打印字符（A-Z a-z 0-9 + /）来表示二进制数据的编码方式）来完成，将json字符串变为64个可打印字符，
Java IO流实践案例解析大全
标题“java io流的实践案例大全”直接指出了文档的主旨，即提供了大量关于Java I/O流的实际操作案例。通过这些案例的展示，初学者和有经验的开发者都能从中获得必要的信息来增强他们在Java I/O操作方面的能力。 ###...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值