数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为输入input 和输出output ，即流向内存是输入流，流出内存的输出流。

Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。输入也叫做读取数据，输出也叫做作写出数据。

根据数据的流向分为：输入流和输出流。

输入流 ：把数据从其他设备上读取到内存中的流。输出流 ：把数据从内存 中写出到其他设备上的流。

格局数据的类型分为：字节流和字符流。

字节流 ：以字节为单位，读写数据的流。字符流 ：以字符为单位，读写数据的流。

1 字节流

1.1 字节输出流（OutputStream）

java.io.OutputStream抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。public abstract void write(int b) ：将指定的字节输出流。

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

1.1.1 FileOutputStream

java.io.FileOutputStream类是文件输出流，用于将数据写出到文件,是OutputStream的子类。

构造方法

public FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。public FileOutputStream(String name)： 创建文件输出流以指定的名称写入文件。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。

构造方法的作用: 1.创建一个FileOutputStream对象 2.会根据构造方法中传递的文件/文件路径,创建一个空的文件 3.会把FileOutputStream对象指向创建好的文件

写入数据的原理(内存-->硬盘) java程序-->JVM(java虚拟机)-->OS(操作系统)-->OS调用写数据的方法-->把数据写入到文件中 字节输出流的使用步骤(重点): 1.创建一个FileOutputStream对象,构造方法中传递写入数据的目的地 2.调用FileOutputStream对象中的方法write,把数据写入到文件中 3.释放资源(流使用会占用一定的内存,使用完毕要把内存清空,提供程序的效率)

写出字节：write(int b) 方法，每次可以写出一个字节数据。 写出字节数组：write(byte[] b)，每次可以写出数组中的数据。 写出指定长度字节数组：write(byte[] b, int off, int len) ,每次写出从off索引开始，len个字节。

数据追加续写：

public FileOutputStream(File file, boolean append)： 创建文件输出流以写入由指定的 File对象表示的文件。public FileOutputStream(String name, boolean append)： 创建文件输出流以指定的名称写入文件。

这两个构造方法，参数中都需要传入一个boolean类型的值，true 表示追加数据，false 表示清空原有数据。这样创建的输出流对象，就可以指定是否追加续写了。

代码运行如下：

