IO流的字节流和字符流，之后衍生出来的处理流{缓冲流，转换流，对象流}(字符缓冲流遇到一些bug，待完善)

最新推荐文章于 2024-10-09 11:13:12 发布
最新推荐文章于 2024-10-09 11:13:12 发布
阅读量328 收藏 6
点赞数 3
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64417283/article/details/140827969
版权

声明

在了解处理流的时候我们要了解一些基本内容，如上图的IO流体系所示，在图中，蓝色的。InputStream，OutputStram这二个是字节流的父类，Reader，Writer是字符流的父类，下方箭头代红色框内代表的是他们的子实现类，这些流是最基础的流！，一切的处理流都需要有基础流，才能实现功能。

缓冲流

作用，就是为了加快传输速度。以下代码做了不使用缓冲流和使用缓冲流的区别，首先要准备一个内存大小足够的文件（图片，音频，文档都可以）

字节缓冲流


文档准备：我的文档为59mb大小
不使用缓冲流的情况

代码如下

 public static void main(String[] args) throws Exception {
//        注意字节流和字符流的区别 
        InputStream is=new FileInputStream("src/com/haogu/write.txt");

        OutputStream os=new FileOutputStream("src/com/haogu/write2.txt");

        System.out.println("在不使用缓冲流的情况下");
        byte[] bytes=new byte[1024];
        long start=System.currentTimeMillis();

        int num;
        while ((num=is.read(bytes))!=-1){
         os.write(bytes);
        };
        long end=System.currentTimeMillis();
        System.out.println("执行时间为"+(end-start)+"毫秒");



        is.close();
        os.close();
    }
使用缓冲流的情况
 public static void main(String[] args) throws Exception {
        InputStream is=new FileInputStream("src/com/haogu/write.txt");
        InputStream bis=new BufferedInputStream(is);
        OutputStream os=new FileOutputStream("src/com/haogu/write2.txt");
        OutputStream bos=new BufferedOutputStream(os);
        Long start2=System.currentTimeMillis();
        byte[] bytes=new byte[1024];
     

        int num;
//        缓冲流处理 循环的时候就用缓冲流
        while((num=bis.read(bytes))!=-1){
            bos.write(bytes);
        }

        long end2=System.currentTimeMillis();
        System.out.println("使用缓冲流执行时间为"+(end2-start2)+"毫秒");
        bis.close();
        is.close();
        bos.close();
        os.close();
    }

可以看到，传输的速度极大的加快了。

字符缓冲流

字符缓冲流和字节缓冲流相比，字符缓冲流中多了一些方法，可以让我们更好处理文档的数据

在不使用缓冲流的情况下处理
public static void main(String[] args) throws Exception {
        //字符缓冲流 ，二种处理方式
        Reader re=new FileReader("src/com/haogu/java02/write.txt");

        Writer  wi=new FileWriter("src/com/haogu/java02/write2.txt");


        char[] chars=new char[1024];
        int num;
        long start=System.currentTimeMillis();
        System.out.println("不使用缓冲流使用最普通的流处理");
        while((num=re.read(chars))!=-1){
            wi.write(chars);
        }
        Long end=System.currentTimeMillis();
        System.out.println("运行时间时间为"+(end-start)+"毫秒");
        
    }
使用字符缓冲流但是不使用字符缓冲流中特有的方法来处理
使用字符缓冲流的新方法

因为文件里面是空的所以先运行一次之后才会读取到数据，否则只是插入数据，是读取不到数据的

   public static void main(String[] args) throws Exception {
        Reader r=new FileReader("src/com/haogu/java02/write3.txt");
//  todo 使用BufferedReader内的方法来处理循环
        BufferedReader br=new BufferedReader(r);
        Writer w=new FileWriter("src/com/haogu/java02/write3.txt");
//        todo 使用BufferedWrite内的方法来处理循环
        BufferedWriter bw=new BufferedWriter(w);
//        按照行来读取
//        readLine读取完毕之后读取的就是null
       String num;
       while ((num=br.readLine())!=null){
//           注意区别
           System.out.println(num);
       }
//       对于写入
//        换行
        bw.write("随意内容");
        bw.write("随意内容");
        bw.write("随意内容");
        bw.newLine();
        bw.write("随意内容");
        bw.write("随意内容");
        bw.write("随意内容");
br.close();
r.close();
bw.close();
w.close();
    }

运行二次之后就可以读出第一次的数据了，会发现第一次插入的数据是按照行来读取的

 

转换流 

文档准备：

jdk默认的编码是utf-8在这里准备一个 编码格式是GBK的文档
 

转换输入流（读取）

使用默认方式读取

代码如下

 public static void main(String[] args) throws Exception {

        InputStream is=new FileInputStream("src/com/haogu/Java03/write3.txt");
        int num;
        byte[] bytes=new byte[100];
        while ((num=is.read(bytes))!=-1){
            System.out.println(new String(bytes,0,num));
        }



        is.close();



    }

 发现大部分乱码

