Java笔记之IO流（二十七）

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量73 收藏
点赞数
分类专栏： 自学Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44604159/article/details/125828766
版权

学习目录

一、节点流和处理流

1.基本介绍

节点流：可以从一个特定的数据源读写数据，如FileReader、FileWriter。

处理流：也叫包装流，是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader。处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。

节点流（绿）和处理流（红）一览表：
在这里插入图片描述

2.两者的区别和联系

  • 节点流是底层流/低级流，直接根据数据源相接
  • 处理流（包装流）包装其其节点流，既可以消除不同节点流的实现差异 ，也可以提供更方便的方法来完成输入输出
  • 处理流也叫包装流对节点流进行包装，使用了修饰设计模式，不会直接与数据源相连（底层是模拟修饰器设计模式）

3.处理流功能体现

  1. 性能的提高：主要以增加缓冲的方式来提高输入输出的效率
  2. 操作的便捷：处理流可能提供一系列便捷的方法来一次输入输出大批量的数据，使用更加灵活方便

下面通过简单的代码模拟说明处理流（会有种醍醐灌顶的感觉）

模拟一下底层处理流的设计模式（修饰器设计模式）

public class test {
    public static void main(String[] args) {
        BufferedReader_ bufferedReader_1 = new BufferedReader_(new FileReader_());
        bufferedReader_1.readFile();
        System.out.println("===============");
        bufferedReader_1.readFiles(5);

        BufferedReader_ bufferedReader_2 = new BufferedReader_(new StringReader_());
        System.out.println("===============");
        bufferedReader_2.readStrings(5);
    }
}

/**
 * 定义一个抽象类，放两个抽象方法
 */
abstract class Reader_ {
    public void readFile(){}
    public void readString(){}
}

/**
 * 模拟一个读文件的节点流
 */
class FileReader_ extends Reader_{
    @Override
    public void readFile() {
        System.out.println("对文件进行读取");
    }
}

/**
 * 模拟一个读字符串的节点流
 */
class StringReader_ extends Reader_{
    @Override
    public void readString() {
        System.out.println("对字符串进行读取");
    }
}

/**
 * 模拟一个包装类，实现多个功能
 */
class BufferedReader_ extends Reader_{
    private Reader_ reader_;    //属性为Reader_类型

    public BufferedReader_(Reader_ reader_) {
        this.reader_ = reader_;
    }

    //读取一次文件，读取字符串同类
    public void readFile(){    //相当于封装一层
        reader_.readFile();
    }

    //让方法更加灵活，多次读取文件
    public void readFiles(int num){
        for (int i = 0; i < num; i++) {
            reader_.readFile();
        }
    }

    public void readStrings(int num){
        for (int i = 0; i < num; i++) {
            reader_.readString();
        }
    }
}

以上代码也可以进行优化，用多态的动态绑定机制

public class test {
    public static void main(String[] args) {
        BufferedReader_ bufferedReader_1 = new BufferedReader_(new FileReader_());
        bufferedReader_1.read();
        bufferedReader_1.reads(5);

        BufferedReader_ bufferedReader_2 = new BufferedReader_(new StringReader_());
        bufferedReader_2.read();
        bufferedReader_2.reads(5);
    }
}

/**
 * 定义一个抽象类，放两个抽象方法
 */
abstract class Reader_ {
    public abstract void read();
}

/**
 * 模拟一个读文件的节点流
 */
class FileReader_ extends Reader_{
    @Override
    public void read() {
        System.out.println("对文件进行读取");
    }
}

/**
 * 模拟一个读字符串的节点流
 */
class StringReader_ extends Reader_{
    @Override
    public void read() {
        System.out.println("对字符串进行读取");
    }
}

/**
 * 模拟一个包装类，实现多个功能
 */
class BufferedReader_{
    private Reader_ reader_;    //属性为Reader_类型

    public BufferedReader_(Reader_ reader_) {
        this.reader_ = reader_;
    }

    public void read(){
        reader_.read();
    }

    //让方法更加灵活，多次读取
    public void reads(int num){
        for (int i = 0; i < num; i++) {
            reader_.read();
        }
    }
}

二、包装流BufferedReader和BufferedWriter

BufferedReader和BufferedWriter均为字符处理流，关闭流时只需要关闭外层流即可，不可以处理二进制文件（如：音频、视频）

1.BufferedReader

基本介绍
BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，具体方法的详细使用请看API
在这里插入图片描述
快速入门
读取一个文本文件，并把读取内容输出到控制台上

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

public class test {
    public static void main(String[] args) throws IOException {
        String path = "F:\\test.txt";
        BufferedReader bufferedReader = new BufferedReader(new FileReader(path));
        String line = null;
        //按行读取，效率高，readLine方法没有换行功能
        //当读到流的末尾，则返回为null
        while ((line = bufferedReader.readLine()) != null){
            System.out.println(line);
        }
        //这里只需要关闭BufferedReader流即可，底层代码会自动关闭FileReader
        if(bufferedReader != null){
            bufferedReader.close();
        }
    }
}

2.BufferedWriter

基本介绍
BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，具体方法的详细使用请看API
在这里插入图片描述
快速入门
将内容写入一个文本文件中

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

public class test {
    public static void main(String[] args) throws IOException {
        String path = "F:\\test1.txt";
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(path));       //覆盖的形式
//        BufferedWriter bufferedWriter1 = new BufferedWriter(new FileWriter(path,true));       //追加的形式
        //注意，这里不会换行
        bufferedWriter.write("你好java");
        bufferedWriter.newLine();   //插入换行
        bufferedWriter.write("你好scala");
        bufferedWriter.newLine();   //插入换行
        bufferedWriter.write("你好python");

        //关闭流,FileWriter也会关闭
		if (bufferedWriter !=null){
            bufferedWriter.close();
        }
    }
}

3.综合小案例-复制

import java.io.*;

public class test {
    public static void main(String[] args) throws IOException {
        String path = "F:\\test1.txt";
        String path1 = "F:\\test2.txt";

        BufferedReader bufferedReader = new BufferedReader(new FileReader(path));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(path1));
        String line = null;

        while ((line = bufferedReader.readLine()) != null){
            bufferedWriter.write(line);
            bufferedWriter.newLine();
        }

        if(bufferedReader != null){
            bufferedReader.close();
        }
        if (bufferedWriter !=null){
            bufferedWriter.close();
        }
    }
}

二、包装流BufferedOutputStream和BufferedInputStream

这里是引用BufferedOutputStream和BufferedInputStream均为自己处理流，关闭流时只需要关闭外层流即可，既可以处理二进制文件又可以处理文本文件

BufferedOutputStream和BufferedInputStream具体方法使用和上面差不多，具体方法的使用请看API

1.综合小案例-复制

import java.io.*;
public class test {
    public static void main(String[] args) throws IOException {
        String path = "F:\\java.jpeg";
        String path1 = "F:\\java1.jpeg";
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;

        //FileInputStream是InputStream的子类，所有可以作为BufferedInputStream的参数;
        //BufferedOutputStream同理
        bis = new BufferedInputStream(new FileInputStream(path));
        bos = new BufferedOutputStream(new FileOutputStream(path1));
        byte[] bytes = new byte[1024];  //每次读取的大小
        int readlen = 0;
        //bis.read(bytes)返回类型为int，返回-1时，表示文件读取完毕
        while ((readlen = bis.read(bytes)) != -1){
            bos.write(bytes,0,readlen);
        }

        //关闭BufferedInputStream和BufferedOutputStream即可
        //FileInputStream和FileOutputStream会自动关闭
        if (bis != null){
            bis.close();
        }
        if (bos != null){
            bos.close();
        }
    }
}

下面代码和上面功能一样，只是把异常用try/catch包起来了

import java.io.*;
public class test {
    public static void main(String[] args) {
        String path = "F:\\java.jpeg";
        String path1 = "F:\\java1.jpeg";
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;

        try {
            bis = new BufferedInputStream(new FileInputStream(path));
            bos = new BufferedOutputStream(new FileOutputStream(path1));
            byte[] bytes = new byte[1024];  //每次读取的大小
            int readlen = 0;
            //bis.read(bytes)返回类型为int，返回-1时，表示文件读取完毕
            while ((readlen = bis.read(bytes)) != -1){
                bos.write(bytes,0,readlen);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bis != null){
                    bis.close();
                }
                if (bos != null){
                    bos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
王博1999
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java基础篇之IO流，动力节点老杜详细笔记
qq_45769329的博客
01-21 1180
详细讲解IO流，主要聚焦如何使用、掌握常用方法等
java学习笔记之IO流总结(一）
不懂编程的程序员都是在耍流氓
10-14 3621
输入输出作为所有程序都必需的部分   对于我们的java学习有特别重要的意义，以至于博主辛苦看了三天的流分布，跟大家分享一下 一.首先我们说一下io流的概念 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。简单的说这就是计算机传输数据的方式  输入流主要体现在我们从
（Java笔记）IO流的六类16种流方式
张松的博客
04-26 2947
IO流的四大类16种流方式
java IO流之BufferedReader和BufferedWriter
学习笔记，相关教程 分享
04-03 6203
笑霸能看懂的学习笔记
javaIO流之转换流
恒二哥的博客
05-19 2172
转换流可以将一个字节流包装成字符流，或者将一个字符流包装成字节流。这种转换通常用于处理文本数据，如读取文本文件或将数据从网络传输到应用程序。转换流主要有两种类型：InputStreamReader 和 OutputStreamWriter。InputStreamReader 将一个字节输入流转换为一个字符输入流，而 OutputStreamWriter 将一个字节输出流转换为一个字符输出流。它们使用指定的字符集将字节流和字符流之间进行转换。常用的字符集包括 UTF-8、GBK、ISO-8859-1 等。
java中的io流
m0_66689823的博客
07-19 9736
流是一种抽象概念，它代表了数据的无结构化传递。按照流的方式进行输入输出，数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作，而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO流。换句话说，IO流就是以流的方式进行输入输出 。
java笔记二（IO流与json）
百般回首曾经的相遇，留下的只是一缕残忆
04-07 1890
注：导包问题自行解决 模板类 /* 商家，设计商家模型 */ public class Merchant { //商家名称 private String name; //商家地址 private String address; //商家菜品 private Dishes[] dishes; //经度 private double l...
Java笔记_18(IO流)
weixin_74155781的博客
05-08 1668
IO流存储和读取数据的解决方案用于读写文件中的数据（可以读写文件，或网络中的数据…)纯文本文件：用windows系统自带的记事本打开并且能读懂的文件。
【Java笔记】IO流-数据流（DataInputStream 和 DataOutputStream）
lijibai_的博客
04-23 3031
为了方便地操作 Java 语言的基本数据类型和 String 的数据，可以使用数据流 数据流的使用 数据流有两个类：DataInputStream 和 DataOutputStream，分别 “套接” 在 InputStream 和 OutputStream 子类的流上 数据流用于读取或写入基本数据类型的变量或字符串 注：读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致 代码举例 import org.junit.Test; import java.io.*; public
【Java】之IO流
m0_67388084的博客
10-25 1298
IO：输入/输出（Input/Output）。流：是一种抽象概念，是对数据传输的总称，数据在设备间的传输称为流。IO流：用来处理设备间数据传输的问题。
java IO流详细笔记
07-12
Java IO流详解
Java 的 IO流笔记.md
03-08
Java IO流的笔记，写了常用的类和方法的示例，以及部分Apache的commons-io的IO类，如果没有积分，可以到我的博客里查看下载
Java学习笔记之IO流
08-11
详细介绍了IO的用法，基本实现原理，并介绍了序列化与反序列化的实现方法。谢谢
java IO流学习笔记
12-12
java IO流学习笔记
JAVAEE之多线程进阶（2）_ CAS概念、实现原理、ABA问题及解决方案
2301_80653026的博客
05-29 1363
CAS全称Compare and swap，字面意思:”比较并交换“，它是一条 CPU 并发原语，用于判断内存中某个值是否为预期值，如果是则更改为新的值，这个过程是原子的。全称 Compare and swap, 即 “比较并交换”. 相当于通过一个原子的操作, 同时完成 “读取内存, 比较是否相等, 修改内存” 这三个步骤. 本质上需要 CPU 指令的支撑。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 873
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1194
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 485
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
黑马程序员io流笔记
07-29
根据提供的引用内容，IO流是Java中用于处理输入和输出的机制。在Java中，有字节流和字符流两种类型的IO流。字节流是以字节为单位进行操作的，而字符流是以字符为单位进行操作的。字节流更加方便且在处理图片、音频等...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

王博1999

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值