public class Demo02OutputStream { public static void main(String[] args) throws IOException { //创建FileOutputStream对象，构造方法中绑定要写入数据的目的地 FileOutputStream fos = new FileOutputStream(new File("E:\\java\\JavaseBase02\\day15\\b.txt")); //调用FileOutputStream对象中的方法write，把数据写入到文件中 fos.write(49); fos.write(48); fos.write(49); /* public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。 一次写多个字节: 如果写的第一个字节是正数(0-127),那么显示的时候会查询ASCII表 如果写的第一个字节是负数,那第一个字节会和第二个字节,两个字节组成一个中文显示,查询系统默认码表(GBK) */ byte[] bytes = {65,66,67,68,69}; fos.write(bytes); fos.write(bytes,1,2); /* 写入字符的方法:可以使用String类中的方法把字符串,转换为字节数组 byte[] getBytes() 把字符串转换为字节数组 */ byte[] bytes2 = "你好".getBytes(); System.out.println(Arrays.toString(bytes2)); fos.write(bytes2); //释放资源 fos.close(); } }

运行结果如图：

1.2 字节输入流（InputStream）

java.io.InputStream抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。public abstract int read()： 从输入流读取数据的下一个字节。public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

1.1.2 FileInputStream

java.io.FileInputStream类是文件输入流，从文件中读取字节。

构造方法

FileInputStream(File file)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。FileInputStream(String name)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出FileNotFoundException 。

读取字节：read方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回-1。 使用字节数组读取：read(byte[] b)，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1 。

代码运行如下：

/* 文件复制的步骤: 1.创建一个字节输入流对象,构造方法中绑定要读取的数据源 2.创建一个字节输出流对象,构造方法中绑定要写入的目的地 3.使用字节输入流对象中的方法read读取文件 4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中 5.释放资源 */ public class Demo01CopyFile { public static void main(String[] args) throws IOException { long s = System.currentTimeMillis(); //1.创建一个字节输入流对象，构造方法中绑定要读取的数据源 FileInputStream fis = new FileInputStream("C:\\Users\\Administrator\\Pictures\\Saved Pictures\\source code.png"); //2.创建一个字节输出流对象，构造方法中绑定要写入的目的地 FileOutputStream fos = new FileOutputStream("E:\\Source code.png"); //一次读取一个字节写入一个字节的方式 //3.使用字节输入流对象中的方法read读取文件 /* int len = 0; while((len = fis.read()) != -1){ //4.使用字节输出流中的方法write，把读取到的字节写入到目的地的文件中 fos.write(len); }*/ //使用数组缓冲读取多个字节，写入多个字节 byte[] bytes = new byte[1024]; //3.使用字节输入流对象中的方法read读取文件 int len = 0; // while((len = fis.read(bytes)) != -1){ fos.write(bytes, 0 ,len); } //5.释放资源（先关写的，后关读的；如果写完了，肯定读取完毕了） fis.close(); fos.close(); long e = System.currentTimeMillis(); System.out.println("复制文件共耗时："+(e-s)+"毫秒"); } }

运行结果如图：

2 字符流

当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。

2.1 字符输入流（Reader）

java.io.Reader抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。

public void close() ：关闭此流并释放与此流相关联的任何系统资源。public int read()： 从输入流读取一个字符。public int read(char[] cbuf)： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。

2.1.1 FileReader

java.io.FileReader类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

字符编码：字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。

idea中默认UTF-8编码表

字节缓冲区：一个字节数组，用来临时存储字节数据。

构造方法

FileReader(File file)： 创建一个新的 FileReader ，给定要读取的File对象。FileReader(String fileName)： 创建一个新的 FileReader ，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径。类似于FileInputStream .

构造方法: FileReader(String fileName) FileReader(File file) 参数:读取文件的数据源 String fileName:文件的路径 File file:一个文件 FileReader构造方法的作用: 1.创建一个FileReader对象 2.会把FileReader对象指向要读取的文件 字符输入流的使用步骤: 1.创建FileReader对象,构造方法中绑定要读取的数据源 2.使用FileReader对象中的方法read读取文件 3.释放资源

读取字符：read方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回-1，循环读取。 使用字符数组读取：read(char[] cbuf)，每次读取b的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回-1 。

代码运行如下：

public class Demo02Reader { public static void main(String[] args) throws IOException { //1.创建FileReader对象，构造方法中绑定要读取的数据源 FileReader fr = new FileReader("E:\\java\\JavaseBase02\\day15\\b.txt"); //2.使用FileReader对象中的方法read读取文件 /*int len = 0; while((len = fr.read()) != -1){ System.out.print((char)len); }*/ char[] bytes = new char[1024]; int len = 0; while((len = fr.read(bytes)) != -1){ System.out.print(new String(bytes,0,len)); } //3.释放资源 fr.close(); } }

运行结果如图：

2.2 字符输出流（Writer）

java.io.Writer抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。

void write(int c) 写入单个字符。void write(char[] cbuf)写入字符数组。abstract void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。void write(String str)写入字符串。void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。void flush()刷新该流的缓冲。void close() 关闭此流，但要先刷新它。

2.2.1 FileWriter

java.io.FileWriter类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

构造方法

FileWriter(File file)： 创建一个新的 FileWriter，给定要读取的File对象。FileWriter(String fileName)： 创建一个新的 FileWriter，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。

写出字符：write(int b) 方法，每次可以写出一个字符数据。

关闭和刷新：

因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要flush 方法了。

flush ：刷新缓冲区，流对象可以继续使用。close:先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

写出字符数组 ：write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ，每次可以写出字符数组中的数据，用法类似FileOutputStream。

写出字符串：write(String str) 和 write(String str, int off, int len) ，每次可以写出字符串中的数据，更为方便。

代码运行如下：

public class Demo03Writer { public static void main(String[] args) throws IOException { FileWriter fw = new FileWriter("E:\\java\\JavaseBase02\\day15\\a.txt"); char[] chars = {'a','b','c','d','e'}; fw.write(chars); fw.flush(); fw.write(chars,0,3); fw.flush(); fw.write("\r\n"); fw.write("你好java"); fw.write("你好java",0,5); fw.close(); } }

运行结果如图：

2.3 IO异常的处理

2.3.1 JDK7前处理

代码运行如下：

/* 在jdk1.7之前使用try catch finally 处理流中的异常 格式: try{ 可能会产出异常的代码 }catch(异常类变量 变量名){ 异常的处理逻辑 }finally{ 一定会指定的代码 资源释放 } */ public class Demo01TryCatch { public static void main(String[] args) throws IOException { //提高变量fw的作用域,让finally可以使用 //变量在定义的时候,可以没有值,但是使用的时候必须有值 //fw = new FileWriter("09_IOAndProperties\\g.txt",true); 执行失败,fw没有值,fw.close会报错 FileWriter fw = null; try { fw = new FileWriter("E:\\java\\JavaseBase02\\day15\\a.txt"); for (int i = 0; i < 10; i++) { //可能会产出异常的代码 fw.write("HwlloWorld" + i + "\r\n"); } }catch (IOException e) { //异常的处理逻辑 e.printStackTrace(); }finally { //一定会指定的代码 //创建对象失败了,fw的默认值就是null,null是不能调用方法的,会抛出NullPointerException,需要增加一个判断,不是null在把资源释放 if(fw != null){ try { fw.close(); //fw.close方法声明抛出了IOException异常对象,所以我们就的处理这个异常对象,要么throws,要么try catch } catch (IOException e) { e.printStackTrace(); } } } } }

2.3.2 JDK后前处理

代码运行如下：

/* JDK7的新特性 在try的后边可以增加一个(),在括号中可以定义流对象 那么这个流对象的作用域就在try中有效 try中的代码执行完毕,会自动把流对象释放,不用写finally 格式: try(定义流对象;定义流对象....){ 可能会产出异常的代码 }catch(异常类变量 变量名){ 异常的处理逻辑 } */ public class Demo02JDK7 { public static void main(String[] args) { try{//1.创建一个字节输入流对象，构造方法中绑定要读取的数据源 FileInputStream fis = new FileInputStream("E:\\java\\JavaseBase02\\day15\\a.txt"); //2.创建一个字节输出流对象，构造方法中绑定要写入的目的地 FileOutputStream fos = new FileOutputStream("E:\\b.txt"); //可能会产出异常代码 //一次读取一个字节写入一个字节的方式 //3.使用字节输入流对象中的方法read读取文件 int len = 0; while((len = fis.read()) != -1){ fos.write(len); } }catch (IOException e){ e.printStackTrace(); } } }

3 缓冲流

缓冲流,也叫高效流，是对4个基本的FileXxx 流的增强，所以也是4个流，按照数据类型分类：

字节缓冲流：BufferedInputStream，BufferedOutputStream字符缓冲流：BufferedReader，BufferedWriter

缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

3.1 字节缓冲流

构造方法

public BufferedInputStream(InputStream in) ：创建一个 新的缓冲输入流。public BufferedOutputStream(OutputStream out)： 创建一个新的缓冲输出流。

效率测试代码运行如下：

package Demo01; import java.io.*; /* 读写文件效率测试 */ public class Demo05Tes01 { public static void main(String[] args) { show01(); show02(); show03(); } private static void show03() { //记录开始时间 long start = System.currentTimeMillis(); //创建流对象 try(BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\Source code.png")); BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\\SourceCode3.png"));){ //读写数据 byte[] bytes = new byte[1024]; int len = 0; while((len = bis.read(bytes)) != -1){ bos.write(bytes,0,len); } }catch (IOException e){ e.printStackTrace(); } //记录结束时间 long end = System.currentTimeMillis(); System.out.println("缓冲流使用数组复制时间："+(end - start)+"毫秒"); } private static void show02() {//缓冲流 //记录开始时间 long start = System.currentTimeMillis(); //创建流对象 try(BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\Source code.png")); BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\\SourceCode2.png"));){ //读写数据 int len = 0; while((len = bis.read()) != -1){ bos.write(len); } }catch (IOException e){ e.printStackTrace(); } //记录结束时间 long end = System.currentTimeMillis(); System.out.println("缓冲流复制时间："+(end - start)+"毫秒"); System.out.println("====================================="); } private static void show01() {//基本流 //记录开始时间 long start = System.currentTimeMillis(); //创建流对象 try(FileInputStream fis = new FileInputStream("E:\\Source code.png"); FileOutputStream fos = new FileOutputStream("C:\\SourceCode1.png");){ int len = 0; while((len = fis.read()) != -1){ fos.write(len); } }catch (IOException e){ e.printStackTrace(); } //记录结束时间 long end = System.currentTimeMillis(); System.out.println("普通流复制时间："+(end - start)+"毫秒"); System.out.println("====================================="); } }

运行结果如图：

3.2 字符缓冲流

public BufferedReader(Reader in) ：创建一个 新的缓冲输入流。public BufferedWriter(Writer out)： 创建一个新的缓冲输出流。

特有方法

字符缓冲流的基本方法与普通字符流调用方式一致，不再阐述，我们来看它们具备的特有方法。

BufferedReader：public String readLine(): 读一行文字。BufferedWriter：public void newLine(): 写一行行分隔符,由系统属性定义符号。

代码运行如下：

package Demo01; import java.io.*; import java.util.HashMap; /* 练习: 对文本的内容进行排序 按照(1,2,3....)顺序排序 分析: 1.创建一个HashMap集合对象,可以:存储每行文本的序号(1,2,3,..);value:存储每行的文本 2.创建字符缓冲输入流对象,构造方法中绑定字符输入流 3.创建字符缓冲输出流对象,构造方法中绑定字符输出流 4.使用字符缓冲输入流中的方法readline,逐行读取文本 5.对读取到的文本进行切割,获取行中的序号和文本内容 6.把切割好的序号和文本的内容存储到HashMap集合中(key序号是有序的,会自动排序1,2,3,4..) 7.遍历HashMap集合,获取每一个键值对 8.把每一个键值对,拼接为一个文本行 9.把拼接好的文本,使用字符缓冲输出流中的方法write,写入到文件中 10.释放资源 */ public class Demo06Test02 { public static void main(String[] args) throws IOException { //1.创建一个HashMap集合对象，key:存储每行文本的序号（1,2,3...）；value:存储每行的文本 HashMap<String ,String> map = new HashMap<>(); //2.创建字符缓冲输入流对象，构造方法中绑定字符流入流 BufferedReader br = new BufferedReader(new FileReader("day16\\in.txt")); //3.创建字符缓冲输出流对象，构造方法中绑定字符输出流 BufferedWriter bw = new BufferedWriter(new FileWriter("day16\\out.txt")); //4.使用字符缓冲输入流中的方法readLine，逐行读取文本 String line; while((line = br.readLine()) != null){ //5.对读取到的文本进行切割，获取行中的序号和文本内容 String[] arr = line.split("\\."); //6.把切割好的序号和文本的内容存储到HashMap集合中（key序号是有序的，会自动排序1,2,3,4...） map.put(arr[0], arr[1]); } //7.遍历HashMap集合，获取每个键值对 for (String key : map.keySet()) { String value = map.get(key); //8.把每个键值对，拼接为一个文本行 line = key + "." + value; //9.把拼接好的文本，使用字符缓冲输出流中的方法wirte，写入到文件中 bw.write(line); bw.newLine(); } //10.释放资源 bw.close(); br.close(); } }

运行结果如图：

4 转换流

字符编码

计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则，将字符存储到计算机中，称为编码 。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码 。比如说，按照A规则存储，同样按照A规则解析，那么就能显示正确的文本符号。反之，按照A规则存储，再按照B规则解析，就会导致乱码现象。

编码:字符(能看懂的)–字节(看不懂的)

解码:字节(看不懂的)–>字符(能看懂的)

字符编码Character Encoding : 就是一套自然语言的字符与二进制数之间的对应规则。

编码表:生活中文字和计算机中二进制的对应规则

字符集

字符集 Charset：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。

计算机要准确的存储和识别各种字符集符号，需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBK字符集、Unicode字符集等。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WfNbwJ6a-1593607966410)(img/1_charset.jpg)]

可见，当指定了编码，它所对应的字符集自然就指定了。

4.1 InputStreamReader

转换流java.io.InputStreamReader，是Reader的子类，是从字节流到字符流的桥梁。它读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。

构造方法

InputStreamReader(InputStream in): 创建一个使用默认字符集的字符流。InputStreamReader(InputStream in, String charsetName): 创建一个指定字符集的字符流。

使用步骤:

1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称 2.使用InputStreamReader对象中的方法read读取文件 3.释放资源 注意事项: 构造方法中指定的编码表名称要和文件的编码相同,否则会发生乱码

指定编码读取代码运行如下：

public class Demo03InputStreamReader { public static void main(String[] args) throws IOException { read_utf_8(); read_gbk(); } private static void read_gbk() throws IOException { //1.创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称 InputStreamReader isr = new InputStreamReader(new FileInputStream("day16\\我是GBK格式的文本.txt"),"GBK"); //2.使用InputStreamReader对象中的方法read读取文件 int len = 0; while((len = isr.read()) != -1){ System.out.print((char)len); } //3.释放资源 isr.close(); } /* 使用InputStreamReader读取UTF-8格式的文件 */ private static void read_utf_8() throws IOException { //1.创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称 InputStreamReader isr = new InputStreamReader(new FileInputStream("day16\\我是utf_8格式的文件.txt")); //2.使用InputStreamReader对象中的方法read读取文件 int len = 0; while((len = isr.read()) != -1){ System.out.print((char)len); } //3.释放资源 isr.close(); System.out.println("\n==========================="); } }

运行结果如图：

4.2 OutputStreamReader

转换流java.io.OutputStreamWriter ，是Writer的子类，是从字符流到字节流的桥梁。使用指定的字符集将字符编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。

构造方法

OutputStreamWriter(OutputStream in): 创建一个使用默认字符集的字符流。OutputStreamWriter(OutputStream in, String charsetName): 创建一个指定字符集的字符流。

代码运行如下：

/* 练习：转换文件编码 将GBK编码的文本文件，转换为UTF-8编码的文本文件。 分析: 1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称GBK 2.创建OutputStreamWriter对象,构造方法中传递字节输出流和指定的编码表名称UTF-8 3.使用InputStreamReader对象中的方法read读取文件 4.使用OutputStreamWriter对象中的方法write,把读取的数据写入到文件中 5.释放资源 */ public class Demo04Test { public static void main(String[] args) throws IOException { //1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称GBK InputStreamReader isr = new InputStreamReader(new FileInputStream("day16\\我是GBK格式的文本.txt"),"GBK"); //2.创建OutputStreamWriter对象,构造方法中传递字节输出流和指定的编码表名称UTF-8 OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day16\\我是UTF-8格式的文本.txt"),"UTF-8"); //3.使用InputStreamReader对象中的方法read读取文件 int len = 0; while((len = isr.read()) != -1){ //4.使用OutputStreamWriter对象中的方法write,把读取的数据写入到文件中 osw.write(len); } // 5.释放资源 osw.close(); isr.close(); } }

运行结果如图：

转换流是字节与字符间的桥梁！

5 对象流

Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的数据、对象的类型和对象中存储的属性等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。

反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。对象的数据、对象的类型和对象中存储的数据信息，都可以用来在内存中创建对象。看图理解序列化：

5.1 ObjectOutputStream

java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。

构造方法

public ObjectOutputStream(OutputStream out)： 创建一个指定OutputStream的ObjectOutputStream。

构造举例，代码如下：

FileOutputStream fileOut = new FileOutputStream("java.txt"); ObjectOutputStream out = new ObjectOutputStream(fileOut);

序列化操作

一个对象要想序列化，必须满足两个条件: 该类必须实现java.io.Serializable 接口，Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出NotSerializableException 。该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。

2.写出对象方法

public final void writeObject (Object obj) : 将指定的对象写出。

5.2 ObjectInputStream

ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

构造方法

public ObjectInputStream(InputStream in)： 创建一个指定InputStream的ObjectInputStream。

反序列化操作1

如果能找到一个对象的class文件，我们可以进行反序列化操作，调用ObjectInputStream读取对象的方法：

public final Object readObject () : 读取一个对象。

注意： 对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个 ClassNotFoundException 异常。

反序列化操作2

当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个InvalidClassException异常。**发生这个异常的原因如下：

该类的序列版本号与从流中读取的类描述符的版本号不匹配该类包含未知数据类型该类没有可访问的无参数构造方法

Serializable 接口给需要序列化的类，提供了一个序列版本号。serialVersionUID 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。

序列化集合代码如下：

/* 练习：序列化集合 当我们想在文件中保存多个对象的时候 可以把多个对象存储到一个集合中 对集合进序列化和反序列化 分析: 1.定义一个存储Person对象的ArrayList集合 2.往ArrayList集合中存储Person对象 3.创建一个序列化流ObjectOutputStream对象 4.使用ObjectOutputStream对象中的方法writeObject,对集合进行序列化 5.创建一个反序列化ObjectInputStream对象 6.使用ObjectInputStream对象中的方法readObject读取文件中保存的集合 7.把Object类型的集合转换为ArrayList类型 8.遍历ArrayList集合 9.释放资源 */ public class Demo03Test { public static void main(String[] args) throws IOException, ClassNotFoundException { //1.定义一个存储Person对象的ArrayList集合 ArrayList<Person> list = new ArrayList<>(); //2.往ArrayList集合中存储Person对象 list.add(new Person("张三",18)); list.add(new Person("李四",19)); list.add(new Person("王五",20)); //3.创建一个序列化流ObjectOutputStream对象 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day16\\list.txt")); //4. 使用ObjectOutputStream对象中的方法writeObject，对集合进行序列化 oos.writeObject(list); //5.创建一个反序列化ObjectInputStream对象 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day16\\list.txt")); //6.使用ObjectInputStream对象中的方法readObject读取文件中保存的集合 Object o = ois.readObject(); //7.把Object类型的集合转换为ArrayList类型 ArrayList<Person> list2 = (ArrayList<Person>)o; //8.遍历ArrayList集合 for (Person p : list2) { System.out.println(p); } //9.释放资源 ois.close(); oos.close(); } } public class Person implements Serializable { private static final long serialVersionUID = 1L; private String name ; private int age; public Person() { } Person(String name, int age) { this.name = name; this.age = age; } @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + '}'; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }

运行结果如图：

6 打印流

平时我们在控制台打印输出，是调用print方法和println方法完成的，这两个方法都来自于java.io.PrintStream类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式。

6.1 PrintStream类

构造方法

public PrintStream(String fileName)： 使用指定的文件名创建一个新的打印流。

如果使用继承自父类的write方法写数据,那么查看数据的时候会查询编码表 97->a 如果使用自己特有的方法print/println方法写数据,写的数据原样输出 97->97

使用System.setOut方法改变输出语句的目的地改为参数中传递的打印流的目的地， 输出语句,默认在控制台输出 static void setOut(PrintStream out) 重新分配“标准”输出流。

代码运行如下：

public class Demo01PrintStream { public static void main(String[] args) throws FileNotFoundException { show01(); show02(); } private static void show02() throws FileNotFoundException { System.out.println("我是在控制台输出的~"); PrintStream ps = new PrintStream("day16\\print.txt"); System.setOut(ps);//把输出语句的目的地改变为打印流的目的地 System.out.println("我在打印流的目的地中输出"); ps.close(); } public static void show01() throws FileNotFoundException { //创建打印流PrintStream对象,构造方法中绑定要输出的目的地 PrintStream ps = new PrintStream("day16\\print.txt"); //如果使用继承父类write方法写数据，那么查看数据的时候会查询编码表 ps.write(97); //如果使用自己特有的方法print/println写数据，写的数据会原样输出 ps.println(97); ps.println("Hello Java"); } }

运行结果如图：