java输入输出及文件的详细解析

最新推荐文章于 2024-08-21 02:08:14 发布

小白迷上java

最新推荐文章于 2024-08-21 02:08:14 发布

阅读量1.3k

点赞数 2

分类专栏： java基础文章标签： java

本文链接：https://blog.csdn.net/Junsunnyl/article/details/119973088

版权

java基础专栏收录该内容

33 篇文章 1 订阅

订阅专栏

java输入输出及文件的详细解析

File类（重点）

基本概念

java.io.File类主要用于描述文件或目录路径的抽象表示信息，可以获取文件或目录的特征信息，如：大小等

常用的方法

方法声明
File(String pathname)	根据参数指定的路径名来构造对象
File(String parent, String child)	根据参数指定的父路径和子路径信息构造对象
File(File parent, String child)	根据参数指定的父抽象路径和子路径信息构造对象
boolean exists()	测试此抽象路径名表示的文件或目录是否存在
String getName()	用于获取文件的名称
long length()	返回由此抽象路径名表示的文件的长度
long lastModified()	用于获取文件的最后一次修改时间
String getAbsolutePath()	用于获取绝对路径信息
boolean delete()	用于删除文件，当删除目录时要求是空目录
boolean createNewFile()	用于创建新的空文件
boolean mkdir()	用于创建目录
boolean mkdirs()	用于创建多级目录
File[] listFiles()	获取该目录下的所有内容
boolean isFile()	判断是否为文件
boolean isDirectory()	判断是否为目录
File[] listFiles(FileFilter filter)	获取目录下满足筛选器的所有内容

方法演示

常用方法演示

        // 3.由于修改时间返回的是毫秒值 所有格式化
        SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        // 1.构造File类型的对象 并用 z:/a.txt初始化
        File file = new File("z:/a.txt");
        if (file.exists()) { // 判断文件是否存在 如果存在执行以下代码
            System.out.println("文件的名称是:" + file.getName()); // a.txt
            System.out.println("文件的大小是:" + file.length()); // 0
            System.out.println("文件的最后一次次改时间是" + format.format(new Date(file.lastModified()))); // 2021年08月19日 22:23:10
            System.out.println("文件的绝对路径是:" + file.getAbsolutePath()); // z:/a.txt
            System.out.println(file.delete() ? "文件删除成功" : "文件删除失败"); // 文件删除成功
        } else {
            // 3.如果文件不存在 创建文件
            try {
                System.out.println(file.createNewFile() ? "文件创建成功" : "文件创建失败"); // 文件创建成功
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

创建目录

        // 4.实现单多级目录的创建
        File file1 = new File("z:/java/css/html");
        if (file1.exists()) {
            System.out.println("目录名称是:" + file1.getName());
            System.out.println(file1.delete() ? "目录删除成功" : "目录删除失败");
        } else {
            // System.out.println(file1.mkdir() ? "目录创建成功" : "目录创建失败"); // 创建单单极目录
            System.out.println(file1.mkdirs() ? "目录创建成功" : "目录创建失败"); // 创建多单极目录
        }

遍历目录结构

		// 5.获取文件目录的文件及文件夹 并遍历
		File file2 = new File("z:/java");
		File[] filesArr = file2.listFiles();
		// 5.1遍历file数组
		for (File file3 : filesArr) {
   			String name = file3.getName();
    		// 判读是否为文件 如果是打印文件名
    		if (file3.isFile()){
        		System.out.println(name);
    		}
   		    // 判断是否为目录 如果是 打印目录名 并按照格式{}
    		if (file3.isDirectory()){
       		 System.out.println("{" + name + "}");
    		}
		 }

文件过滤器的使用

// 6.实现目录中的所有内容获取的通时 进行过滤 获取.png为后缀名的所有
        // 6.1 使用匿名内部类
        File[] files = file2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.getName().endsWith(".png");
            }
        });
        // 6.1 使用lambda表达式
        FileFilter filter = (File pathname) -> pathname.getName().endsWith(".mp4");
        // 6.1 传入lambda表达式
        File[] file5 = file2.listFiles((File pathname) -> pathname.getName().endsWith(".png"));
        // 6.2过滤之后进行打印
        System.out.println(Arrays.toString(file5));
    }

