20220809 第五组罗大禹学习笔记

20220809 第五小组罗大禹学习笔记

Java IO流

学习重点

1.IO流
2.序列化

学习内容

Java IO流

IO流（输入输出流）

按照流向分

输入流：从硬盘上读取数据到内存。（读）

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

一个文件在传输过程中经历了多次拷贝，IO性能本身就很低。

零拷贝、Nio附加题！！！
按照操作单元分：

字节流：是一个字节一个字节的操作。二进制操作。操作任意类型的文件。(操作二进制的文件要使用字节流)

字符流：是一个字符一个字符的操作。一个字符两个字节，主要用来处理文本文件。(.txt,.java,.py,.xml,.properties,.html,.css,.js,)
按照角色划分：

节点流：直接操作一个特定的IO设备。

处理流：在节点流的基础上，做进一步的处理。

Java中输入/输出流常用的流：

	字节输入流	字节输出流	字符输入流	字符输出流
抽象基类	InputStream	OutputStream	Reader	Writer
访问文件（节点流）	FileInputStream	FileOutputStream	FileReader	FileWriter
缓冲流（处理流）	BufferedInputStream	BufferedOutputStream	BufferedReader	BufferedWriter
操作对象	ObjectInputStream	ObjectOutputStream

File类不能够操作文件的内容

字节流

字节输入流：

输入流：就是一点一点的往内存中读数据！

创建一个FileInputStream对象
定义一个标记，用来控制输入流的读取
循环读取，如果读取到了-1，说明读取到了文件的末尾，循环结束
关闭资源。

注意：

我们发现一个流读完了就没有了，不能再读了。

当一个流读完之后会默认调用mark和reset方法来进行记录和重置，

这个流就已经重置到了上次读完的位置，所以就无法再次读取内容。并不是读完一次之后就关闭了流。

自己写的工具类：

接下来关闭流用到该工具类

import java.io.*;
import java.util.Objects;

public class IOUtil {

    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);
            }
        }
    }
}

举例说明：

import com.jsoft.util.IOUtil;
import org.junit.Test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.Objects;



public class Ch02 {

