IO流初学(中)

最新推荐文章于 2024-07-10 21:37:49 发布

卷扬机

最新推荐文章于 2024-07-10 21:37:49 发布

阅读量175

点赞数 2

分类专栏： java学习文章标签： java 后端

本文链接：https://blog.csdn.net/weixin_52357736/article/details/120840769

版权

java学习专栏收录该内容

9 篇文章 0 订阅

订阅专栏

先看一下IO流的主要分类非常之多（麻了.jpg）

1.3.1BufferedInputStream

1.3.2 BufferedOutputStream

1.3.3 字节流拷贝

二对象处理流

2.1ObjectOutputStream

2.2 ObjectInputStream

一节点流和处理流

1.1概念

节点流：节点流是对单一数据源(数组文件管道字符串 )进行读写操作的一种流如专门读写文件的FileReader FileWriter

处理流：处理流也叫包装流连接在已存在的流(节点流或者包装流) 为程序提供更为强大的读写功能也更加灵活数据源可以是数组也可以是文件

ps：节点流相当于一个只能做椅子的工匠只能对木头进行操作

处理流相当于多功能工匠可以对木头进行操作也可以对石头沙子进行操作

可能形容的不太准确但大致是这么个意思处理流能处理的范围明显多于节点流

BufferedReader 类中有属性Reader 即可以封装一个节点流该节点流可以是任意的只要是Reader子类

BufferedWriter类中有属性Writer 即可以封装一个节点流该节点流可以是任意的只要是Writer子类

节点流和处理流的区别和联系

1.节点流是底层流/低级流直接跟数据源(文件管道)相接

2.处理流包装节点流既可以消除不同节点流的实现差异也可以提供更方便的方法来完成输入输出

3.处理流对节点流进行包装使用了修饰器设计模式不会直接与数据源相连接

备注：处理流处理的是节点流节点流直接跟数据源相连接所以处理流是间接的与数据源相连接

处理流的功能主要体现在以下两个方面

1.性能的提高：主要以增加缓冲的方式来提高输入输出的效率

备注：Buffered提供了一个八个字节大小的缓冲区当程序与磁盘进行交互时效率很低速度很慢普通流每次读写一个字节而缓冲流在内存中设置了一个缓冲区缓冲区存够足够大的数据后再与内存或者磁盘进行交换减少了需要交换的次数提高了处理的效率

2.操作的便捷：处理流可能提供了一系列便捷的方法来一次输入输出大批量的数据使用更加灵活方便

1.2字符流

1.2.1 BufferedReader

 public static void main(String[] args) throws IOException {
        String filepath="d:\\1.txt";
        FileReader reader = new FileReader(filepath);
        BufferedReader bufferedReader = new BufferedReader(reader);

        //一个字符一个字符读入
        int readline;
        while((readline=bufferedReader.read())!=-1){
            System.out.print((char)(readline));
        }
        //一行一行读入
        String read;
        while ((read=bufferedReader.readLine())!=null){
            System.out.println(read);
        }
        //只需要关闭外层流即可
        reader.close();
    }

1.2.2 BufferedWriter

 public static void main(String[] args) throws IOException {
        String filepath = "d:\\1.txt";
        FileWriter fileWriter = new FileWriter(filepath);
        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
        bufferedWriter.write("大二实习冲冲冲");
        bufferedWriter.write("15");
        bufferedWriter.write('F');
        bufferedWriter.close();
    }

1.2.3 Buffered拷贝

 public static void main(String[] args) throws IOException {
        //拷贝一边读入一边写入
        String filepath1 = "d:\\hello.txt";//读入流
        String filepath2 = "d:\\1.txt";//输出流
        FileReader fileReader = new FileReader(filepath1);
        FileWriter fileWriter = new FileWriter(filepath2);
        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        String readline;
        while ((readline=bufferedReader.readLine())!=null){
            bufferedWriter.write(readline);
        }
        bufferedReader.close();
        bufferedWriter.close();

    }

