什么是IO,初级Java怎么更好的理解IO流(上)

2023-12-25 16:29:33

(注:本篇文章分为两个部分,如果想更为深刻的了解IO,请关注下一篇;欢迎大家学习讨论和批评指正)

IO1

作用

将数据在虚拟机内存和本地磁盘之间进行传输

I:input 输入

O:output 输出

相当于管道,作用为进行数据传输

分类

  1. 从传输方向上看

    • 输入流:本地磁盘的数据向JVM传输
    • 输出流:JVM数据向本地磁盘传输
  2. 从传输单位上看

    • 字节流:以字节为单位进行数据传输。可以传输任意类型的数据,如文本、图片、视频、音频等
    • 字符流:以字符为单位进行数据传输。只能传输文本类型的数据,如.txt、.java、.html等
  3. 从传输功能上看

    • 节点流:具有传输功能和意义的流
    • 过滤流:没有传输功能,用来给节点流增强传输能力或增加附加功能

字节流

  • 输入流:InputStream 抽象父类
  • 输出流:OutputStream 抽象父类

输入流

  • 节点流:FileInputStream
创建
FileInputStream fis=new FileInputStream("本地的文件路径");
  • 路径:

    • 绝对路径:以电脑磁盘为基点的完整路径

      FileInputStream fis = new FileInputStream("D:\\test\\a.txt");
      FileInputStream fis = new FileInputStream("D:/test/a.txt");
      
    • 相对路径:以当前项目路径为基点的路径,前提是文件必须在项目下

      FileInputStream fis = new FileInputStream("file\\a.txt");
      FileInputStream fis = new FileInputStream("file/a.txt");
      
    • 路径书写必须截至至文件

    • 文件必须存在,否则抛出异常

常用方法
  1. void close():关闭流链接,释放相关资源。(每个流中都有)
  2. int read(): 读取一个字节返回,读取到达末尾,返回-1
  3. int read(byte[] b): 尝试读取数组长度的数据至数组中, 返回实际读取个数.读取到达末尾,返回-1
package com.by.test;

import java.io.FileInputStream;

public class TestFIS {
    public static void main(String[] args)throws Exception {
        // FileInputStream fis = new FileInputStream("D:\\test\\a.txt");
        //  FileInputStream fis = new FileInputStream("D:/test/a.txt");

        // FileInputStream fis = new FileInputStream("C:\\Users\\Administrator\\IdeaProjects\\Chp16\\file\\a.txt");
         FileInputStream fis = new FileInputStream("file\\a.txt");
         //FileInputStream fis = new FileInputStream("file/a.txt");
        //读取一个字节
        //利用循环读取文件所有内容
        while (true) {
            //先接收本次读取内容
            int n = fis.read();
            //判断读取是否到达末尾
            if (n == -1) {
                break;
            }
            //未到达末尾,输出查看
            System.out.println((char) n);
        }

        //利用read(byte[])+循环读取文件所有内容
        while (true) {
            byte[] bs = new byte[3];
            //接收本次读取结果
            int n = fis.read(bs);
            //判断读取是否到达末尾
            if (n == -1) {
                break;
            }
            //遍历数组查看本次读取结果
            for (int i = 0; i < bs.length; i++) {
                System.out.println(bs[i]);
            }
        }



        //关流
        fis.close();

        System.out.println("执行成功!");
    }
}

输出流

  • 节点流:FileOutputStream
创建
FileOutputStream fos=FileOutputStream("本地的文件路径",true|false);
  • 如果文件不存在,会自动创建
    • 无法创建文件夹
  • true表示数据追加,false表示数据覆盖
    • 默认是false
常用方法
  1. void flush(): 刷新缓冲区,所有输出流中都具备该方法
  2. void write(int ): 向目标文件写入一个字节
  3. void write(byte[] ): 向目标文件写入一个数组的数据
package com.by.test;

import java.io.FileOutputStream;

public class TestFOS {
    public static void main(String[] args)throws Exception {
        FileOutputStream fos=new FileOutputStream("file/b.txt");
        //写入一个字节
        fos.write(65);
        fos.write(66);
        fos.write(67);
        //写入一个数组
        String str = "abcdefg123456";
        byte[] bs = str.getBytes();
        fos.write(bs);

        //关流
        fos.close();

        System.out.println("执行成功!");
    }
}

标准异常处理

  • JDK7.0之后,提供了自动关流的语法结构,简化了finally的工作内容
try(
	//需要自动关流的创建语句
){
    
}catch(){
    
}
  • 原理: JDK7.0之后,所有的流都默认实现了AutoCloseable接口,该接口中提供了自动关流所需的close方法
package com.by.test;

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