使用转换流来读取 
  public static void main(String[] args) throws Exception {
        InputStream is=new FileInputStream("src/com/haogu/Java03/write3.txt");
        //      转换流都是吧字节流转化为字符流 传入的参数就是字节流，和需要你转换的格式
//        格式为 InputStreamReader
        InputStreamReader ir=new InputStreamReader(is,"GBK");
        System.out.println("用转换流来读取");
        char[] chars=new char[100];

        while ((ir.read(chars))!=-1){
            System.out.println(new String(chars));
        }
}

发现可以正常的读取

转换输出流

默认输出方式
 public static void main(String[] args) throws Exception {
//        转换流输出
       try( OutputStream os=new FileOutputStream("src/com/haogu/Java03/write3.txt",true);

               ) {
           String str="用常规方式输入错误编码格式的内容";
           byte[] bytes=str.getBytes();
           os.write(bytes);
       }catch (Exception e){
           e.printStackTrace();
       }
    }

可以看到文件里面乱码了，这是因为jdk默认utf-8和GBK不兼容导致

使用转换流输入 

代码如下

 public static void main(String[] args) throws Exception {
        try( OutputStream os=new FileOutputStream("src/com/haogu/Java03/write3.txt",true);
             OutputStreamWriter ow=new OutputStreamWriter(os,"gbk")
        ) {
            ow.write("/n传入正确的格式");
        }catch (Exception e){
            e.printStackTrace();
        }



    }

数据流 

