编程语言
首页 > 编程语言> > Java中的IO流大家族(Java中的IO详解)

Java中的IO流大家族(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,就代表没有了
public class FileInputStream读 {
          
   
    public static void main(String[] args) throws IOException {
          
   
        FileInputStream fis = null;
        try {
          
   
            //创建文件字节流输入对象
            fis = new FileInputStream("D:\AJava\新建文件夹\aaa");
           /* while (true){
                int rea = fis.read(); //read():读文件
                if (rea == -1 ){
                    break;
                }
                System.out.println(rea);
            }*/
            //改造while
            int aaa = 0;
            while ((aaa= fis.read())!=-1){
          
   
                System.out.println(aaa);
            }


        } catch (FileNotFoundException e) {
          
   
            e.printStackTrace();
        }finally {
          
   
            //关闭流的前提是流不是空,流是空没有必要关
            if (fis != null) {
          
   
                fis.close();
            }
        }

    }
}
分析以上程序的缺点: 一次读取一个字节byte,这样内存和硬盘交互太频繁,基本上时间/资源都耗费在交互上面了。能不能一次读取多个字节呢?可以。
public class FileInputStream读最终版 {
          
   
    public static void main(String[] args) {
          
   
        FileInputStream fil = null;
        try {
          
   
            //创建文件字节输入流
            fil = new FileInputStream("JAVAse进阶/src/IO流/aa");
            //开始读,采用byte数组,一次读取多个字节。最多读取“数组.length”个字节
            byte[] bytes= new byte[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(new String(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):跳过几个字节不读。
public class FileInputStream类的其他常用方法 {
          
   
    public static void main(String[] args) {
          
   
        FileInputStream fil = null;
        try {
          
   
            fil = new FileInputStream("JAVAse进阶/src/IO流/aa");
            System.out.println(fil.available());
            //准备一个长度为fil.available长度的数组,一次最多读fil.available()个字节
            byte[] bytes = new byte[fil.available()];// 这种方式不太适合太大文件,因为byte数组不能太大
            //不需要循环了,直接读一次就行了,返回的是一次读到的字节
            int read = fil.read(bytes);
            //读取到的字节转换为字符串输出
            System.out.println(new String(bytes));
        } catch (FileNotFoundException e) {
          
   
            e.printStackTrace();
        } catch (IOException e) {
          
   
            e.printStackTrace();
        } finally {
          
   
            if (fil != null) {
          
   
                try {
          
   
                    fil.close();
                } catch (IOException e) {
          
   
                    e.printStackTrace();
                }
            }
        }
    }
}

FileOutputStream (写 字节)

文件字节输出流,负责写。从内存到硬盘。
运行后文件末尾会多出:abcdab我是一个中国人

文件复制

使用FileInputStream+FileOutputStream完成文件的拷贝。拷贝的过程应该是一边读,一边写。 使用以上的字节流拷贝文件的时候,文件类型随意,万能的。什么样的文件都能拷贝。
public class 文件复制 {
          
   
    public static void main(String[] args) {
          
   
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
          
   
            //创建一个输入流对象
            fis= new FileInputStream("D:\a剪辑\完成视频\123.mp4");
            //创建一个输出流对象
            fos = new FileOutputStream("D:\123.mp4");

            //最核心 一边写 一边读
            byte[] bytes =new byte[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(读 字节)的使用方法一样,直接照葫芦画瓢
public class FileReader读 {
          
   
    public static void main(String[] args) {
          
   
        FileReader fileReader =  null;
        try {
          
   
            //创建文件字符输入流
            fileReader = new FileReader("JAVAse进阶/src/IO流/aa");
            //开始读
            char [] chars = new char[4]; //一次读四个字符
            int red = 0;
            while ((red = fileReader.read(chars))!=-1){
          
   
                //使用String构造方法,将char转换为字符串,从0开始,到red结束,转换这么多
                //red返回的是读取字符数量。
                System.out.print(new String(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: 文件字符输出流,只能输出普通文本。

复制普通文本文件

使用FileReader, FileWriter进行拷贝的话,只能拷贝“普通文本”文件。
public class 复制普通文本文件 {
          
   
    public static void main(String[] args) {
          
   
        FileReader du = null;
        FileWriter xie = null;
        try {
          
   
            //读
            du = new FileReader("JAVAse进阶/src/IO流/aa");
            //写
            xie = new FileWriter("aa");
            //一边读一边写
            char [] chars = new char[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),使字节输入流转成字符输入流。
public class BufferedReader读_加转换流 {
          
   
    public static void main(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 = new FileInputStream("aa");
            //创建转换流对象(字节输入转换成字符输入)
            isr= new InputStreamReader(fis);
            //创建BufferdReader对象
            br = new BufferedReader(isr);
            /*上面的合并在一起写 也就不用上面的赋值null了
            //当一个流的构造方法中需要一个流的时候,这个被传进来的流叫做:节点流。外部负责包装的这个流,叫做:包装流,还有一个名字叫做:处理流。
            br = new BufferedReader(new InputStreamReader(new FileInputStream("aa")));*/

            //readLine()读取一行内容,当读到末尾没有内容的时候,返回null
            String 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),使字节输出流转换成字符输出流。
public class BufferedWriter写_加转换流 {
          
   
    public static void main(String[] args) {
          
   
        BufferedWriter bw  =null;
        try {
          
   
            /*传入字符writer类型的输出流
            bw = new BufferedWriter(new FileWriter("aa",true));*/

            //里面只能传入字符输出流类型。传入字节输出流要使用转换流,把字节输出流转换成字符输出流
            bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("JAVAse进阶/src/IO流/aa",true)));

            bw.write("我是一个大帅哥");
            bw.write("
");
            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:数据专属的流。这个流可以将数据连同数据的类型一并写入文件。 注意:这个文件不是普通文本文档。(这个文件使用记事本打不开。)
public class 数据流_写 {
          
   
    public static void main(String[] args) throws IOException {
          
   
        // 创建数据专属的字节输入流
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("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去读。并且读的时候你需要提前知道写入的顺序。读的顺序需要和写的顺序一致。才可以正常取出数据。
public class 数据流_读 {
          
   
    public static void main(String[] args) throws IOException {
          
   
        //创建对象
        DataInputStream dis = new DataInputStream(new FileInputStream("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()关闭。可以改变标准输出流的输出放向

public class PringtStream标准输出流 {
          
   
    public static void main(String[] args) {
          
   
        PrintStream printStream = null;
        try {
          
   
            //标准输出流不在指向控制台,指向log输出流文件
            printStream = new PrintStream(new FileOutputStream("log输出流文件",true));
            //修改输出方向,将输出方向修改到“log输出流文件”文件
            System.setOut(printStream);
            //下面输出的 ,就不会再控制台显示了,会写入到“log输出流文件”这个文件
            System.out.println("你好");
            System.out.println("iedsoafj");
        } catch (FileNotFoundException e) {
          
   
            e.printStackTrace();
        }
    }
}
执行结果 会发现没有输出到控制台,而是输出到了指定文件

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

/*
日志工具
 */
public class logger {
          
   
    /**
     * 记录日志的方法
     * @param msg 发生了神什么事
     */
    public static void log(String msg) {
          
   
        //PrintStream printStream = null;
        try {
          
   
            //指向一个日志文件
            PrintStream printStream = new PrintStream(new FileOutputStream("JAVAse进阶/src/IO流/输出流日志/log.txt",true));

            //PrintStream printStream = new PrintStream(new FileOutputStream("JAVAse进阶/src/IO流/输出流日志/log.txt"),true);

            //改变输出方向
            System.setOut(printStream);

            //日期当前时间
            Date date = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
            String format = sdf.format(date);

            //什么时间发生了什么事件
            System.out.println(format+":"+msg);
        } catch (FileNotFoundException e) {
          
   
            e.printStackTrace();
        }
    }
}
public class 测试日志方法 {
          
   
    public static void main(String[] args) {
          
   
        //测试工具类
        logger.log("有灰正在编写java代码");
        logger.log("有灰正在测试日志工具类");
        logger.log("写一上午代码的有灰,眼睛好累,好模糊!");
    }
}
运行后输出结果 会发现已经在文件中记录

File类

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

14个常用方法

exists():判断这个文件是否存在 createNewFile():以文件的形式创建出来 file.mkdir():以目录的形式创建出来 mkdirs():可以创建多重目录 getParent():获取文件的父路径 getParentFile():获取文件的父路径,和上面的返回类型不一样,其他都一样 getAbsolutePath():获取绝对路径 getName():获取文件名 isDirectory():判断是否是一个目录 isFile():判断是否是一个文件 lastModified():获取文件最后一次修改时间 length():获取文件大小 listFiles():获取当前目录下所有的子文件。返回值是File[], 遍历输出获得这个路径下的子文件的绝对路径 list():返回值是String[], 遍历输出获得这个路径下的子文件的文件名

详细介绍

public class File类的常用方法 {
          
   
    public static void main(String[] args) throws IOException {
          
   
        //创建File对象
        File file = new File("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 = new File("D:\AJava\a\ab\cd\ef");
        if (!file1.exists()){
          
   
            file1.mkdirs();
        }

        File file2 = new File("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 = new File("aa");
        //getAbsolutePath():获取绝对路径
        System.out.println("绝对路径:"+ file3.getAbsolutePath());//绝对路径:D:AJavaxiangmuaa

        //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 = new Date(l);
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("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 = new File("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对象

public class Student implements Serializable {
          
   
    //Java虚拟机看到Serializable接口之后,会自动生成一个序列化版本号。
    //这里没有手动写出来,Java虚拟机会自动提供这个序列化版本号
    private int no ;

    //transient (穿森的) :关键字 表示游离,不参与序列化
    private  transient String name; //name 不参与序列化操作

    public Student() {
          
   
    }

    public Student(int no, String name) {
          
   
        this.no = no;
        this.name = name;
    }

    public int getNo() {
          
   
        return no;
    }

    public void setNo(int no) {
          
   
        this.no = no;
    }

    public String getName() {
          
   
        return name;
    }

    public void setName(String name) {
          
   
        this.name = name;
    }

    @Override
    public String toString() {
          
   
        return "Student{" +
                "no=" + no +
                ", name=" + name +  +
                };
    }
}
public class 序列化的实现 {
          
   
    public static void main(String[] args) throws Exception {
          
   
        //创建java对象
        Student s = new Student(1111,"zhangsna");
        //序列化   异常先抛出去了 不管了
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("JAVAse进阶/src/IO流/序列化和反序列化/students"));
        //序列化对象
        oos.writeObject(s);

        //刷新
        oos.flush();
        //关闭
        oos.close();
    }
}

反序列化(ObjectInputStream)

public class 反序列化的实现 {
          
   
    public static void main(String[] args) throws Exception {
          
   
        //创建反序列化对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("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对象

public class User implements Serializable {
          
   
    private int no ;
    private String name;

    public User() {
          
   
    }

    public User(int no, String name) {
          
   
        this.no = no;
        this.name = name;
    }

    public int getNo() {
          
   
        return no;
    }

    public void setNo(int no) {
          
   
        this.no = no;
    }

    public String getName() {
          
   
        return name;
    }

    public void setName(String name) {
          
   
        this.name = name;
    }

    @Override
    public String toString() {
          
   
        return "User{" +
                "no=" + no +
                ", name=" + name +  +
                };
    }
}

实现

public class 序列化多个对象集合 {
          
   
    public static void main(String[] args) throws Exception{
          
   
        List<User> userList = new ArrayList<>();
        userList.add(new User(1,"zhangsan"));
        userList.add(new User(2,"lisi"));
        userList.add(new User(3,"wnagwu "));
        userList.add(new User(4,"zhaliu"));
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("JAVAse进阶/src/IO流/序列化和反序列化/users"));
        //一次序列化一个集合,这个集合对象中放了很多其他对象。
        oos.writeObject(userList);

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

反序列化集合(ObjectInputStream )

public class 反序列化集合 {
          
   
    public static void main(String[] args) throws Exception {
          
   
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("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虚拟机会认为是同一个类。
public class Student implements Serializable {
          
   
    //Java虚拟机看到Serializable接口之后,会自动生成一个序列化版本号。
    //这里没有手动写出来,Java虚拟机会自动提供这个序列化版本号
    // 建议将序列化版本号手动的写出来。不建议自动生成
    private static final long serialVersionUID = 1L;//手动写出来

    // 如果是自动生成的序列化版本号,过了很久,Student这个类的源代码改动了,
    // 源代码改动之后,需要重新编译,编译之后生成了全新的字节码文件,
    // 并且class文件再次运行的时候,java虚拟机生成的序列化版本号也会发生相应的改变,
    //而上面自己手动写了一个固定的序列化版本号,以后这个类即使代码修改了,但是版本号不变,java虚拟机会认为是同一个类。

    private int no ;
    private String name;

    public Student() {
          
   
    }

    public Student(int no, String name) {
          
   
        this.no = no;
        this.name = name;
    }

    public int getNo() {
          
   
        return no;
    }

    public void setNo(int no) {
          
   
        this.no = no;
    }

    public String getName() {
          
   
        return name;
    }

    public void setName(String name) {
          
   
        this.name = name;
    }

    @Override
    public String toString() {
          
   
        return "Student{" +
                "no=" + no +
                ", name=" + name +  +
                };
    }
}

IDEA工具生成版本号快捷键

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

IO和Properties属性类的联合应用

IO+Properties的联合应用。 非常好的一个设计理念: 以后经常改变的数据,可以单独写到一个文件中,使用程序动态读取。将来只需要修改这个文件的内容,Java代码不需要改动,不需要重新编译,服务器也不需要重启。就可以拿到动态的信息。
类似于以上机制的这种文件被称为配置文件。并且当配置文件中的内容格式是: key1=value key2=value 的时候,我们把这种配置文件叫做属性配置文件。
java规范中有要求:属性配置文件建议以.properties结尾,但这不是必须的。这种以.properties结尾的文件在java中被称为:属性配置文件。其中Properties是专门存放属性配置文件内容的一个类。

示例

配置文件

代码

public class IO和Properties联合应用 {
          
   
    public static void main(String[] args) throws Exception{
          
   

        /*
            Properties是一个Map集合,Key和Value都是String类型
            想将aaaa文件中的数据加载到Properties对象当中。
         */
        //新建一个输入流对象
        FileReader fileReader = new FileReader("JAVAse进阶/src/IO流/联合应用/aaaa.properties");
        //新建一个Map集合
        Properties properties = new Properties();

        //调用Properties对象的load方法将文件中的数据加载到Map集合中
        properties.load(fileReader);//文件中的数据顺着管道加载到Map集合中,其中等号左边是Key,右边是Value

        //通过Key来获取Value
        String username = properties.getProperty("username");
        System.out.println(username);// 输出:admin

        String password = properties.getProperty("password");
        System.out.println(password);// 输出:123456


    }
}

标签:java,IO,详解
来源: