2022-08-09 第4组 蒋萍 IO流的简单使用

目录

• “ 把今天过好 ”
• IO流
  • 1、分类
  • 2、在Java中IO流常用流：
  • 3、流的使用
    • 1.字节输入流
      • 字节输入流读数据步骤：
      • 一些注意点
    • 2. 字节输出流
      • 注意点
    • *关闭流的工具类
    • *案例：文件复制
    • 3、字符流操作
  • 字符处理流（用的最多）
    • 缓冲字符输入流
    • 缓冲字符输出流
    • *案例：缓冲字符流做文件复制
  • 序列化与反序列化（可能面试）
    • 如何实现序列化？？
    • 实现反序列化：
• 其他

“ 把今天过好 ”

最近是怎么了？？
我总是感到莫名其妙的累，效率也不高，脑子也不想动

IO流

File类不能操作文件内容

1、分类

1、按流向分

• 输入流（读）：从物理内存读取数据到运行内存

• 输出流（写）：从内存写出数据到硬盘

---

2、按操作单元分

• 字节流：一个字节一个字节的操作（二进制操作），可以操作任意类型的文件

• 字符流：一个字符一个字符的操作，一个字符是两个字节，主要用于处理文本文件，只能是纯文字（.txt、.java、.xml、.py、.properties……）

---

3、按角色分

• 节点流：直接操作一个特定的IO设备（麻烦）,是二进制操作！！！

• 处理流：在节点流的基础上做进一步处理 （写法简单，性能高）；缓冲流

---

2、在Java中IO流常用流：

	字节输入流	字节输出流	字符输入流	字符输出流
抽象基类	InputStream	OutputStream	Reder	Writer
访问文件(节点流)	FileInputStream	FileOutputStream	FileReder	FileWriter
缓冲流(处理流)	BufferedInputStream	BufferedOutputStream	BufferedReder	BufferedWriter
操作对象	ObjectInputStream	ObjectOutputStream

3、流的使用

1.字节输入流

往内存读数据

1、创建字节输入流

2、开始读的操作，read,返回值是int，返回值是-1时，说明文件读取到了末尾

字节流：一个一个字节的读所以用到循环读取

用啥循环？？

while(){}

并且现在打印出来的是ASCII码，怎么转成我们看得懂的？？

用一个构造器：new String(buf) 但不好控制，得控制字节数组的大小

字节流读的操作，目的也不是让你看懂，哈哈哈哈哈