数据流：正常情况下我们只能往文件里面输入 普通的符合Unicode编码的值，而无法直接输入整形，浮点型，以及字符串等等，通过数据流可以实现这些不同类型的数据的传输，输入进去的数据是加密的 但是在读取的时候计算机是可以识别的
注意读取时候的注意事项，在代码中已经注释了
  public static void main(String[] args) throws Exception {
//        todo 数据流：正常情况下我们只能往文件里面输入 普通的符合Unicode编码的值，而无法直接输入
//          整形，浮点型，以及字符串等等，通过数据流可以实现这些不同类型的数据的传输，
//          输入进去的数据是加密的 但是在读取的时候计算机是可以识别的
        try(      OutputStream os=new FileOutputStream("src/com/haogu/Java04/write04.txt");
                  DataOutputStream dos=new DataOutputStream(os);

                ) {
        dos.write(67);
      dos.writeInt(132);
      dos.writeLong(1111111111);
      dos.writeBoolean(true);
      dos.writeDouble(3.1415926);
      dos.writeUTF("数据流的测试");
        }catch (Exception e){
            e.printStackTrace();
        }
//       todo 数据流的读取
        try(  InputStream is=new FileInputStream("src/com/haogu/Java04/write04.txt");
              DataInputStream dis=new DataInputStream(is);
              ){
//            todo  注意读取的时候必须根据你输入的顺序进行读取 否则会出现数据不准确或者报错
            System.out.println(dis.read());
            System.out.println(dis.readInt());
            System.out.println(dis.readLong());
            System.out.println(dis.readBoolean());
            System.out.println(dis.readDouble());
            System.out.println(dis.readUTF());


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



    }

对象流（序列化） 

对对象进行序列化的时候，对象要实现序列化的接口，否则会报序列化异常的错误

准备工作

准备一个类
 

public class Student implements Serializable {
    private String name;
    private  Integer age;
    private  String sex;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

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

序列化’

代码如下

   public static void main(String[] args) throws Exception {
        Student student = new Student("张三",15,"男");
        try(
               OutputStream os=new FileOutputStream("src/com/haogu/java05/write05.txt");
               ObjectOutputStream oos=new ObjectOutputStream(os);
               ){
//            记得让student实现序列化的接口
           oos.writeObject(student);
       }catch (Exception e){
           e.printStackTrace();
       }
    }

 一下是序列化得到的信息

反序列化 

 public static void main(String[] args) {
        try (
                InputStream is=new FileInputStream("src/com/haogu/java05/write05.txt");
                ObjectInputStream ois=new ObjectInputStream(is);
                ){
            System.out.println(  ois.readObject());

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

序列化还可以得到无法打开的文件

public static void main(String[] args) {
        Student student = new Student("张三", 15, "男");
        try(
                OutputStream os=new FileOutputStream("src/com/haogu/java05/write05.test");
                ObjectOutputStream oos=new ObjectOutputStream(os);
                ){
            oos.writeObject(student);
        }catch (Exception e){

        }
    }

 

但是我们的程序可以正常去读取
读取

 public static void main(String[] args) {
        try(
                InputStream is=new FileInputStream("src/com/haogu/java05/write05.test");
                ObjectInputStream isr=new ObjectInputStream(is);
                ){
            System.out.println(isr.readObject());

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

如履灬薄冰丿
关注
十五、Java中I/O流
康宁的博客
04-24 490
转换流（InputStreamReader和OutputStreamWriter）是Java中用于在字节流和字符流之间进行转换的桥梁。它们可以将字节流转换为字符流，并提供了字符编码的功能。转换流的主要作用是将字节流解析成字符流，在读取字节数据或写入字符数据时完成字符编码和解码的过程。这样可以处理特定编码格式的文本数据，例如将字节流转换为字符流以支持UTF-8或GBK编码。BufferedReader是Java中的一个输入流类，用于从字符流中读取文本。
12 Java文件处理之写入、读取：IO流（上）：基本流：字节流（FileOutputStream和FileInputStream）、字符流（FileReader和FileWriter）
smalltorch的博客
09-12 965
本节我们先来介绍IO流的基本体系，并且先来学习基本流IO流：文件的读写和存储解决方案IO流的分类：根据流的方向分为输入流（读取）、输出流（写出）根据操作文件的类型分为字节流（以字节为基本单位进行数据的传输）、字符流（以字符char为单位进行数据的传输）；字节流(8 bit)，字符流(16 bit)字节流：可以操作所有类型的文件（视频、音频、纯文本等）字符流：只能操作纯文本文件（txt文件和md文件、xml文件等）什么是文件？文件就是保存数据的地方。
java io 装饰流_java IO流的继承体系和装饰类应用
weixin_28731231的博客
02-16 128
java IO流的设计是基于装饰者模式&适配模式，面对IO流庞大的包装类体系，核心是要抓住其功能所对应的装饰类。装饰模式又名包装(Wrapper)模式。装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。装饰模式通过创建一个包装对象，也就是装饰，来包裹真实的对象。装饰模式以对客户端透明的方式动态地给一个对象附加上更多的责任。换言之，客户端并不会觉得对象在装饰前和装饰后有什...
Java必备基础十六——输入与输出流相关类详细介绍
Pandafz的博客
09-29 2748
真正能让你走远的，都是自律、积极和勤奋
java io流大全_java IO流-学习整理汇总
weixin_34282558的博客
03-06 113
java IO流1：概念java中的流，他的概念源于unix中管道(pipe)的概念，在unix中，管道是一条不间断的字节流，用于实现程序或者进程之间的通信，或者读写外围设备，外围文件等。2：分类输入输出流：根据文件流的流向，分为输入流和输出流，字节流和字符流：针对处理的对象是字符还是字节，分为字符流和字节流，字节流：一般读入或读出的是8位二进制数据，InputStream是所有字节输入流的祖先，...
JAVA-IO流体系
借你一秒
05-06 398
JAVA-IO流体系 在IO中，具体构件角色是节点流，装饰角色是过滤流。 1、继承自InputStream/OutputStream的流都是用于向程序中输入/输出数据，且数据的单位都是字节(byte=8bit)，如图，深色的为节点流，浅色的为过滤流。 2、继承自Reader/Writer的流都是用于向程序中输入/输出数据，且数据的单位都是字符(2byte=16bit)，如图，深色的为节点流，浅色...
Java IO流介绍以及缓冲为何能提升性能
A乐神的博客
01-03 1239
Java IO流介绍以及缓冲为何能提升性能
IO第十一回：处理流之四：标准输入流 & 标准输出流
japson的专栏
03-15 368
IO第十一回：处理流之四：标准输入流 & 标准输出流标签： IO流IO第十一回处理流之四标准输入流 标准输出流 Systemout out的定义 记录日志文件 Systemin Systemin原理 简单标准输入 Scanner类对象 构造方法 重要方法 代码演示 在IO中，标准输入流是System.in，标准输出流是System.out。我们经常使用它们，我们今天要学一学他们的原理System.
文件和流笔记
lx__angel的博客
07-04 200
成员变量可以被访问控制符修饰，而局部变量却不可以被public ,private ,protect,static修饰。 成员变量有默认值（被final修饰的没有，被static修饰的必须显示赋值），而局部变量不会自动赋值。   流式输入输出的特点是，数据的获取和发送沿着数据的顺序进行，即每一个数据都必须等待排在它前面的数据完成输入或是输出。 InputStream、OutputStream
IO流---
m0_53450038的博客
07-03 159
io
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的输入输出流
blue丶的博客
08-24 655
一、输入输出流      读入一个字节序列的对象叫做输入流,写入一个字节序列的对象叫做输出流 抽象类InputStream和OutputStream是Java输入输出流的基础，字节相关操作的对象都继承自这两个。      InputStream和OutputStream有两个抽象的方法，由此衍生出来的类都实现了这两个方法，分别为: abstarct int read(); abstarct int write();     很多时候，我们需要处理Unicode形式的存储信息，因为各国文字的差异，Unico
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1248
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 938
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
FoolRabbit的专栏
10-06 366
JDK1.0主要特性。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 707
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
Java中的break、continue和return语句
weixin_73230994的博客
10-05 380
break语句用于终止某个语句块的执行，一般使用在switch或者循环【for, while ,do-while】（提前退出或结束循环不是终止程序）1.continue语句用于结束本次循环，继续执行下一次循环2.continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用规则一样。
Netty 相比原生IO模型的优势
最新发布
lssffy的博客
10-09 373
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
Java IO流详解：字节流与字符流的缓冲操作
"Java IO（输入输出）.pptx 是一份关于Java中输入输出操作的教程，涵盖了字节流、字符流、缓冲流以及File类的相关知识，旨在帮助学习者熟练掌握文件读写和文件系统访问。" 在Java中，IO（输入输出）流是处理数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值