使用递归的思想实现层层目录的打印

public static void show(File file){
        // 5.获取文件目录的文件及文件夹 并遍历
        File[] filesArr = file.listFiles();
        // 5.1遍历file数组
        for (File file3 : filesArr) {
            String name = file3.getName();
            // 判读是否为文件 如果是打印文件名
            if (file3.isFile()){
                System.out.println(name);
            }
            // 判断是否为目录 如果是 打印目录名 并按照格式{}
            if (file3.isDirectory()){
                System.out.println("{" + name + "}");
                show(file3);
            }
        }
    }

IO 流

IO流的概念

IO就是Input和Output的简写，也就是输入和输出的含义。
IO流就是指读写数据时像流水一样从一端流到另外一端，因此得名为“流"。

基本分类

按照读写数据的基本单位不同可分为两种

字节流

其中字节流主要指以字节为单位进行数据读写的流，可以读写任意类型的文件。(txt,jpg,avi,mp4等)

字符流

其中字符流主要指以字符(2个字节)为单位进行数据读写的流，只能读写文本文件 含有中文的文本文件推荐用

按照读写数据的方向不同，可分为两种（站在程序的角度）。

输入流

其中输入流主要指从文件中读取数据内容输入到程序中，也就是读文件。

输出流

其中输出流主要指将程序中的数据内容输出到文件中，也就是写文件。

按照流的角色不同分为

节点流

其中节点流主要指直接和输入输出源对接的流。

处理流。

其中处理流主要指需要建立在节点流的基础之上的流。

体系结构

请添加图片描述

下面类的思维导图

请添加图片描述

FileWriter类（重点）

FileWriter类（重点）

java.io.FileWriter类主要用于将文本内容写入到文本文件。

常用的方法

方法声明	功能介绍
FileWriter(String fileName)	根据参数指定的文件名构造对象
FileWriter(String fileName, boolean append)	以追加的方式根据参数指定的文件名来构造对象
void write(int c)	写入单个字符
void write(char[] cbuf, int off, int len)	将指定字符数组中从偏移量off开始的len个字符写入此文件输出流
void write(char[] cbuf)	将cbuf.length个字符从指定字符数组写入此文件输出流中
void flush()	刷新流 void close() 关闭流对象并释放有关的资源
void close()	关闭流对象并释放有关的资源

常用方法代码演示

对象的构造需要进行异常单处理

		    // 1.构造FileWrite类型的对象 与 z://a.txt文件关联
            // 若文件不存在创建一个新文件
            // 若文件存在 该流会清空文件中原有的内容
            writer = new FileWriter("z:/a.txt");
            // 加true之后 文件以追加的形式创建对象 去关联文件
            // 若文件不存在则自动创建新的空文件 并保留文件中原有的数据内容
            writer = new FileWriter("z:/a.txt", true);

文件的写入

            // 2.通过流对象写入数据内容
            writer.write('a');

写入字符数组

   		   // 准备一个字符串并将字符串转化为char[]
            char[] charsArr = "hello, java !!!".toCharArray();
		   // 将字符的一部分写入到文件中
            writer.write(charsArr,6,charsArr.length-1 - 6); // java !!!
		   // 此处不会清除文件中的内容 而是在末尾进行追加
            writer.write(charsArr);  // java !!hello, java !!!