public class TestFOS2 {
    public static void main(String[] args) {
        try (
                FileOutputStream fos = new FileOutputStream("file/b.txt");
                ){

            //写入一个字节
            fos.write(65);
            fos.write(66);
            fos.write(67);
            //写入一个数组
            String str = "abcdefg123456";
            byte[] bs = str.getBytes();
            fos.write(bs);
        } catch (FileNotFoundException e) {
            System.out.println("文件路径不正确");
        } catch (IOException e) {
            System.out.println("读写失败");
        } catch (Exception e) {
            System.out.println("未知异常!");
            e.printStackTrace();
        }

        System.out.println("执行成功!");
    }
}

文件复制

  • 原理: 先将文件A中的内容读取到JVM中,再从JVM中将读取内容写入到文件B, 借助JVM来实现A与B之间的数据复制
    • 先读后写
package com.by.test;

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

public class TestFileCopy {
    public static void main(String[] args) {
        copy1();
        copy2();
    }
    /**
     * 一次复制一个字节
     */
    public static void copy1(){
        try (
                //创建输出节点流-复制到的文件路径
                FileOutputStream fos=new FileOutputStream("d:/test/2.pdf");
                //创建输入节点流-被复制的文件路径
                FileInputStream fis=new FileInputStream("d:/test/1.pdf")
                ) {
            //先循环读取文件所有内容
            while (true) {
                int n = fis.read();
                if (n == -1) {
                    break;
                }
                //将本次读取的字节写入到目标文件
                fos.write(n);
            }

            System.out.println("复制成功!");

        } catch (FileNotFoundException e) {
            System.out.println("文件路径不正确");
        } catch (IOException e) {
            System.out.println("读写失败!");
        } catch (Exception e) {
            System.out.println("未知异常!");
            e.printStackTrace();
        }
    }
    /**
     * 一次复制一个字节数组
     */
    public static void copy2(){
        try (
                //创建输出节点流-复制到的文件路径
                FileOutputStream fos=new FileOutputStream("d:/test/3.pdf");
                //创建输入节点流-被复制的文件路径
                FileInputStream fis=new FileInputStream("d:/test/1.pdf")
        ) {
            //先循环读取文件所有内容
            while (true) {
                //创建数组
                byte[] bs = new byte[1024];
                //读取一个数组的数据
                int n = fis.read(bs);
                if (n == -1) {
                    break;
                }
                //将数组中的数据写入到目标文件
                fos.write(bs);
            }

            System.out.println("复制成功!");

        } catch (FileNotFoundException e) {
            System.out.println("文件路径不正确");
        } catch (IOException e) {
            System.out.println("读写失败!");
        } catch (Exception e) {
            System.out.println("未知异常!");
            e.printStackTrace();
        }
    }
}

缓冲过滤流

  • BufferedInputStream: 输入缓冲过滤流
  • BufferedOutputStream: 输出缓冲过滤流

创建

BufferedInputStream bis=new BufferedInputStream(fis对象);
BufferedOutputStream bos=new BufferedOutputStream(fos对象);

作用

拥有一个内置的数据缓冲区, 文件数据将对接至数据缓冲区中,在缓冲区刷新或关闭时再将内部内容一并的给到目标文件

 /**
     * 一次复制一个字节+缓冲过滤流
     */
    public static void copy3(){
        try (
                //创建输出节点流-复制到的文件路径
                FileOutputStream fos=new FileOutputStream("d:/test/4.pdf");
                //创建输入节点流-被复制的文件路径
                FileInputStream fis=new FileInputStream("d:/test/1.pdf");
                //添加缓冲过滤流
                BufferedOutputStream bos=new BufferedOutputStream(fos);
                BufferedInputStream bis=new BufferedInputStream(fis)
        ) {
            //先循环读取文件所有内容
            while (true) {
                int n = bis.read();
                if (n == -1) {
                    break;
                }
                //将本次读取的字节写入到目标文件
                bos.write(n);
            }

            System.out.println("复制成功!");

        } catch (FileNotFoundException e) {
            System.out.println("文件路径不正确");
        } catch (IOException e) {
            System.out.println("读写失败!");
        } catch (Exception e) {
            System.out.println("未知异常!");
            e.printStackTrace();
        }
    }

使用

  1. 如果先写后读,需要在写入完成后刷新缓冲区才能保证读取的正常进行

    • 调用flush():强刷缓冲区 (推荐)
    • 调用close(): 关流之前也会刷新缓冲区
  2. 关流时外层过滤流关闭内层节点流会一并关闭

package com.by.test;

import java.io.*;

public class TestBuffered {
    public static void main(String[] args) {
        try(
               //输出
               BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("file/a.txt"));
               //输入
               BufferedInputStream bis=new BufferedInputStream(new FileInputStream("file/a.txt"))
                ){
            //先写
            bos.write("abcd".getBytes());
            //刷新缓冲区
            bos.flush();   
            //bos.close();
            //再读
            while (true) {
                int n = bis.read();
                if (n == -1) {
                    break;
                }
                System.out.println((char) n);
            }

        }catch (FileNotFoundException e) {
            System.out.println("文件路径不正确");
        } catch (IOException e) {
            System.out.println("读写失败!");
        } catch (Exception e) {
            System.out.println("未知异常!");
            e.printStackTrace();
        }
    }
}

对象过滤流

  • ObjectInputStream 对象输入过滤流
  • ObjectOutputStream 对象输出过滤流
  • 附加功能1: 读写基本类型
  • 附加功能2: 读写引用类型

读写基本类型

读取: ois.readXxx()
写入: oos.writeXxx();: Xxx对应的为基本类型名,首字母大写
  • 由于对象过滤流底层嵌套了缓冲区,所以先写后读操作时,仍然需要在写入完成后刷新缓冲区
  • 为了保证数据的安全性,所以在写入时数据会根据魔数机制对其加密,在读取时在进行解密
package com.by.test;

import java.io.*;

public class TestObject_Double {
    public static void main(String[] args) {
        try (
                //输出流
                ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("file/c.txt"));
                //输入流
                ObjectInputStream ois=new ObjectInputStream(new FileInputStream("file/c.txt"))

                ) {
            //先写
            oos.writeDouble(10.5);
            //强刷缓冲区
            oos.flush();
            //读取
            System.out.println(ois.readDouble());


        } catch (FileNotFoundException e) {
            System.out.println("文件路径不正确");
        } catch (IOException e) {
            System.out.println("读写失败!");
            e.printStackTrace();
        } catch (Exception e) {
            System.out.println("未知异常!");
            e.printStackTrace();
        }
    }
}

读写引用类型

读取: Object ois.readObject()  读取到达末尾,抛出EOFException异常
写入: oos.writeObject(对象)  可以自动刷新缓冲区,所以先写后读时无需进行flush
读写String
package com.by.test;

import java.io.*;

public class TestObject_String {
    public static void main(String[] args) {
        try (
                //输出流
                ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("file/c.txt"));
                //输入流
                ObjectInputStream ois=new ObjectInputStream(new FileInputStream("file/c.txt"))

                ) {
            //先写
            oos.writeObject("床前明月光");
            oos.writeObject("疑是地上霜");
            oos.writeObject("举头望明月");
            oos.writeObject("低头思故乡");
            //后读
            while (true) {
                try {
                    String s =(String) ois.readObject();
                    System.out.println(s);
                } catch (EOFException e) {
                    //读取到达末尾,跳出循环
                    break;
                }
            }


        } catch (FileNotFoundException e) {
            System.out.println("文件路径不正确");
        } catch (IOException e) {
            System.out.println("读写失败!");
            e.printStackTrace();
        } catch (Exception e) {
            System.out.println("未知异常!");
            e.printStackTrace();
        }
    }
}
读写自定义类型
  • 自定义类必须实现Serializable接口,表示允许被序列化,否则IO流没有读写权限

    序列化:拆分对象信息的过程

    反序列化:通过信息组装对象的过程

  • 将属性通过transient修饰符修饰则可以防止其参与序列化

  • 如果对象中有自定义类型的属性,则必须使该属性类型也实现序列化接口或者通过transient修饰符对其修饰

package com.by.entity;

import java.io.Serializable;

public class Student implements Serializable {
    private String name;
    private int age;
    //防止被序列化
    private transient double score;
   // private Teacher tea;
//省略getter、setter、构造、toString
}

package com.by.test;

import com.by.entity.Student;

import java.io.*;

public class TestObject_Student {
    public static void main(String[] args) {
        try (
                //输出流
                ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("file/c.txt"));
                //输入流
                ObjectInputStream ois=new ObjectInputStream(new FileInputStream("file/c.txt"))

                ) {
            //先写
            oos.writeObject(new Student("zhangsan", 20, 88.5));
            //后读
            System.out.println((Student)ois.readObject());



        } catch (FileNotFoundException e) {
            System.out.println("文件路径不正确");
        } catch (IOException e) {
            System.out.println("读写失败!");
            e.printStackTrace();
        } catch (Exception e) {
            System.out.println("未知异常!");
            e.printStackTrace();
        }
    }
}

怎么理解输出语句?

System是类库中的工具类,out为该工具类中的静态属性,类型为标准输出流类型,print和println系列方法是该流中提供的写入方法,作用为向控制台写入一个内容

今日掌握

  1. 流的分类
  2. 文件复制的源码(字节复制+缓冲过滤流)
  3. 对象过滤流读写自定义类型

文章来源:https://blog.csdn.net/z122899/article/details/135132986
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。