    @Test
    public void test02() {
        InputStream inputStream = null;
        try {
            inputStream = new FileInputStream("e:/aaa.txt");
            int read;
            byte [] buf = new byte[1024];
            // 将读取到的数据存入至字节数组中，然后对数组进行编辑
            while((read = inputStream.read(buf)) != -1) {
//                System.out.print(Arrays.toString(buf) + " ");
                System.out.println(new String(buf));
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            IOUtil.closeIO(inputStream,null);
        }
    }

    @Test
    public void test01() {
        InputStream inputStream = null;
        try {
            inputStream = new FileInputStream("e:/aaa.txt");
            // 开始读的操作，read方法，返回值是int，当返回值为-1时，说明文件读取到了末尾
            // 读取文件是否结束的标记
            int read;
            // 字节流读数据的时候一个字节一个字节去读
            // 循环读取，读取出来的内容为ASC码
            while((read = inputStream.read()) != -1) {
                System.out.print(read + " ");
            }
            System.out.println();
            System.out.println("读取完毕，再读一次。。。。");
            // 字节流读数据的时候一个字节一个字节去读
            // 循环读取
            // 啥都没读到
            while((read = inputStream.read()) != -1) {
                System.out.print(read + " ");
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                // 关闭流
                inputStream.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

字节输出流

写的操作，目标文件如果不存在，会自动新建。

FileOutputStream构造器：

boolean append参数：如果传入true，则代表在原有基础上追加，不覆盖

如果传入false，或者不传，覆盖原有内容

举例说明：

import com.jsoft.util.IOUtil;
import org.junit.Test;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Objects;



public class Ch03 {

    @Test
    public void test03(){
        System.out.println(Objects.nonNull("null"));
    }

    @Test
    public void test02() {
        OutputStream outputStream = null;
        try {
            outputStream = new FileOutputStream("e:/aaa.txt",true);
            // 一个字节一个字节的写
            outputStream.write("\r\n".getBytes());
            // .getBytes() 将字符串转为byte类型的数组
            // 传入一个byte类型的数组，将数组中的内容编译后写入文件中
            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);
//            }
        }
    }

    @Test
    public void test01() {
        OutputStream outputStream = null;
        try {
             // 传入true，操作为继续添加
             outputStream = new FileOutputStream("e:/aaa.txt",true);
             // 一个字节一个字节的写
            outputStream.write(98);
            System.out.println("数据写出成功...");
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                outputStream.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

用字节流实现文件的复制

使用两个流：

FileInputStream：把对应文件的内容读取出来
FileOutputStream：把读到的内容写出去

使用方法：

read(byte[])
write(byte[])

多个流同时使用时：

流的关闭顺序的问题？先用的流后关，后用的先关！！！

举例说明：

import com.jsoft.util.IOUtil;
import org.junit.Test;

import java.io.*;
import java.util.Objects;


public class Ch04 {

    @Test
    public void test01(){
        InputStream inputStream = null;
        OutputStream outputStream = null;
        try {
            inputStream = new FileInputStream("E:\\workspace\\vscode\\HTML\\20220709\\img\\lijian.jpeg");
            outputStream = new FileOutputStream("e:/lijian.jpeg");

            byte [] buf = new byte[3];
            int len;

            // 循环读进来
            while((len = inputStream.read(buf)) != -1){
                // 写出去
                // 将buf写出，（0，len）代表从0的位置开始写，写取到len-1
                outputStream.write(buf,0,len);
            }
            System.out.println("文件复制完毕...");
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
//            IOUtil.closeIO(inputStream,outputStream);
            try {
                if(Objects.nonNull(outputStream)){
                    outputStream.close();
                    int i = 10 / 0;
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
            try {
                if(Objects.nonNull(inputStream)){
                    inputStream.close();
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }

        }
    }

}

自动关闭，了解即可

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

包括我们常见的流，FileInputStream,FileOutputStream....

可以在try中定义资源，并会主动释放资源

了解即可！！

字符流

举例说明：

import com.jsoft.util.IOUtil;
import org.junit.Test;

import java.io.*;
import java.util.Arrays;



public class Ch06 {

    @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];
            // 传入的数组为char类型的，读出的内容为字符类型
            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);
        }
    }
}

字符处理流（字符缓冲流）（用的最多）

只能处理纯文本文件：

.txt,.java,.html,.css.........

import com.jsoft.util.IOUtil;
import org.junit.Test;

import java.io.*;


public class Ch07 {

    @Test
    public void test02() {
        BufferedWriter bufferedWriter = null;
        try {
            bufferedWriter = new BufferedWriter(new FileWriter("e:/xxx.txt"));
            bufferedWriter.write("今天是星期二，天气凉爽！");
            System.out.println("数据写出成功！");
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            IOUtil.closeIO(null,bufferedWriter);
        }
    }

    @Test
    public void test01() {
        BufferedReader bufferedReader = null;
        try {
            bufferedReader = new BufferedReader(new FileReader("e:/aaa.txt"));
            String str;
            // 读取的内容为字符串		.readLine()一行一行的读取
            while((str = bufferedReader.readLine()) != null) {
                System.out.println(str);
            }
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            IOUtil.closeIO(bufferedReader,null);
        }
    }
}

用字符缓冲流实现文件的复制

外层流，内层流，关闭了外层的流，内层的流会随之关闭。

import com.jsoft.util.IOUtil;

import java.io.*;


public class Ch01 {

    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流中恢复对象，将存储在硬盘上或者从网络中接收的数据恢复成对象模型

使用场景：

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

序列化版本号：

反序列化必须拥有class文件，但随着项目的升级，class文件也会升级，序列化可保证升级前后的兼容性。

不指定版本号的隐患：

java序列化提供了一个版本号，版本号是可以自由指定，如果不指定，JVM会根据类信息自己计算一个版本号。将对象序列化后，再对类进行改动的话，会生成新的版本号，这时再读取时，会发生异常。

不指定版本号，还有一个隐患，不利于JVM的移植，移植后，可能class文件没有改，但是不同的jvm计算规则不一样，导致无法反序列化，如果只修改了方法，反序列化是不受影响，无需修改版本号

修改了静态变量static，瞬态变量transient，反序列化也不受影响，无需修改版本号

transient会阻止被标记的属性序列化

总结：

所有需要网络传输的对象都需要实现序列化接口
对象的类名、实例变量都会被序列化；方法、类变量、transient变量不会被序列化
如果想让某个变量不被序列化，可以用transient修饰
序列化对象的引用类型成员变量，也必须是可序列化的，否则会报错
反序列化时必须有序列化对象的class文件
同一个对象被序列化多次，只有第一次序列化为二进制流，以后都只是保存序列化的版本号
建议所有可序列化的类加上版本号，方便项目升级。

import com.jsoft.util.IOUtil;
import org.junit.Test;

import java.io.*;

/**

 *
 */
public class Ch02 {

    @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);
        }

    }

    @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);
        }

    }
}

posted @ 2022-08-11 19:03 怂还嘴硬阅读(37) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 20220808 第五组罗大禹学习笔记

· 20220713 第二小组罗大禹学习笔记

· 2022-08-09 第二小组张鑫学习笔记

· 2022-08-09 第八组卢睿学习心得

· 2022-08-09 第五组赖哲栋学习笔记

阅读排行：
· 【自荐】一款简洁、开源的在线白板工具 Drawnix
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本
· C#/.NET/.NET Core优秀项目和框架2025年2月简报
· DeepSeek在M芯片Mac上本地化部署

公告

昵称：怂还嘴硬
园龄： 2年7个月
粉丝： 0
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

随笔分类

学习笔记(26)

ldydj

20220809 第五组罗大禹学习笔记

20220809 第五小组罗大禹学习笔记

Java IO流

学习重点

学习内容

Java IO流

IO流（输入输出流）

Java中输入/输出流常用的流：

File类不能够操作文件的内容

字节流

字节输入流：

注意：

自己写的工具类：

举例说明：

字节输出流

举例说明：

用字节流实现文件的复制

使用两个流：

使用方法：

多个流同时使用时：

举例说明：

自动关闭，了解即可

字符流

举例说明：

字符处理流（字符缓冲流）（用的最多）

用字符缓冲流实现文件的复制

序列化与反序列化：操作对象

使用场景：

序列化版本号：

不指定版本号的隐患：

总结：

公告

搜索

常用链接

随笔分类

随笔档案

阅读排行榜

评论排行榜

最新评论

ldydj

20220809 第五组 罗大禹 学习笔记

20220809 第五小组 罗大禹 学习笔记

Java IO流

学习重点

学习内容

Java IO流

IO流（输入输出流）

Java中输入/输出流常用的流：

File类不能够操作文件的内容

字节流

字节输入流：

注意：

自己写的工具类：

举例说明：

字节输出流

举例说明：

用字节流实现文件的复制

使用两个流：

使用方法：

多个流同时使用时：

举例说明：

自动关闭，了解即可

字符流

举例说明：

字符处理流（字符缓冲流）（用的最多）

用字符缓冲流实现文件的复制

序列化与反序列化：操作对象

使用场景：

序列化版本号：

不指定版本号的隐患：

总结：

公告

搜索

常用链接

随笔分类

随笔档案

阅读排行榜

评论排行榜

最新评论

20220809 第五组罗大禹学习笔记

20220809 第五小组罗大禹学习笔记