1.3字节流

1.3.1BufferedInputStream

  public static void main(String[] args) throws IOException {
        String filepath = "d:\\hello.txt";
        FileInputStream fileInputStream = new FileInputStream(filepath);
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
        //按字节读
        int read;
        while ((read=bufferedInputStream.read())!=-1){
            System.out.print((char) read);
        }
        //字节数组读
        byte[] buf = new byte[1024];
        int readbuf;
        while((readbuf=bufferedInputStream.read(buf))!=-1){
            System.out.println(new String(buf,0,readbuf));
        }
        bufferedInputStream.close();

    }

1.3.2 BufferedOutputStream

public static void main(String[] args) throws IOException {
       String filepath = "d:\\hello.txt";
        FileOutputStream fileOutputStream = new FileOutputStream(filepath);
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
        bufferedOutputStream.write("I LOVE YOU THREE THOUSANDS TIMES".getBytes());//转化为字节数组
        bufferedOutputStream.close();
    }

1.3.3 字节流拷贝

public static void main(String[] args) throws IOException {
    //两个地址
        String filepath = "d:\\hello.txt";
        String filepath1 = "d:\\hsp.txt";
        FileInputStream fileInputStream = new FileInputStream(filepath);
        FileOutputStream fileOutputStream = new FileOutputStream(filepath1);
        byte buf[]=new byte[1024];
        int readlen;
        while((readlen=fileInputStream.read(buf))!=-1){
            fileOutputStream.write(buf,0,readlen);
        }
        fileInputStream.close();
        fileOutputStream.close();
    }

二对象处理流

需求

保存一个Dog类对象 Dog dog = new Dog("小花农夫"，3) 保存到文件中并且能够从文件恢复

保存值和数据类型 序列化

将保存在文件中的数据（值和数据类型）重新恢复 称之为反序列化

为了让类是可序列化的我们必须要实现这两个接口之一

Serializable(标记接口没有方法推荐+)

Externalizable

ObjectInputStream 提供反序列化功能

ObjectOutputStream 提供序列化功能

2.1ObjectOutputStream

 public static void main(String[] args) throws IOException {
        //序列化
        String filepath = "d:\\hello.txt";
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(filepath));
        //写入一个数字
        objectOutputStream.writeInt(100);
        //写入一个浮点数
        objectOutputStream.writeDouble(5.20);
        //写入一个字符串
        objectOutputStream.writeUTF("love");
        //写入一个Boolean值
        objectOutputStream.writeBoolean(true);
        //写入一个字符
        objectOutputStream.writeChar('a');
        //写入一个对象
        objectOutputStream.writeObject(new Dog("小花❀",5));
        objectOutputStream.close();
    }

2.2 ObjectInputStream

public static void main(String[] args) throws IOException, ClassNotFoundException {
        String filepath = "d:\\hello.txt";
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filepath));
        System.out.println(objectInputStream.readInt());
        System.out.println(objectInputStream.readDouble());
        System.out.println(objectInputStream.readUTF());
        System.out.println(objectInputStream.readBoolean());
        System.out.println(objectInputStream.readChar());
        System.out.println(objectInputStream.readObject());
    }

Dog.java

public class Dog {
        private String name;
        private  int age;
        public Dog(String name, int age) {
            this.name = name;
            this.age = age;
        }

    }

2.3注意事项

1.读写顺序要一致

2.要求序列化或反序列化对象类需要实现Serializable接口

3.序列化的类中建议添加SerialVersionUID 为了提高版本的兼容性

 private static final long serialVersionUID=1L;

4.序列化对象时默认将里面所有属性都进行序列化但除了static或transient修饰的成员

5.序列化对象时要求里面属性的数据类型也需要实现序列化接口

6.序列化具备可继承性也就是说如果某类已经实现了序列化那么它的所有子类也已经默认实现了序列化