@Test
public void test01() {
    InputStream inputStream = null;
    try {
        // 创建字节流对象
        inputStream = new FileInputStream("f:/aaa.txt");
        // 做个标记   ----- 操作的是二进制，所以用 int
        int read;
        // 缓冲 ？？？ 
        byte[] buf = new byte[1024];
        // 开始读取 ----- read() 要处理异常
        while((read = inputStream.read(buf)) != -1){
            System.out.println(Arrays.toString(buf) + " ");
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    }finally {
        try {
            // 关闭流 ---- close() 也要处理异常
            inputStream.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

总结：

字节输入流读数据步骤：

1、创建字节输入流对象

2、定义标记控制输入流的读取

3、循环读取，若读到了-1，说明读到了末尾，循环结束

4、关闭字节流（只能手动关闭）

注意异常处理 ！！！（最好处理掉，不要抛出）

一些注意点

感觉写起来有点臃肿 ? ? ?

可以封装一个工具类~~

• 能不能再读一次？？---------->不可以

当一个流读完之后，会默认调用mark和reset来记录和重置，这个流就已经重置到了上次读完的位置，所以就无法再次读取，并不是读完一次后就关闭了流。

2. 字节输出流

写入文件，原文件里有东西 ？？那就追加or覆盖

FileOutputStream构造器中

boolean append参数：true：追加；false或无参：覆盖

使用和输入流类似

@Test
    public void test02() {
        OutputStream outputStream = null;
        try {
            outputStream = new FileOutputStream("e:/aaa.txt",true);  // 追加 ！
            // 一个字节一个字节的写
            outputStream.write("\r\n".getBytes());  // 换行
            outputStream.write("八月正午的阳光都没你耀眼".getBytes());
            System.out.println("数据写出成功...");
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            IOUtil.closeIO(null,outputStream);
/*            try {
                if(Objects.nonNull(outputStream)){
                    outputStream.close();
                }
            } catch (IOException e) {
              throw new RuntimeException(e);
            }
*/
        }

• 

注意点

1、一个字节一个字节地写 write() （费劲）括号里传的不是字符串

​ 如果文件不存在还没报错？？？----> 会自动给新建一个然后写入

2、write()如果传入的是字符串，就成字节型数组" xxx ".getBytes()

换行就是"\r\n"

3、关闭流的操作注意判断下，这么麻烦，整个工具类！！

*关闭流的工具类

/**
 * 关闭流
 * 注意保证所有的流都关闭！！ 抓取异常的最大父类 Exception
 */
public class closeIOUtil {
     public static void closeIO(Reader reader, Writer writer){
        if(Objects.nonNull(reader)) {
            try {
                reader.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if(Objects.nonNull(writer)){
            try {
                writer.close();
            } catch (Exception e) {
               e.printStackTrace();
            }
        }
    }
   
    public static void closeIO(InputStream inputStream, OutputStream outputStream){ 
        // 避免空指针异常
        if (Objects.nonNull(inputStream)) {
            try {
                inputStream.close();
            } catch (Exception e) {    
                //  保证出了异常也能让所有的流关闭
                throw new RuntimeException(e);
            }
        }
        if (Objects.nonNull(outputStream)) {
            try {
                outputStream.close();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }
}

了解即可：

在JDK1.7之后，很多资源类实现了AutoCloseable接口

包括常见的流：FileInputStream,FilOutputStream……

可以直接在try中定义资源，它会主动释放资源，不用手动关闭

*案例：文件复制

/**
 * 两个流：
 * FileInputStream:把对应文件的内容读出来
 * FileOutputStream:把读到的内容写出去
 *
 * 复制粘贴
 * 复制：从哪复制，读 read(byte[])
 * 粘贴：粘贴到哪，写 write(byte[])
 *
 * 多个流同时使用时，流的关闭顺序？？从后往前关 （先用的流后关，）
 *
 */
public class StreamCopy {

    @Test
    public void copy(){
        FileInputStream inputStream = null;
        FileOutputStream outputStream = null;
        try {
            inputStream = new FileInputStream("f:/aaa.txt");
            outputStream= new FileOutputStream("f:/bbb.txt");
            int len;
            byte[] buf = new byte[3]; //一次读三个字节
            // 循环读进来
            while ((len = inputStream.read(buf)) != -1){
                // 写出去
                outputStream.write(buf,0,len);
                // outputStream.write(buf,0,len); 读几个写几个
            }
            System.out.println("文件复制完毕。。。");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            CloseIOUtil.closeIO(inputStream,outputStream);
        }
    }
}

3、字符流操作

很少用FileReader这个节点流，简单了解即可~

读 Reader reader = new FileReader("e:/aaa.txt")

一个中文就当一个字符；

读出来是汉字就汉字，读到的是字符型数组，输出可以转成字符串new String（buf ,0,len）

字符处理流（用的最多）

只能处理纯文本文件，最好用缓冲流

缓冲字符输入流

// BufferedRead buffer = new BufferedRead(这里传节点流)

缓冲字符输出流

 @Test
    public void test02() {
        Writer writer = null;
        try {
            writer = new FileWriter("e:/bbb.txt");
            writer.write("阿里巴巴规约手册...");
            System.out.println("数据写出成功...");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            IOUtil.closeIO(null,writer);
        }
    }

    @Test
    public void test01() {
        Reader reader = null;
        try {
            reader = new FileReader("e:/aaa.txt");
            int len;
            char [] buf = new char[10];
            while((len = reader.read(buf)) != -1){
                System.out.println(new String(buf,0,len));
            }
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            IOUtil.closeIO(reader,null);
        }
    }

*案例：缓冲字符流做文件复制

public static void main(String[] args) {
    BufferedReader bufferedReader = null;
    BufferedWriter bufferedWriter = null;

    try {
        bufferedReader = new BufferedReader(new FileReader("e:/aaa.txt"));
        bufferedWriter = new BufferedWriter(new FileWriter("e:/bbb.txt"));

        String str;
        while((str = bufferedReader.readLine()) != null){
            bufferedWriter.write(str);
            bufferedWriter.newLine();  // 换行
        }
        System.out.println("文件复制成功！！！");

    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        IOUtil.closeIO(bufferedReader,bufferedWriter);
    }
}

缓冲流是处理流

序列化与反序列化（可能面试）

操作的是对象

序列化：将对象写入IO流中，是把对象转换成有序字节流，以便在网络上传输或者保存在本地文件中。 核心作用是对象状态的保存与重建

反序列化：从IO流中恢复对象，客户端从文件中或网络上获得序列化后的对象字节流，根据字节流中所保存的对象状态及描述信息，通过反序列化重建对象。

使用？？

所有可在网络传输的对象都必须可序列化，所有存在硬盘上的对象也必须可序列化，否则报错

如何实现序列化？？

实现接口：Serializable；将对象写入文件

1、先锁定一个文件（用到IO流）（output）

2、创建对象流

3、造对象

4、写出writeObject(造的对象)

5、关流

@Test
public void test01() {
    ObjectOutputStream objectOutputStream = null;
    // 先锁定一个文件
    try {
        objectOutputStream = new ObjectOutputStream(new FileOutputStream("e:/user.txt"));
        User user = new User("张三",25,1);
        objectOutputStream.writeObject(user);
        System.out.println("对象写出成功...");
    } catch (FileNotFoundException e) {
        throw new RuntimeException(e);
    } catch (IOException e) {
        throw new RuntimeException(e);
    } finally {
        IOUtil.closeIO(null,objectOutputStream);
    }
}

实现反序列化：

对象读入文件

1、先锁定一个文件（用到IO流）input

2、创建对象流

3、写出readObject() 注意强转

4、关流

@Test
public void test02() {
    ObjectInputStream objectInputStream = null;
    // 先锁定一个文件
    try {
        objectInputStream = new ObjectInputStream(new FileInputStream("e:/user.txt"));
        User user = (User) objectInputStream.readObject();
        System.out.println("对象读取成功：" + user);
    } catch (FileNotFoundException e) {
        throw new RuntimeException(e);
    } catch (IOException e) {
        throw new RuntimeException(e);
    } catch (ClassNotFoundException e) {
        throw new RuntimeException(e);
    } finally {
        IOUtil.closeIO(objectInputStream,null);
    }
}

关于序列化版本号错误：

反序列化必须拥有class文件，但随着项目的升级，class文件也会升级

所以序列化保证升级前后的兼容性

• 所以在类里给个版本号就行，这个版本号可以自由指定，但不能不指定，不然JVM会自己计算一个，就不能匹配，就报错

如果不指定版本号：不利于JVM移植，而且不同JVM计算规则不同，导致无法反序列化

如果只修改了方法，反序列化不受影响，如果修改的是静态变量static或瞬态变量transient反序列化也不受影响，无序修改序列化

其他

总结：

1、所有需要网络传输的对象都要实现序列化接口

2、对象的类名、实例变量都会被序列化，但方法、类变量、瞬态变量不会被序列化

3、如果想让某个变量不被序列化，可以用transient修饰

4、序列化对象的引用类型的成员变量必须是可序列化的，否则报错

5、反序列化时，必须有序列化对象的class文件

6、同一个对象被序列化多次，只有第一次序列化为二进制流，以后都只是保存序列化的版本号

7、建议所有可序列化的类