流的关闭防在捕获异常之后的finally类中

        // 3.关闭流对象 并释放资源
        // 如果在创建对象时发生异常 则writer为空值 可能引发空指针异常 在这进行判断防止异常的发生
        if (writer != null){
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

数刷新 flush 只有大量写入数据时才用到

         // 刷新流
         write.flush();

FileReader类（重点）

基本概念

java.io.FileReader类主要用于从文本文件读取文本数据内容

常用的方法

方法声明	功能介绍
FileReader(String fileName)	根据参数指定的文件名构造对象
int read()	读取单个字符的数据并返回，返回-1表示读取到末尾
int read(char[] cbuf, int offset, int length)	从输入流中将最多len个字符的数据读入一个字符数组中，返回读取到的字符个数，返回-1表示读取到末尾
int read(char[] cbuf)	从此输入流中将最多 cbuf.length 个字符的数据读入字符数组中，返回读取到的字符个数，返回-1表示读取到末尾
void close()	关闭流对象并释放有关的资源

常用方法代码演示

对象的构造并进行遍历文本文件进行打印

 FileReader reader = null;
        try {
            // 1.构造FileReader类型的对象 与 z:/a.txt 文件关联
            reader = new FileReader("z:/a.txt"); // 文件中的内容是  java !!hello, java !!!
            // 2.读取文件内容并打印
            // System.out.println(reader.read()); // 输出为 32 可能为ASCII码
            // 进行数字转换为char 返回值是对应的ASCII码值
            // 当读取单文件的最后位置返回为 - 1
            int temp = 0; // 初始化用来接受输入流的信息
            while ( (temp = reader.read()) != -1){
                System.out.print( (char) temp); //  java !!hello, java !!!
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

将关联文件读取到字符数组中

            // 1.定义一个字符串数组 长度为10  文件中的字符为java!!hellojava
            char[] charArr = new char[10];
            reader.read(charArr,1,8);
            // 打印数组中的元素
            System.out.println(Arrays.toString(charArr)); // [,  , j, a, v, a, !, !, h,  ]
            // 由于用的是同一个对象 指针保留到下一个字符 如果读取完毕  指针自动调用前调用方第一个字符 最后一个字符返回为空
		   reader.read(charArr); 
            System.out.println(Arrays.toString(charArr)); // [e, l, l, o, j, a, v, a, h,  ]

关闭流对象并释放有关的资源

	finally {
            // 3.关闭流对象并释放有关的资源
            // 如果在创建对象时发生异常 则reader为空值 可能引发空指针异常 在这进行判断防止异常的发生
            if (reader != null){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

实现文件的拷贝(单个字符)

FileReader reader = null;
        FileWriter writer = null;
        try {
            // 1.创建FileReader类型的对象 与 z:/a.txt 关联
            reader = new FileReader("z:/a.txt");
            // 2.创建FileWriter类型的对象 与 z:/b.txt 关联
            writer = new FileWriter("z:/b.txt");
            // 3.从输入流中读取到的数据写入到输出流
            int temp = 0;
            while ((temp = reader.read()) != -1){
                writer.write(temp);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 4.关闭流信息 并释放对应的资源
            // 关闭流信息一般操作是 县创建的后关闭
            if (writer != null){
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(reader != null){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
    }

FileOutputStream类（重点）

基本概念

java.io.FileOutputStream类主要用于将图像数据之类的原始字节流写入到输出流中。

常用的方法

方法声明	功能介绍
FileOutputStream(String name)	根据参数指定的文件名来构造对象
FileOutputStream(String name, boolean append)	以追加的方式根据参数指定的文件名来构造对象
void write(int b)	将指定字节写入此文件输出流
void write(byte[] b, int off, int len)	将指定字节数组中从偏移量off开始的len个字节写入此文件输出流
void write(byte[] b)	将 b.length 个字节从指定字节数组写入此文件输出流中
void flush()	刷新此输出流并强制写出任何缓冲的输出字节
void close()	关闭流对象并释放有关的资源

FileInputStream类（重点）

基本概念

java.io.FileInputStream类主要用于从输入流中以字节流的方式读取图像数据等。

常用的方法

方法声明	功能介绍
FileInputStream(String name)	根据参数指定的文件路径名来构造对象
int read()	从输入流中读取单个字节的数据并返回，返回-1表示读取到末尾
int read(byte[] b, int off, int len)	从此输入流中将最多len个字节的数据读入字节数组中，返回读取到的字节个数，返回-1表示读取到末尾
int read(byte[] b)	从此输入流中将最多 b.length 个字节的数据读入字节数组中，返回读取到的字节个数，返回-1表示读取到末尾
void close()	关闭流对象并释放有关的资源
int available()	获取输入流所关联文件的大小

案例题目

编程实现两个文件之间的拷贝功能(异常未处理处理异常的方式和上面相同)

拷贝方式一: 文件捎到时拷贝效率低

    public static void main(String[] args) {
        // 1.创建字节输入流 FileInputStream 与文件 z:/c.png 进行关联
        FileInputStream inputStream = new FileInputStream("z:/d.png");
        // 2.创建字节输出流 FileOutputStream 与文件 z:/d.png 进行关联
        FileOutputStream outputStream = new FileOutputStream("z:/c.png");
        // 3.将字节输入流读到的数据写入到字节输出流上
        int res = 0;
        while ((res = inputStream.read()) != -1){
            outputStream.write(res);
        }
        // 4.关闭流信息 释放相关的资源
        outputStream.close();
        inputStream.close();
    }

拷贝方式二:准备一个和文件大小相同的数据缓冲区一次性将文件拷贝完成(缺点是文件太大时无法申请和文件大小一样的缓冲区真实的物理内存不足)

   		   // 3.将字节输入流读到的数据写入到字节输出流上 
		  // 将下面代码改为3以后的代码
            int leng = inputStream.available();
            byte[] temp = new byte[leng];
            outputStream.write(temp);

拷贝方式三：准备一个相对适当的缓冲区分多次将文件拷贝完成一般用1024的倍数或 1024

// 3.将字节输入流读到的数据写入到字节输出流上
            byte[] b = new byte[1024];
            int res = 0;
            while ((res = inputStream.read(b)) != -1){
                outputStream.write(b,0,res);
            }

BufferedOutputStream类（重点）

基本概念

java.io.BufferedOutputStream类主要用于描述缓冲输出流，此时不用为写入的每个字节调用底层系统

常用的方法

方法声明	功能介绍
BufferedOutputStream(OutputStream out)	根据参数指定的引用来构造对象
BufferedOutputStream(OutputStream out, int size)	根据参数指定的引用和缓冲区大小来构造对象
void write(int b)	写入单个字节
void write(byte[] b, int off, int len)	写入字节数组中的一部分数据
void write(byte[] b)	写入参数指定的整个字节数组
void flush()	刷新流
void close()	关闭流对象并释放有关的资源

BufferedInputStream类（重点）

基本概念

java.io.BufferedInputStream类主要用于描述缓冲输入流。

常用的方法、

方法声明	功能介绍
BufferedInputStream(InputStream in)	根据参数指定的引用构造对象
BufferedInputStream(InputStream in, int size)	根据参数指定的引用和缓冲区大小构造对象
int read()	读取单个字节
int read(byte[] b, int off, int len)	读取len个字节
int read(byte[] b)	读取b.length个字节
void close()	关闭流对象并释放有关的资源

使用缓冲输入输出流实现文件的拷贝（未进行异常的处理自己也可以定义缓冲区）默认缓冲区为 8192 = 1024 * 8

        // 1.创建BufferedInputStream 类型与 z://c.png 文件管理
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("z:/c.png")); // 处理流
        // 2.创建BufferedIOutputStream 类型与 z://d.png 文件管理
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("z/d.png")); // 处理流
        // 3.不断地从输入流读取文件数据 写入到输出流中
        int res = 0;
        while ((res = bis.read()) != -1){
            bos.write(res);
        }
        // 4.关闭流对象 释放有关的资源
        bos.close();
        bis.close();

使用

当牵扯到文件复制是首选 BufferedInputStream 和 BufferedOutoutStream

BufferedWriter类（重点）

基本概念

java.io.BufferedWriter类主要用于写入单个字符、字符数组以及字符串到输出流中。

常用的方法

方法声明	功能介绍
BufferedWriter(Writer out)	根据参数指定的引用来构造对象
BufferedWriter(Writer out, int sz)	根据参数指定的引用和缓冲区大小来构造对象
void write(int c)	写入单个字符到输出流中
void write(char[] cbuf, int off, int len)	将字符数组cbuf中从下标off开始的len个字符写入输出流中
void write(char[] cbuf)	将字符串数组cbuf中所有内容写入输出流中
void write(String s, int off, int len)	将参数s中下标从off开始的len个字符写入输出流中
void write(String str)	将参数指定的字符串内容写入输出流中
void newLine()	用于写入行分隔符到输出流中
void flush()	刷新流
void close()	关闭流对象并释放有关的资源

BufferedReader类（重点）

基本概念

java.io.BufferedReader类用于从输入流中读取单个字符、字符数组以及字符串。

常用的方法

方法声明	功能介绍
BufferedReader(Reader in)	根据参数指定的引用来构造对象
BufferedReader(Reader in, int sz)	根据参数指定的引用和缓冲区大小来构造对象
int read()	从输入流读取单个字符，读取到末尾则返回-1，否则返回实际读取到的字符内容
int read(char[] cbuf, int off, int len)	从输入流中读取len个字符放入数组cbuf中下标从off开始的位置上，若读取到末尾则返回-1，否则返回实际读取到的字符个数
int read(char[] cbuf)	从输入流中读满整个数组
cbuf String readLine()	读取一行字符串并返回，返回null表示读取到末尾
void close()	关闭流对象并释放有关的资源

数据缓冲输入流(字符按照行数据 )实现文件的拷贝(有异常未进行处理)

  // 1.定义一个字符缓冲输入流 BufferedReader 与文件 z:/a.txt 文件关联
        BufferedReader reader = new BufferedReader(new FileReader("z:a.txt"));
        // 2.定义一个字符缓冲输出流 BufferedWriter 与文件 z:/a.txt 文件关联
        BufferedWriter writer = new BufferedWriter(new FileWriter("z:/b.txt"));
        // 3.将读到的行数据输入流按照行输出到输出流上
        String res = null;
        while ((res = reader.readLine()) != null){ // 读取一行数据
            writer.write(res); // 写入一行数据
             writer.newLine(); // 新建一行 不添加此处代码 默认在末尾追加 当前系统的行分隔符是 
        }
        // 4.关闭流信息 释放相关的资源
        writer.close();
        reader.close();

PrintStream类

基本概念

java.io.PrintStream类主要用于更加方便地打印各种数据内容

常用的方法

方法声明	功能介绍
PrintStream(OutputStream out)	根据参数指定的引用来构造对象
void print(String s)	用于将参数指定的字符串内容打印出来
void println(String x)	用于打印字符串后并终止该行
void flush()	刷新流
void close()	用于关闭输出流并释放有关的资源

PrintWriter类

基本概念

java.io.PrintWriter类主要用于将对象的格式化形式打印到文本输出流。

常用的方法

方法声明	功能介绍
PrintWriter(Writer out)	根据参数指定的引用来构造对象
void print(String s)	将参数指定的字符串内容打印出来
void println(String x)	打印字符串后并终止该行
void flush()	刷新流
void close()	关闭流对象并释放有关的资源

案例题目

不断地提示用户输入要发送的内容，若发送的内容是"bye"则聊天结束，否则将用户输入的内容写入到文件z:/a.txt中。

要求使用BufferedReader类来读取键盘的输入 System.in代表键盘输入

要求使用PrintStream类负责将数据写入文件

		   BufferedReader reader = null;
            PrintStream printStream = null;
            try {
                // 2.读取用户输入的聊天内容 要求使用 BufferedReader 类 参数为 System.in
                // 2.1 InputStream in = System.in; // 由此行代码可以知道 System.in 字节流
                // 2.2 通过查源码可以知道 参数为 Reader类 字符流
                // 2.3 所以需要类型的转换 字节流到字符流的转换 需要用到  InputStreamReader
                reader = new BufferedReader(new InputStreamReader(System.in));
                printStream = new PrintStream(new FileOutputStream("z:/a.txt"));
                while (true) {
                    // 1. 提示用户输入聊天内容
                    System.out.println("请输入聊天内容:");
                    // 3.读取用户输入的内容并使用 PrintStream 写入到 z:/a.txt中
                    String s = reader.readLine();
                    // 3.1判读用户输入数据是否为 bye 忽略大小写 如果是 退出聊天 如果不是 将记录聊天内容
                    if ("bye".compareToIgnoreCase(s) == 0) {
                        System.out.println("聊天结束");
                        break;
                    }
                    printStream.println(s);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                // 4.关闭相关流信息 释放相关资源
                if (printStream != null){
                    printStream.close();
                }
                if (reader != null){
                    try {
                        reader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

OutputStreamWriter类

基本概念

java.io.OutputStreamWriter类主要用于实现从字符流到字节流的转换。

常用的方法

方法声明	功能介绍
OutputStreamWriter(OutputStream out)	根据参数指定的引用来构造对象
OutputStreamWriter(OutputStream out, String charsetName)	根据参数指定的引用和编码构造对象
void write(String str)	将参数指定的字符串写入
void flush()	刷新流
void close()	用于关闭输出流并释放有关的资源

InputStreamReader类

基本概念

java.io.InputStreamReader类主要用于实现从字节流到字符流的转换。

常用的方法

方法声明	功能介绍
InputStreamReader(InputStream in)	根据参数指定的引用来构造对象
InputStreamReader(InputStream in, String charsetName)	根据参数指定的引用和编码来构造对象
int read(char[] cbuf)	读取字符数据到参数指定的数组
void close()	用于关闭输出流并释放有关的资源

字符编码

编码表的由来

计算机只能识别二进制数据，早期就是电信号。为了方便计算机可以识别各个国家的文字，就需要将各个国家的文字采用数字编号的方式进行描述并建立对应的关系表，该表就叫做编码表。

常见的编码表

ASCII：美国标准信息交换码，使用一个字节的低7位二位进制进行表示。

ISO8859-1：拉丁码表，欧洲码表，使用一个字节的8位二进制进行表示。

GB2312：中国的中文编码表，最多使用两个字节16位二进制为进行表示。

GBK：中国的中文编码表升级，融合了更多的中文文字符号，最多使用两个字节16位二进制位表示。

Unicode：国际标准码，融合了目前人类使用的所有字符，为每个字符分配唯一的字符码。所有的文字都用两个字节16位二进制位来表示

编码的发展

面向传输的众多 UTF（UCS Transfer Format）标准出现了，UTF-8就是每次8个位传输数据，而 UTF-16就是每次16个位。这是为传输而设计的编码并使编码无国界，这样就可以显示全世界上所有文化的字符了。
Unicode只是定义了一个庞大的、全球通用的字符集，并为每个字符规定了唯一确定的编号，具体存储成什么样的字节流，取决于字符编码方案。推荐的Unicode编码是UTF-8和UTF-16。
UTF-8：变长的编码方式，可用1-4个字节来表示一个字符。

DataOutputStream类（了解）

基本概念

java.io.DataOutputStream类主要用于以适当的方式将基本数据类型写入输出流中。

常用的方法、

方法声明	功能介绍
DataOutputStream(OutputStream out)	根据参数指定的引用构造对象 OutputStream类是个抽象类，实参需要传递子类对象
void writeInt(int v)	用于将参数指定的整数一次性写入输出流，优先写入高字节写入四个字节
void close()	用于关闭文件输出流并释放有关的资源

DataInputStream类（了解）

基本概念、

java.io.DataInputStream类主要用于从输入流中读取基本数据类型的数据

常用的方法

方法声明	功能介绍
DataInputStream(InputStream in)	根据参数指定的引用来构造对象 InputStream类是抽象类，实参需要传递子类对象
int readInt()	用于从输入流中一次性读取一个整数数据并返回读取4个字节
void close()	用于关闭文件输出流并释放有关的资源

ObjectOutputStream类（重点）

基本概念
- java.io.ObjectOutputStream类主要用于将一个对象的所有内容整体写入到输出流中。
- 只能将支持 java.io.Serializable 接口的对象写入流中。
- 类通过实现 java.io.Serializable 接口以启用其序列化功能。
- 所谓序列化主要指将一个对象需要存储的相关信息有效组织成字节序列的转化过程。

常用的方法

方法声明	功能介绍
ObjectOutputStream(OutputStream out)	根据参数指定的引用来构造对象
void writeObject(Object obj)	用于将参数指定的对象整体写入到输出流中
void close()	用于关闭输出流并释放有关的资源

方法使用

    public static void main(String[] args) {
        ObjectOutputStream objectOutputStream = null;
        try {
            // 1.创建ObjectOutputStream 对象与 z:/a.txt 关联
            objectOutputStream = new ObjectOutputStream(new FileOutputStream("z:/a.txt"));
            // 2.将 User类型的对象写入到留信息中
            User user = new User("zhangsan","123456","15836546481");
            // user类 需要实现 Serializable 接口 并 指定序列化版本号
            // 否则会Error NotSerializableException
            objectOutputStream.writeObject(user);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3.关闭流信息 并释放对应的资源
            if (objectOutputStream == null){
                try {
                    objectOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

ObjectInputStream类（重点）

基本概念
- java.io.ObjectInputStream类主要用于从输入流中一次性将对象整体读取出来。
- 所谓反序列化主要指将有效组织的字节序列恢复为一个对象及相关信息的转化过程。

常用的方法

方法声明	功能介绍
ObjectInputStream(InputStream in)	根据参数指定的引用来构造对象
Object readObject()	主要用于从输入流中读取一个对象并返回无法通过返回值来判断是否读取到文件的末尾
void close()	用于关闭输入流并释放有关的资源

方法使用

      ObjectInputStream inputStream = null;
        try {
            // 1.创建 ObjectInoutStream 对象与 z:/a.txt 文件关联
            inputStream = new ObjectInputStream(new FileInputStream("z:/a.txt"));
            // 2.读取文件内容并打印信息
            User user = (User)inputStream.readObject();
            System.out.println(user);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            // 3.关闭流信息 并释放对应的资源
            if (inputStream != null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

序列化版本号

序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时， JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常 (InvalidCastException)

transient关键字

transient是Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。

public class User implements Serializable { // 实现序列化接口
   private static final long serialVersionUID = -9049093910568116892L;  // 生成序列化版本号
   private String userName;
   private String password;
   // 表示该成员变量不参与序列化 在反序列化操作时 不输出该类型的数值 
    private transient String phoneNum;
}

经验的分享

当希望将多个对象写入文件时，通常建议将多个对象放入一个集合中，然后将集合这个整体看做一个对象写入输出流中，此时只需要调用一次readObject方法就可以将整个集合的数据读取出来，从而避免了通过返回值进行是否达到文件末尾的判断

RandomAccessFile类

基本概念

java.io.RandomAccessFile类主要支持对随机访问文件的读写操作。

常用的方法

方法声明功能介绍
RandomAccessFile(String name, String mode)	根据参数指定的名称和模式构造对象 r: 以只读方式打开 rw：打开以便读取和写入 rwd:打开以便读取和写入，同步文件内容的更新 rws:打开以便读取和写入，同步文件内容和元数据的更新
int read()	读取单个字节的数据
void seek(long pos)	用于设置从此文件的开头开始测量的文件指针偏移量
void write(int b)	将参数指定的单个字节写入
void close()	用于关闭流并释放有关的资源

方法演示

 RandomAccessFile raf = null;
        try {
            // 1.创建RandomAccessFile类型的对象与d:/a.txt文件关联
            raf = new RandomAccessFile("d:/a.txt", "rw");
            // 2.对文件内容进行随机读写操作
            // 设置距离文件开头位置的偏移量，从文件开头位置向后偏移3个字节    aellhello
            raf.seek(3);
            int res = raf.read();
            System.out.println("读取到的单个字符是：" + (char)res); // a l
            res = raf.read(); // h 指向了e
            raf.write('2'); // 执行该行代码后覆盖了字符'e'
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3.关闭流对象并释放有关的资源
            if (null != raf) {
                try {
                    raf.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }