猿创征文｜Java中的IO流大家族 （两万字详解）

目录

IO流

概述

IO流，什么是IO？
I:Input
O:Output
通过IO可以完成硬盘文件的读和写。

分类

IO流有多种分类方式:
一种方式是按照流的方向进行分类:
以内存作为参照物，
往内存中去，叫做输入(Input)。或者叫做读(Read)。
从内存中出来，叫做输出(Output)。或者叫做写(Write)

另一种方式是按照读取数据方式不同进行分类:
有的流是按照字节的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制，这种流是万能的，什么类型的文件都可以读取。包括:文本文件，图片，声音文件，视频。
假设文件file1.txt，采用字节流的话是这样读的:
a中国bc张三fe
第一次读:一个字节，正好读到’a’
第二次读:一个字节，正好读到’中’字符的一半。
第三次读:一个字节，正好读到’中’字符的另外一半。

有的流是按照字符的方式读取数据的，一次读取一个字符，这种流是为了方便读取普通文本文件而存在的，这种流不能读取:图片、声音、视频等文件。只能读取纯文本文件，连word文件都无法读取。
假设文件filel.txt，采用字符流的话是这样读的:
a中国bc张三fe
第一次读:'a’字符(a字符在windows系统中占用1个字节。)
第二次读:'中’字符(中字符在windows系统中占用2个字节。)

综上所述：流的分类是输入流、输出流、字节流、字符流。

四大家族

java IO流这块有四大家族:
四大家族的首领:
java.io.Inputstream字节输入流
java.io.Outputstream字节输出流
java.io.Reader 字符输入流
java.io.Writer 字符输出流
四大家族的首领都是抽象类。(abstract class)

所有的流都实现了:
java.io.closeable接口，都是可关闭的，都有close()方法。
流毕竟是一个管道，这个是内存和硬盘之间的通道，用完之后一定要关闭，不然会耗费(占用)很多资源。养成好习惯，用完流一定要关闭。

所有的输出流都实现了:
java.io.Flushable接口，都是可刷新的，都有flush()方法。
养成一个好习惯，输出流在最终输出之后，一定要记得flush()刷新一下。这个刷新表示将通道/管道当中剩余未输出的数据强行输出完(清空管道!)刷新的作用就是清空管道。注意:如果没有flush()可能会导致丢失数据。

注意:在java中只要"类名"以stream结尾的都是字节流。以“Reader/Writer”结尾的都是字符流。

需要掌握的16个流

Java中的IO流都已经写好了，我们程序员不需要关心，我们最主要还是掌握，在java中已经提供了哪些流，每个流的特点是什么，每个流对象上的常用方法有哪些???
java中所有的流都是在:java.io.*;下。
java中主要还是研究:
怎么new流对象。
调用流对象的哪个方法是读，哪个方法是写。

java.io包下需要掌握的流有16个:

文件专属:
java.io.FileInputstream
java.io.FileOutputstream
java.io.FileReader
java.io.FileWriter

转换流:(将字节流转换成字符流)
java.io.InputStreamReader
java.io.OutputStreamWriter

缓冲流专属:
java.io.BufferedReader
java.io.BufferedWriter
java.io.BufferedInputStream
java.io.BufferedOutputStream

数据流专属:
java.io.DataInputStream
java.io.DataOutputStream

标准输出流:
java.io.PrintWriter
java.io.PrintStream

对象专属流:
java.io.ObjectInputStream
java.io.ObiectOutputStream

文件专属

FileInputstream（读 字节）

java.io.FileInputStream:
1、文件字节输入流，万能的，任何类型的文件都可以采用这个流来读。
2、字节的方式，完成输入的操作，完成读的操作(硬盘—>内存)

Read()方法:读取内容，返回值是读到几个数量，就返回几，当读完的时候，返回-1，就代表没有了

publicclassFileInputStream读 {publicstaticvoidmain(String[] args)throwsIOException{FileInputStream fis =null;try{//创建文件字节流输入对象
            fis =newFileInputStream("D:\\AJava\\新建文件夹\\aaa");/* while (true){
                int rea = fis.read(); //read（）:读文件
                if (rea == -1 ){
                    break;
                }
                System.out.println(rea);
            }*///改造whileint aaa =0;while((aaa= fis.read())!=-1){System.out.println(aaa);}}catch(FileNotFoundException e){
            e.printStackTrace();}finally{//关闭流的前提是流不是空，流是空没有必要关if(fis !=null){
                fis.close();}}}}

分析以上程序的缺点:
一次读取一个字节byte，这样内存和硬盘交互太频繁，基本上时间/资源都耗费在交互上面了。能不能一次读取多个字节呢?可以。

publicclassFileInputStream读最终版 {publicstaticvoidmain(String[] args){FileInputStream fil =null;try{//创建文件字节输入流
            fil =newFileInputStream("JAVAse进阶/src/IO流/aa");//开始读，采用byte数组，一次读取多个字节。最多读取“数组.length”个字节byte[] bytes=newbyte[4];//准备一个4个长度的byte数组，一次最多读取4个字节/*            while (true){
                int rea = fil.read(bytes);
                if (rea==-1){
                    break;
                }
                System.out.print(new String(bytes,0,rea));
            }*/int aaa=0;//提前准备一个变量while((aaa=fil.read(bytes))!=-1){//使用String构造方法，将byte转换为字符串，从0开始，到aaa结束，转换这么多//aaa返回的是读取字节数量。System.out.print(newString(bytes,0, aaa));}}catch(FileNotFoundException e){
            e.printStackTrace();}catch(IOException e){
            e.printStackTrace();}finally{if(fil !=null){try{
                    fil.close();}catch(IOException e){
                    e.printStackTrace();}}}}}

FileInputStream类的其他常用方法

**FileInputstream类的其它常用方法:

int available():

返回流当中剩余的没有读到的字节数量

Long skip(long n):

跳过几个字节不读。**

publicclassFileInputStream类的其他常用方法 {publicstaticvoidmain(String[] args){FileInputStream fil =null;try{
            fil =newFileInputStream("JAVAse进阶/src/IO流/aa");System.out.println(fil.available());//准备一个长度为fil.available长度的数组，一次最多读fil.available()个字节byte[] bytes =newbyte[fil.available()];// 这种方式不太适合太大文件，因为byte数组不能太大//不需要循环了，直接读一次就行了，返回的是一次读到的字节int read = fil.read(bytes);//读取到的字节转换为字符串输出System.out.println(newString(bytes));}catch(FileNotFoundException e){
            e.printStackTrace();}catch(IOException e){
            e.printStackTrace();}finally{if(fil !=null){try{
                    fil.close();}catch(IOException e){
                    e.printStackTrace();}}}}}

FileOutputStream (写 字节)

文件字节输出流，负责写。从内存到硬盘。

publicclassFileOutputStream写 {publicstaticvoidmain(String[] args){FileOutputStream fos=null;try{//如果没有这个文件，会自动创建一个//这种构造方法会将原文件清空，然后重新写入//fos = new FileOutputStream("JAVAse进阶/src/IO流/aa");//这个构造方法，以追加的方式在文件末尾写入，不会清空原文件内容。
            fos =newFileOutputStream("JAVAse进阶/src/IO流/aa",true);//开始写byte[] bytes ={97,98,99,100};//将byte全部写出
            fos.write(bytes);//将byte数组一部分写出 从下标0开始，取2个
            fos.write(bytes,0,2);//字符串String s ="我是一个中国人";//将字符串转换成byte数组。byte[] bytes1 = s.getBytes(StandardCharsets.UTF_8);//写
            fos.write(bytes1);//写完之后一定要刷新
            fos.flush();}catch(FileNotFoundException e){
            e.printStackTrace();}catch(IOException e){
            e.printStackTrace();}finally{if(args !=null){try{
                    fos.close();}catch(IOException e){
                    e.printStackTrace();}}}}}

运行后文件末尾会多出：abcdab我是一个中国人

文件复制

使用FileInputStream+FileOutputStream完成文件的拷贝。拷贝的过程应该是一边读，一边写。
使用以上的字节流拷贝文件的时候，文件类型随意，万能的。什么样的文件都能拷贝。

publicclass 文件复制 {publicstaticvoidmain(String[] args){FileInputStream fis =null;FileOutputStream fos =null;try{//创建一个输入流对象
            fis=newFileInputStream("D:\\a剪辑\\完成视频\\123.mp4");//创建一个输出流对象
            fos =newFileOutputStream("D:\\123.mp4");//最核心 一边写 一边读byte[] bytes =newbyte[1024*1024];//1MB(一次最多拷贝1MB)int aa =0;while((aa= fis.read(bytes))!=-1){//Fis.Read(bytes) :往bytes数组中读
                fos.write(bytes,0,aa);// 然后从数组拿出来 一次写aa个，aa是写入数组的数量}//刷新 输出流最后要刷新
            fos.flush();}catch(FileNotFoundException e){
            e.printStackTrace();}catch(IOException e){
            e.printStackTrace();}finally{if(fos ==null){// 分开try，不要一起try// 一起try的时候，其中一个异常，可能会影响另外一个流的关闭。try{
                    fis.close();}catch(IOException e){
                    e.printStackTrace();}try{
                    fos.close();}catch(IOException e){
                    e.printStackTrace();}}}}}

FileReader（读 字符）

FileReader ：文件字符输入流。只能读取普通文本。
读取文本内容时，比较方便，快捷。

FileReader 和上面 FileInputStream（读 字节）的使用方法一样，直接照葫芦画瓢

publicclassFileReader读 {publicstaticvoidmain(String[] args){FileReader fileReader =null;try{//创建文件字符输入流
            fileReader =newFileReader("JAVAse进阶/src/IO流/aa");//开始读char[] chars =newchar[4];//一次读四个字符int red =0;while((red = fileReader.read(chars))!=-1){//使用String构造方法，将char转换为字符串，从0开始，到red结束，转换这么多//red返回的是读取字符数量。System.out.print(newString(chars,0,red));}}catch(FileNotFoundException e){
            e.printStackTrace();}catch(IOException e){
            e.printStackTrace();}finally{if(fileReader !=null){try{
                    fileReader.close();}catch(IOException e){
                    e.printStackTrace();}}}}}

FileWriter （写 字符）

FileWriter： 文件字符输出流，只能输出普通文本。

publicclassFileWriter写 {publicstaticvoidmain(String[] args){FileWriter fileWriter =null;try{//创建文件字符流对象 清空原文内容在写入//fileWriter = new FileWriter("JAVAse进阶/src/IO流/aa");//加个ture 表示不清空原文内容，从后面追加
            fileWriter =newFileWriter("JAVAse进阶/src/IO流/aa",true);//创建一个char数组char[] chars ={'我','是','中','国','人'};//全部写出
            fileWriter.write(chars);//部分写出，下标从2开始，取三个
            fileWriter.write(chars,2,3);//直接传入一个String也是可以的
            fileWriter.write("我是中国人");//换行符
            fileWriter.write("\n");
            fileWriter.write("励志当一个程序员");//刷新  写出都要刷新
            fileWriter.flush();}catch(IOException e){
            e.printStackTrace();}finally{if(fileWriter !=null){try{
                    fileWriter.close();}catch(IOException e){
                    e.printStackTrace();}}}}}

复制普通文本文件

使用FileReader, FileWriter进行拷贝的话，只能拷贝“普通文本”文件。

publicclass 复制普通文本文件 {publicstaticvoidmain(String[] args){FileReader du =null;FileWriter xie =null;try{//读
            du =newFileReader("JAVAse进阶/src/IO流/aa");//写
            xie =newFileWriter("aa");//一边读一边写char[] chars =newchar[1024*512];int aa =0;//du.read(chars) 往chars数组中读while((aa =du.read(chars))!=-1){//读多少写多少
                xie.write(chars,0,aa);}//刷新
            xie.flush();}catch(FileNotFoundException e){
            e.printStackTrace();}catch(IOException e){
            e.printStackTrace();}finally{if(xie !=null){try{
                    xie.close();}catch(IOException e){
                    e.printStackTrace();}}if(du !=null){try{
                    du.close();}catch(IOException e){
                    e.printStackTrace();}}}}}

缓冲流专属和转换流

BufferedReader读，和InputStreamReader转换流联合使用

BufferedReader:
带有缓冲区的字符输入流。
使用这个流的时候不需要自定义char数组，或者说不需要自定义byte数组。自带缓冲。

BufferedReader的括号里面要求传的是Reader(字符输入流)，如果要传字节输入流，就要使用转换流(InputStreamReader)，使字节输入流转成字符输入流。

publicclassBufferedReader读_加转换流 {publicstaticvoidmain(String[] args){BufferedReader br=null;FileReader fr =null;FileInputStream fis =null;InputStreamReader isr =null;try{/* 这里面演示的是BufferedReader传入一个Reader
            这个构造方法里面只能传入Reader类型的，如果要传入字节输入流，就要用转换流转换
            fr = new FileReader("D:\\AJava\\新建文件夹\\aaa");
            br = new BufferedReader(fr);*///这个构造方法里面只能传入字符输入流类型。传入字节输入流要使用转换流，把字节输入流转换成字符入出流//演示传入字节输入流 用转换流//创建字节输入流对象
            fis =newFileInputStream("aa");//创建转换流对象（字节输入转换成字符输入）
            isr=newInputStreamReader(fis);//创建BufferdReader对象
            br =newBufferedReader(isr);/*上面的合并在一起写 也就不用上面的赋值null了
            //当一个流的构造方法中需要一个流的时候，这个被传进来的流叫做:节点流。外部负责包装的这个流，叫做:包装流，还有一个名字叫做:处理流。
            br = new BufferedReader(new InputStreamReader(new FileInputStream("aa")));*///readLine()读取一行内容，当读到末尾没有内容的时候，返回nullString aa =null;while((aa = br.readLine())!=null){System.out.println(aa);}/*String s = br.readLine();
            System.out.println(s);读一行内容*/}catch(FileNotFoundException e){
            e.printStackTrace();}catch(IOException e){
            e.printStackTrace();}finally{if(fr !=null){try{
                    br.close();//对于包装流来说，只需要关闭最外层的流就行，里面的节点会自动关闭。}catch(IOException e){
                    e.printStackTrace();}}}}}

BufferedWriter写，和OutputStreamWriter转换流联合使用

BufferedWriter ：带有缓冲的字符输出流。
OutputStreamWriter：转换流。

BufferedWriter 括号里面要求传的是writer(字符输出流)，如果要传字节输出流，就要使用转换流(OutputStreaWriter)，使字节输出流转换成字符输出流。

publicclassBufferedWriter写_加转换流 {publicstaticvoidmain(String[] args){BufferedWriter bw  =null;try{/*传入字符writer类型的输出流
            bw = new BufferedWriter(new FileWriter("aa",true));*///里面只能传入字符输出流类型。传入字节输出流要使用转换流，把字节输出流转换成字符输出流
            bw =newBufferedWriter(newOutputStreamWriter(newFileOutputStream("JAVAse进阶/src/IO流/aa",true)));

            bw.write("我是一个大帅哥");
            bw.write("\n");
            bw.write("你好大帅哥");//刷新
            bw.flush();}catch(FileNotFoundException e){
            e.printStackTrace();}catch(IOException e){
            e.printStackTrace();}finally{if(bw !=null){try{
                    bw.close();//关闭最外层}catch(IOException e){
                    e.printStackTrace();}}}}}

数据流专属

DataOutputStream 写

java.io.DataOutputStream:数据专属的流。这个流可以将数据连同数据的类型一并写入文件。
注意:这个文件不是普通文本文档。(这个文件使用记事本打不开。)

publicclass 数据流_写 {publicstaticvoidmain(String[] args)throwsIOException{// 创建数据专属的字节输入流DataOutputStream dos =newDataOutputStream(newFileOutputStream("JAVAse进阶/src/IO流/aa"));// 写数据byte b =100;short s =200;int i =300;long l =400;float f =3.0F;double d =3.14;boolean sex =false;char c ='a';// 写
        dos.writeByte(b);// 把数据以及数据的类型一并写入到文件当中。
        dos.writeShort(s);
        dos.writeInt(i);
        dos.writeLong(l);
        dos.writeFloat(f);
        dos.writeDouble(d);
        dos.writeBoolean(sex);
        dos.writeChar(c);//刷新
        dos.flush();}}

DataInputStream 读

DataInputStream:数据字节输入流。
DataOutputStream写的文件，只能使用DataInputStream去读。并且读的时候你需要提前知道写入的顺序。读的顺序需要和写的顺序一致。才可以正常取出数据。

publicclass 数据流_读 {publicstaticvoidmain(String[] args)throwsIOException{//创建对象DataInputStream dis =newDataInputStream(newFileInputStream("JAVAse进阶/src/IO流/aa"));//开始读byte b = dis.readByte();short s = dis.readShort();int i = dis.readInt();long l = dis.readLong();float f = dis.readFloat();double d = dis.readDouble();boolean sex = dis.readBoolean();char c = dis.readChar();

        dis.close();System.out.println(b);System.out.println(s);System.out.println(i);System.out.println(l);System.out.println(f);System.out.println(d);System.out.println(sex);System.out.println(c);}}

输出结果：

标准输出流

//联合起来写System.out.println("hello world!");//分开写PrintStream ps =System.out;
        ps.println("hello world!");

标准输出流不需要手动close()关闭。可以改变标准输出流的输出放向

publicclassPringtStream标准输出流 {publicstaticvoidmain(String[] args){PrintStream printStream =null;try{//标准输出流不在指向控制台，指向log输出流文件
            printStream =newPrintStream(newFileOutputStream("log输出流文件",true));//修改输出方向，将输出方向修改到“log输出流文件”文件System.setOut(printStream);//下面输出的 ，就不会再控制台显示了，会写入到“log输出流文件”这个文件System.out.println("你好");System.out.println("iedsoafj");}catch(FileNotFoundException e){
            e.printStackTrace();}}}

执行结果

会发现没有输出到控制台，而是输出到了指定文件

利用标准输出流做一个记录日志工具

/*
日志工具
 */publicclass logger {/**
     * 记录日志的方法
     * @param msg 发生了神什么事
     */publicstaticvoidlog(String msg){//PrintStream printStream = null;try{//指向一个日志文件PrintStream printStream =newPrintStream(newFileOutputStream("JAVAse进阶/src/IO流/输出流日志/log.txt",true));//PrintStream printStream = new PrintStream(new FileOutputStream("JAVAse进阶/src/IO流/输出流日志/log.txt"),true);//改变输出方向System.setOut(printStream);//日期当前时间Date date =newDate();SimpleDateFormat sdf =newSimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");String format = sdf.format(date);//什么时间发生了什么事件System.out.println(format+":"+msg);}catch(FileNotFoundException e){
            e.printStackTrace();}}}

publicclass 测试日志方法 {publicstaticvoidmain(String[] args){//测试工具类
        logger.log("有灰正在编写java代码");
        logger.log("有灰正在测试日志工具类");
        logger.log("写一上午代码的有灰，眼睛好累，好模糊！");}}

运行后输出结果

会发现已经在文件中记录

File类

1、File类和四大家族没有关系，所以File类不能完成文件的读和写。
2、File对象代表什么?
文件和目录路径名的抽象表示形式。
C:\Drivers这是一个File对象
C:\Drivers\LanRealtek\Readme.txt也是File对象。
一个File对象有可能对应的是目录，也可能是文件。 File只是一个路径名的抽象表示形式。
3、需要掌握File类中常用的方法。

14个常用方法

**

exists():

判断这个文件是否存在

createNewFile():

以文件的形式创建出来

file.mkdir():

以目录的形式创建出来

mkdirs():

可以创建多重目录

getParent():

获取文件的父路径

getParentFile():

获取文件的父路径,和上面的返回类型不一样，其他都一样

getAbsolutePath():

获取绝对路径

getName():

获取文件名

isDirectory():

判断是否是一个目录

isFile():

判断是否是一个文件

lastModified():

获取文件最后一次修改时间

length（）：

获取文件大小

listFiles():

获取当前目录下所有的子文件。返回值是File[], 遍历输出获得这个路径下的子文件的绝对路径

list():

返回值是String[], 遍历输出获得这个路径下的子文件的文件名**

详细介绍

publicclassFile类的常用方法 {publicstaticvoidmain(String[] args)throwsIOException{//创建File对象File file =newFile("D:\\AJava\\新建文件夹1");//exists():判断这个文件是否存在System.out.println(file.exists());//createNewFile():如果D:\AJava\新建文件夹1不存在，则以文件的形式创建出来if(!file.exists()){
            file.createNewFile();//此处有异常}//file.mkdir():如果D:\AJava\新建文件夹1不存在，则以目录的形式创建出来if(!file.exists()){//
            file.mkdir();}//mkdirs()可以创建多重目录File file1 =newFile("D:\\AJava\\a\\ab\\cd\\ef");if(!file1.exists()){
            file1.mkdirs();}File file2 =newFile("D:\\AJava\\新建文件夹\\新建文件夹\\你好.txt");//getParent():获取文件的父路径String parent = file2.getParent();System.out.println(parent);//D:\AJava\新建文件夹\新建文件夹//getParentFile():获取文件的父路径,和上面的返回类型不一样，其他都一样File parentFile = file2.getParentFile();//返回的是File对象，还可以继续掉其他方法System.out.println(parentFile);//D:\AJava\新建文件夹\新建文件夹File file3 =newFile("aa");//getAbsolutePath():获取绝对路径System.out.println("绝对路径："+ file3.getAbsolutePath());//绝对路径：D:\AJava\xiangmu\aa//getName():获取文件名System.out.println("文件名："+file3.getName());//isDirectory():判断是否是一个目录System.out.println(file3.isDirectory());//false//isFile():判断是否是一个文件System.out.println(file3.isFile());//true//lastModified():获取文件最后一次修改时间long l = file3.lastModified();//这个毫秒是从1970年到现在的总毫秒数//将总毫秒数转换成日期Date date =newDate(l);SimpleDateFormat simpleDateFormat =newSimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS ");String format = simpleDateFormat.format(date);System.out.println(format);//2021-07-16 10:50:23 937//length（）：获取文件大小System.out.println(file3.length());//74字节File f =newFile("D:\\AJava");//listFiles():获取当前目录下所有的子文件。返回值是File[], 遍历输出获得这个路径下的子文件的绝对路径File[] files = f.listFiles();for(File e : files){System.out.println(e);//和绝对路径一样//System.out.println(e.getName()); //所有的文件名//System.out.println(e.getAbsolutePath());//所有的绝对路径}//list():返回值是String[], 遍历输出获得这个路径下的子文件的文件名String[] a = f.list();for(String s : a){System.out.println(s);}}}

序列化和反序列化

1、java.io.NotSerializableException:
Student对象不支持序列化!!!

2、参与序列化和反序列化的对象，必须实现serializable接口。

3、注意:通过源代码发现Serializable接口只是一个标志接口:
public interface Serializable{}
这个接口当中什么代码都没有。那么它起到一个什么作用呢?
起到标识的作用，标志的作用，java虚拟机看到这个类实现了这个接口，可能会对这个类进行特殊待遇。 Serializable这个标志接口是给java虚拟机参考的，java虚拟机看到这个接口之后，会为该类自动生成一个序列化版本号。

例如：它可以把内存中某个对象持久化、永久性的保存到硬盘文件，断电之后这个状态还在；下一次重启电脑的时候，再把硬盘上的文件恢复发哦内存当中。

单个对象序列化（ObjectOutputStream）

Student对象

publicclassStudentimplementsSerializable{//Java虚拟机看到Serializable接口之后，会自动生成一个序列化版本号。//这里没有手动写出来，Java虚拟机会自动提供这个序列化版本号privateint no ;//transient (穿森的) ：关键字 表示游离，不参与序列化privatetransientString name;//name 不参与序列化操作publicStudent(){}publicStudent(int no,String name){this.no = no;this.name = name;}publicintgetNo(){return no;}publicvoidsetNo(int no){this.no = no;}publicStringgetName(){return name;}publicvoidsetName(String name){this.name = name;}@OverridepublicStringtoString(){return"Student{"+"no="+ no +", name='"+ name +'\''+'}';}}

publicclass 序列化的实现 {publicstaticvoidmain(String[] args)throwsException{//创建java对象Student s =newStudent(1111,"zhangsna");//序列化   异常先抛出去了 不管了ObjectOutputStream oos =newObjectOutputStream(newFileOutputStream("JAVAse进阶/src/IO流/序列化和反序列化/students"));//序列化对象
        oos.writeObject(s);//刷新
        oos.flush();//关闭
        oos.close();}}

反序列化（ObjectInputStream）

publicclass 反序列化的实现 {publicstaticvoidmain(String[] args)throwsException{//创建反序列化对象ObjectInputStream ois =newObjectInputStream(newFileInputStream("JAVAse进阶/src/IO流/序列化和反序列化/students"));//开始反序列化  读Object obj = ois.readObject();//反序列化回来是一个学生对象。所以会调用学生对象的toString方法System.out.println(obj);//Student{no=1111, name='zhangsna'}//关闭
        ois.close();}}

集合序列化和反序列化

一次序列化多个对象，将对象方放到集合中，序列化集合

提示：参与序列化的ArrayList集合以及集合中的User元素都需要实现java.io.Serializable接口
ArrayList集合已经实现了这个接口，所以我们要把我们自己定义的类(User)实现了

序列化多个对象集合（ObjectOutputStream ）

User对象

publicclassUserimplementsSerializable{privateint no ;privateString name;publicUser(){}publicUser(int no,String name){this.no = no;this.name = name;}publicintgetNo(){return no;}publicvoidsetNo(int no){this.no = no;}publicStringgetName(){return name;}publicvoidsetName(String name){this.name = name;}@OverridepublicStringtoString(){return"User{"+"no="+ no +", name='"+ name +'\''+'}';}}

实现

publicclass 序列化多个对象集合 {publicstaticvoidmain(String[] args)throwsException{List<User> userList =newArrayList<>();
        userList.add(newUser(1,"zhangsan"));
        userList.add(newUser(2,"lisi"));
        userList.add(newUser(3,"wnagwu "));
        userList.add(newUser(4,"zhaliu"));ObjectOutputStream oos =newObjectOutputStream(newFileOutputStream("JAVAse进阶/src/IO流/序列化和反序列化/users"));//一次序列化一个集合，这个集合对象中放了很多其他对象。
        oos.writeObject(userList);

        oos.flush();
        oos.close();}}

反序列化集合（ObjectInputStream ）

publicclass 反序列化集合 {publicstaticvoidmain(String[] args)throwsException{ObjectInputStream ois =newObjectInputStream(newFileInputStream("JAVAse进阶/src/IO流/序列化和反序列化/users"));//Object o = ois.readObject();//System.out.println(o instanceof List); //true 代表o是一个List集合//ois.readObject()返回的是一个List集合，读出来后直接强转成List<User>对象List<User> userList =(List<User>)ois.readObject();//for循环 取出每个序列化对象for(User user : userList){System.out.println(user);//User的tuString已经重写}
        ois.close();}}

序列化版本号

序列化版本号有什么用呢?
java.io.InvalidClassException:
com.java.bean.Student ；
Local class incompatible:
stream classdesc serialVersionUID=-684255398724514298(十年后)
local class serialVersionUID=-3463447116624555755(十年前)

java语言中是采用什么机制来区分类的?
第一:首先通过类名进行比对，如果类名不一样，肯定不是同一个类。
第二:如果类名一样，再怎么进行类的区别?靠序列化版本号进行区分。

小鹏编写了一个类:com.java.bean.Student implements Serializable
胡浪编写了一个类:com.java.bean.Student implements Serializable不同的人编写了同一个类，但“这两个类确实不是同一个类”。这个时候序列化版本就起上作用了。
对于iava虚拟机来说，java虚拟机是可以区分开这两个类的，因为这两个类都实现了Serializable接口，都有默认的序列化版本号，他们的序列化版本号不一样。所以区分开了。(这是自动生成序列化版本号的好处。

请思考?
这种自动生成序列化版本号有什么缺陷?
这种自动生成的序列化版本号缺点是:一旦代码确定之后，不能进行后续的修改。因为只要修改，必然会重新编译，此时会生成全新的序列化版本号，这个时候java虚拟机会认为这是一个全新的类，重新序列化后，生成新的序列化版本号，之前序列化进去的东西，再反序列化后就会出问题，因为前后序列化版本号不一样。(这样就不好了!)
所以 可以手动写个序列化版本号固定的。

最终结论:
凡是一个类实现了Serializable接口，建议给该类提供一个固定不变的序列化版本号。这样，以后这个类即使代码修改了，但是版本号不变，java虚拟机会认为是同一个类。

publicclassStudentimplementsSerializable{//Java虚拟机看到Serializable接口之后，会自动生成一个序列化版本号。//这里没有手动写出来，Java虚拟机会自动提供这个序列化版本号// 建议将序列化版本号手动的写出来。不建议自动生成privatestaticfinallong serialVersionUID =1L;//手动写出来// 如果是自动生成的序列化版本号，过了很久，Student这个类的源代码改动了，// 源代码改动之后，需要重新编译，编译之后生成了全新的字节码文件，// 并且class文件再次运行的时候，java虚拟机生成的序列化版本号也会发生相应的改变，//而上面自己手动写了一个固定的序列化版本号，以后这个类即使代码修改了，但是版本号不变，java虚拟机会认为是同一个类。privateint no ;privateString name;publicStudent(){}publicStudent(int no,String name){this.no = no;this.name = name;}publicintgetNo(){return no;}publicvoidsetNo(int no){this.no = no;}publicStringgetName(){return name;}publicvoidsetName(String name){this.name = name;}@OverridepublicStringtoString(){return"Student{"+"no="+ no +", name='"+ name +'\''+'}';}}

IDEA工具生成版本号快捷键

首先进入设置把下面图片红框框出来的那一栏打上勾

IO和Properties属性类的联合应用

IO+Properties的联合应用。
非常好的一个设计理念:
以后经常改变的数据，可以单独写到一个文件中，使用程序动态读取。将来只需要修改这个文件的内容，Java代码不需要改动，不需要重新编译，服务器也不需要重启。就可以拿到动态的信息。

类似于以上机制的这种文件被称为配置文件。并且当配置文件中的内容格式是:
key1=value
key2=value
的时候，我们把这种配置文件叫做属性配置文件。

java规范中有要求:属性配置文件建议以.properties结尾，但这不是必须的。这种以.properties结尾的文件在java中被称为:属性配置文件。其中Properties是专门存放属性配置文件内容的一个类。

示例

配置文件

代码

publicclass IO和Properties联合应用 {publicstaticvoidmain(String[] args)throwsException{/*
            Properties是一个Map集合，Key和Value都是String类型
            想将aaaa文件中的数据加载到Properties对象当中。
         *///新建一个输入流对象FileReader fileReader =newFileReader("JAVAse进阶/src/IO流/联合应用/aaaa.properties");//新建一个Map集合Properties properties =newProperties();//调用Properties对象的load方法将文件中的数据加载到Map集合中
        properties.load(fileReader);//文件中的数据顺着管道加载到Map集合中，其中等号左边是Key，右边是Value//通过Key来获取ValueString username = properties.getProperty("username");System.out.println(username);// 输出：adminString password = properties.getProperty("password");System.out.println(password);// 输出：123456}}