Java学习23：IO流

作者: 苦难_69e0 | 来源:发表于2020-11-19 08:17 被阅读0次

什么是IO？

I：Input
O：Output
通过IO可以完成硬盘文件的读和写。

什么是IO.png

IO流的分类

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

另一种方式是按照读取数据方式不同进行分类：
有的流是按照字节的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。
这种流是万能的，什么类型的文件都可以读取，包括：文本文件，图片，声音文件，视频文件等......

字节流.png

有的流是按照字符的方式读取数据的，一次读取一个字符，这种流是为了方便读取普通文本文件而存在的，这种流不能读取：图片，声音，视频等文件，智能读取春文本文件，连word文件都无法读取。

字符流.png

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

流应该怎么学

Java中的IO流都已经写好了，我们程序员不需要关心，我们最主要还是掌握，在java中已经提供了哪些流，每个流的特点是什么，每个流对象上的常用方法有哪些？

java中所有的流都是在：java.io.*;下。

java中主要还是研究：
怎么new流对象。
调用流对象的哪个方法是读，哪个方法是写。

流的四大家族

四大家族的首领：
java.io.InputStream 字节输入流
java.io.OutputStream 字节输出流
java.io.Reder 字符输入流
java.io.Writer 字符输出流

四大家族的首领都是抽象类。（abstract class）

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

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

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

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.DateOutputStream

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

对象专属流：
java.io.ObjectInputStream
java.io.ObjectOutputStream

java.io.FileInputStream流

文件字节输入流，万能的，任何类型的文件都可以采用这个流来读。

字节的方式，完成输入的操作，完成读的操作（硬盘--->内存）

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Text {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            //创建文件字节输入流对象
            //文件路径：C:\Users\HP\Desktop\temp（IDEA会自动把\变成\\，因为java中\表示转义）
            //temp中存储的是：abcdef
            //以下是采用了：绝对路径的方式
            //fis = new FileInputStream("C:\\Users\\HP\\Desktop\\temp");
            //写成这个 / 也是可以的
            fis = new FileInputStream("C:/Users/HP/Desktop/temp");

            //开始读
            int readData = fis.read();//这个方法的返回值是：被取到的“字节”本身。
            System.out.println(readData);//97

            readData = fis.read();
            System.out.println(readData);//98

            readData = fis.read();
            System.out.println(readData);//99

            readData = fis.read();
            System.out.println(readData);//100

            readData = fis.read();
            System.out.println(readData);//101

            readData = fis.read();
            System.out.println(readData);//102

            //已经读到文件的末尾了，再读的时候读取不到任何数据，返回-1
            readData = fis.read();
            System.out.println(readData);//-1

            readData = fis.read();
            System.out.println(readData);//-1

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //在finally语句块中确保流一定关闭
            if (fis != null) {//避免空指针异常
                //关闭流的前提是：流不是空。流是null的时候没必要关闭
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

对以上程序读的方式进行改变

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Text {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("C:\\Users\\HP\\Desktop\\temp");

            //开始读
            /*
                while (true){
                int readData = fis.read();
                if (readData == -1){
                    break;
                }
                System.out.println(readData);
            }
            */
            //进一步改进while循环
            int readData = 0;
            while ((readData = fis.read()) != -1){
                System.out.println(readData);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

在IDEA中默认的当前路径是Project的根。

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

int read(byte[] b)
一次最多读取b.length个字节。
减少硬盘和内存的交互，提高程序的执行效率。
往byte[]数组当中读。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Text {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("C:\\Users\\HP\\Desktop\\temp");

            //开始读,采用byte数组，一次读取多个字符。最多读取“数组.length”个字符
            byte[] bytes = new byte[4];//准备一个4个长度的byte数组，一次最多取4个字节。
            //这个方法的返回值是：读取到的字节数量。（不是字节本身）
            int readCount = fis.read(bytes);
            System.out.println(readCount);//第一次读到了4个字节
            //将字节数组全部转换成字符串
            //System.out.println(new String(bytes));//abcd
            //不应该全部转换，应该是读取了多少字节，转换多少个
            System.out.println(new String(bytes,0,readCount));//abcd

            readCount = fis.read(bytes);//第二次只能读取到2个字节
            System.out.println(readCount);//2
            //将字节数组全部转换成字符串
            //System.out.println(new String(bytes));//efcd
            //不应该全部转换，应该是读取了多少字节，转换多少个
            System.out.println(new String(bytes,0,readCount));//ef

            readCount = fis.read(bytes);//1个字节都没有读取到返回-1
            System.out.println(readCount);//-1

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

最终程序

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Text {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("C:\\Users\\HP\\Desktop\\temp");

            //开始读
            //准备一个byte数组
            byte[] bytes = new byte[4];
            /*
                while(true){
                int readCount = fis.read(bytes);
                if (readCount == -1) {
                    break;
                }
                //把byte数组转换成字符串，读到多少个转换多少个。
                System.out.print(new String(bytes,0,readCount));
            }
            */

            //改进while
            int readCount = 0;
            while((readCount= fis.read(bytes)) != -1){
                System.out.println(new String(bytes,0,readCount));
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileInputStream的其他常用方法

int available()：返回流当中剩余的没有读到的字节数量
long skip(long n)：跳过几个字节不读

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Text {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("C:\\Users\\HP\\Desktop\\temp");
            System.out.println("总字节数量：" + fis.available());
            //读一个字节
            //int readByte = fis.read();
            //还剩下可以读的字节数量是：5
            //System.out.println("剩下多少个字节没有读：" + fis.available());
            //这方法有什么用？
            byte[] bytes = new byte[fis.available()];//这种方式不太适合太大的文件，因为byte[]数组不能太大。
            //不需要循环了
            //直接读一次就行了
            int readCount = fis.read(bytes);//6
            System.out.println(new String(bytes));

            //skip跳过几个字节不读取，这个方法也可能以后会用。
            fis.skip(3);//跳过去3个
            System.out.println(fis.read());//100

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileOutputStream的使用

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Text {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            //myfile文件不存在的时候会自动新建
            //这种方式谨慎使用，这种方式会先将源文件清空，然后重新写入。
            //fos = new FileOutputStream("myfile");

            //以追加的方式在文件末尾写入。不会清空源文件内容。
            fos = new FileOutputStream("myfile",true);
            //开始写
            byte[] bytes = {97,98,99,100};
            //将byte数组全部写出！
            fos.write(bytes);//abcd
            //将byte数组的一部分写出！
            fos.write(bytes,0,2);//再写出ab 就是abcdab

            String s = "我是一个中国人，我骄傲！！！";
            //将字符串转换成byte数组
            byte[] bs = s.getBytes();
            //写
            fos.write(bs);

            //写完之后，最后要刷新。
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

文件复制

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

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyFile {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //创建一个输入流对象
            fis = new FileInputStream("C:\\Users\\HP\\Desktop\\temp");
            //创建一个输出流对象
            fos = new FileOutputStream("D:\\temp");

            //最核心的：一边读，一边写
            byte[] bytes = new byte[1024 * 1024];//1MB(一次最多拷贝1MB)
            int readCount = 0;
            while ((readCount = fis.read(bytes)) != -1){
                fos.write(bytes,0,readCount);
            }
            //刷新，输出流最后要刷新
            fos.flush();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //分开try，不要一起try
            //一起try的时候，其中一个出现异常，可能会影响到另一个流的关闭
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileReader的使用

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


import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Text {
    public static void main(String[] args) {
        FileReader reader = null;
        try {
            //创建文件字符输入流
            reader = new FileReader("C:\\Users\\HP\\Desktop\\temp");

            /*
            //准备一个char数组
            char[] chars = new char[4];
            //往char数组中读
            reader.read(chars);//按照字符的方式读取
            for (char c: chars) {
                System.out.println(c);
            }
            */

            //开始读
            char[] chars = new char[4];//一次读取4个字符
            int readCount = 0;
            while ((readCount = reader.read()) != -1){
                System.out.println(new String(chars,0,readCount));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileWriter的使用

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

import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;

public class Text {
    public static void main(String[] args) {
        FileWriter out = null;
        try {
            //创建文件字符输出流
            //out = new FileWriter("file");
            out = new FileWriter("file",true);

            //开始写
            char[] chars = {'我','是','中','国','人'};
            out.write(chars);
            out.write(chars,2,3);

            out.write("我是一名java软件工程师！");
            //写出一个换行符
            out.write("\n");
            out.write("hello world!");

            //刷新
            out.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

复制普通文本文件

能使用记事本打开编辑的都是普通文本文件。

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyFile1 {
    public static void main(String[] args) {
        FileReader in = null;
        FileWriter out = null;
        try {
            //读
            in = new FileReader("");
            //写
            out = new FileWriter("");

            //一边读，一边写
            char[] chars = new char[1024 * 512];//1MB
            int readCount = 0;
            while((readCount = in.read()) != -1){
                out.write(chars,0,readCount);
            }

            //刷新
            out.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

BufferedReader

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

在这里没有进行try/catch是为了省事，正常编写的时候，还是该干嘛干嘛。

import java.io.BufferedReader;
import java.io.FileReader;

public class Text {
    public static void main(String[] args) throws Exception{
        FileReader reader = new FileReader("");
        //当一个流的构造方法中需要一个流的时候，这个被传进来的流叫做：节点流。
        //外部负责包装的这个流，叫做：包装流，还有一个名字叫做：处理流。
        //像当前这个程序来说：FileReader就是一个节点流。BufferedReader就是包装流/处理流。
        BufferedReader br = new BufferedReader(reader);

        /*
        //读一行
        String firstLine = br.readLine();
        System.out.println(firstLine);
         */

        //br.readLine()方法读取一个文本行，但不带换行符
        String s = null;
        while((s = br.readLine()) != null){
            System.out.println(s);
        }
        //关闭流
        //对于包装流来说，只需要关闭最外层流就行，里面的节点流会自动关闭。
        br.close();
    }
}

转换流：InputStreamReader

import java.io.*;

public class Text {
    public static void main(String[] args) throws Exception{
        /*
        //字节流
        FileInputStream in = new FileInputStream("");

        //通过转换流转换（InputStreamReader将字节流转换成字符流）
        //in是节点流。reader是包装流。
        InputStreamReader reader = new InputStreamReader(in);

        //这个构造方法只能传一个字符流。不能传字节流
        //reader是节点流。br是包装流。
        BufferedReader br = new BufferedReader(reader);
        */

        //合并
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("")));

        String line = null;
        while((line = br.readLine()) != null){
            System.out.println(line);
        }

        //关闭最外层
        br.close();
    }
}

BufferedWriter、OutputStreamWriter：转换流

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

import java.io.*;

public class Text {
    public static void main(String[] args) throws Exception{
        //带有缓冲的字符输出流
        //BufferedWriter out = new BufferedWriter(new FileWriter("copy"));
        //转换流
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("",true)));
        //开始写
        out.write("hello world!");
        out.write("\n");
        out.write("hello kitty!");
        //刷新
        out.flush();
        //关闭最外层
        out.close();
    }
}

数据流

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

import java.io.*;

public class Text {
    public static void main(String[] args) throws Exception{
        //创建数据专属的字节输出流
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data"));
        //写数据
        byte b = 100;
        short s = 200;
        int i = 300;
        long l = 400L;
        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();
        //关闭最外层
        dos.close();
    }
}

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

import java.io.*;

public class Text {
    public static void main(String[] args) throws Exception{
        DataInputStream dis = new DataInputStream(new FileInputStream("data"));
        //开始读
        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();

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

        //关闭最外层
        dis.close();
    }
}

标准输出流

java.io.PrintStream：标准的字节输出流。默认输出到控制台。

import java.io.*;

public class Text {
    public static void main(String[] args) throws Exception{
        //联合起来写
        System.out.println("hello world!");

        //分开写
        PrintStream ps = System.out;
        ps.println("hello zhangsan");
        ps.println("hello li");
        ps.println("hello wangwu");

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

        /*
        //这些是之前System类使用过的方法和属性。
        System.gc();
        System.currentTimeMillis();
        PrintStream ps2 = System.out;
        System.exit();
        System.arraycopy();
        */
        //标准输出流不再指向控制台，指向“log”文件
        PrintStream printStream = new PrintStream(new FileOutputStream("log"));
        //修改输出方向，将输出方向修改到“log”文件
        System.setOut(printStream);
        //再输出
        System.out.println("hello world");
        System.out.println("hello kitty");
        System.out.println("hello zhangsan");
    }
}

记录日志的方法

import java.io.*;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Text {
    public static void log(String[] msg){
        //指向一个日志文件
        PrintStream out = null;
        try {
            out = new PrintStream(new FileOutputStream("log.txt",true));
            //改变输出方向
            System.setOut(out);
            //日期当前时间
            Date nowTime = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss SSS");
            String sttrTime = sdf.format(nowTime);

            System.out.println(sttrTime + ":" + msg);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
    
}

//测试工具类是否好用
public class LogText{
    public static void main(String[] args){
            Text.log("调用了System类的gc()方法，建议启动垃圾回收");
            Text.log("用户尝试进行登录，验证失败");
    }
}

File类

File类和四大家族没有关系，所以File类不能完成文件的读和写。
File对象代表：文件和目录路径名的抽象表示形式。
一个File对象有可能对应的是目录，也可能是文件。
File只是一个路径名的抽象表示形式。
File类的常用方法要掌握。


import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Text {
    public static void main(String[] args) throws Exception{
        //创建一个File对象
        File f1 = new File("D:\\file");

        //判断是否存在
        System.out.println(f1.exists());

        //如果D:\file不存在，则以文件的形式创建出来
        if(!f1.exists()){
            //以文件形式新建
            f1.createNewFile();
        }

        //如果D:\file不存在，则以目录的形式创建出来
        if(!f1.exists()){
            //以目录形式新建
            f1.mkdir();
        }

        //可以创建多重目录么？
        File f2 = new File("D:/a/b/c/d/e/f");
        if(!f2.exists()){
            //以多重目录形式新建
            f1.mkdirs();
        }

        File f3 = new File("C:\\Users\\HP\\Desktop\\temp.txt");
        //获取文件的父路径
        String parentPath = f3.getParent();
        System.out.println(parentPath);//C:\Users\HP\Desktop

        File parentFile = f3.getParentFile();
        System.out.println("获取绝对路径：" + parentFile.getAbsolutePath());

        //获取文件名字
        System.out.println("文件名：" + f3.getName());

        //判断是否是一个目录
        System.out.println(f3.isDirectory());//false

        //判断是否是一个文件
        System.out.println(f3.isFile());//true

        //获取文件最后一次修改时间
        long haoMiao = f3.lastModified();//这个毫秒是从1970年到现在的总毫秒数。
        //将总毫秒数转换成日期
        Date time = new Date(haoMiao);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        String strTime = sdf.format(time);
        System.out.println(strTime);

        //获取文件大小
        System.out.println(f3.length());//多少字节

        //获取当前目录下所有的子文件。
        File f = new File("D:\\IntelliJ IDEA Community Edition 2020.2");
        File[] files = f.listFiles();
        //foreach
        for (File file : files) {
            System.out.println(file.getAbsolutePath());
            System.out.println(file.getName());
        }

    }
}

目录拷贝

import java.io.*;

public class CopyAll {
    public static void main(String[] args) {
        //拷贝源
        File srcFile = new File("D:\\course\\02-javase\\document");
        //拷贝目标
        File destFile = new File("C:\\");
        //调用方法拷贝
        copyDir(srcFile,destFile);
    }

    /*
    * 拷贝目录
    * srcFile 拷贝源
    * destFile 拷贝目录
    * */
    private static void copyDir(File srcFile, File destFile) {
        if (srcFile.isFile()){
            //srcFile如果是一个文件的话，，递归结束.
            //是文件的时候需要拷贝。
            //一边读一边写
            FileInputStream in = null;
            FileOutputStream out = null;
            try {
                //读这个文件
                in = new FileInputStream(srcFile);
                //写到这个文件中
                String path = (destFile.getAbsolutePath().endsWith("\\") ? destFile.getAbsolutePath() : destFile.getAbsolutePath() + "\\" )+ srcFile.getAbsolutePath().substring(3);
                out = new FileOutputStream(path);
                //一边读一边写
                byte[] bytes = new byte[1024 * 1024];//一次复制1MB
                int readCount = 0;
                while((readCount = in.read(bytes)) != -1){
                    out.write(bytes,0,readCount);
                }
                //刷新
                out.flush();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (out != null) {
                    try {
                        out.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }

                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return;
        }
        //获取源下面的子目录
        File[] files = srcFile.listFiles();
        for (File file: files) {
            //获取所有文件的（包括目录和文件）绝对路径
            //System.out.println(file.getAbsolutePath());
            if (file.isDirectory()){
                //新建对应的目录
                //System.out.println(file.getAbsolutePath());
                String srcDir = file.getAbsolutePath();
                System.out.println(srcDir.substring(3));
                String destDir = (destFile.getAbsolutePath().endsWith("\\") ? destFile.getAbsolutePath() : destFile.getAbsolutePath() + "\\" )+ srcDir.substring(3);
                File newFile = new File(destDir);
                if (!newFile.exists()){
                    newFile.mkdirs();
                }
            }
            //递归调用
            copyDir(file,destFile);
        }
    }
}

对象的序列化和反序列化

对象的序列化和反序列化.png

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

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

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

不同的人编写了同一个类，例如：A编写了一个类叫Student，B编写的一个类也叫Student。但是这两个类确实不是同一个类。这个时候序列化版本号就起上作用了。
对Java虚拟机来说，java虚拟机时可以区分开这两个类的，因为这两个类都实现了Serializable接口，都有默认的序列化版本号，他们的序列化版本号不一样。所以区分开来了。（这是自动生成序列化版本号的好处）

那这种自动生成序列化版本号有什么缺陷？
这种自动生成的序列化版本号缺点是：一旦代码确定之后，不能进行后续的修改，因为只要修改，必然会重新编译，此时会生成全新的序列化版本号，这个时候java虚拟机会认为这是一个全新的类。（这样就不好了！）

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

//建议手动写出来序列化版本号，不建议自动生成
//版本号自己定义，最好是全球唯一的
private static final long serialVersionUID = 15451285684684L；

IDEA工具可以自动生成序列化版本号
File---settings---Inspections---Serializable class without 'serialVersionUID'选中---apply
使用的时候，光标放到类名上，alt + 回车添加就好了

import java.io.Serializable;

public class Student implements Serializable {
    //java虚拟机看到Serializable接口之后，会自动生成一个序列化版本号。
    //这里没有手动写出来，java虚拟机会默认提供这个序列化版本号。
    //建议手动写出来序列化版本号，不建议自动生成
    //版本号自己定义，最好是全球唯一的
    private static final long serialVersionUID = 15451285684684L；
    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 + '\'' +
                '}';
    }
}

序列化

mport java.io.FileOutputStream;
import java.io.ObjectOutputStream;


public class Text {
    public static void main(String[] args) throws Exception{
        //创建java对象
        Student s = new Student(111,"zhangsan");
        //序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("students"));

        //序列化对象
        oos.writeObject(s);

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

反序列化

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class Text {
    public static void main(String[] args) throws Exception{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(""));
        //开始反序列化，读
        Object obj = ois.readObject();
        //反序列化回来是一个学生对象，所以会调用学生对象的toString方法。
        System.out.println(obj);
        ois.close();
    }
}

可以一次序列化多个对象么？
可以，可以将对象放到集合当中，序列化集合。
提示：参与序列化的ArrayList集合以及集合中的元素都需要实现java.io.Serializable接口。
序列化集合

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

public class Text {
    public static void main(String[] args) throws Exception{
        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student(1,"zhangsan"));
        studentList.add(new Student(2,"lisi"));
        studentList.add(new Student(1,"wangwu"));
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("students"));

        //序列化一个集合，这个集合对象中放了很多其它对象
        oos.writeObject(studentList);

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

反序列化集合

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.List;

public class Text {
    public static void main(String[] args) throws Exception{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("students"));
        //Object obj = ois.readObject();
        //System.out.println(obj instanceof List);
        List<Student> studentList = (List<Student>)ois.readObject();
        for (Student student: studentList) {
            System.out.println(student);
        }
        ois.close();
    }
}

那如果我不希望Student中的某一个属性，参与序列化呢？
可以使用transient关键字修饰。
例如：private transient String name;
transient关键字表示游离的，不参与序列化。

IO + Properties的联合应用

Properties是一个Map集合，key和value都是String类型。
想将某一个文件（例如：userinfo）中的数据加载到Properties对象当中。
userinfo文件中存储的是:username=admin password=123

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

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

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

在属性配置文件中井号是注释
属性配置文件的key重复的话，value会自动覆盖！
注意：key=value中间最好不要有空格，除了用等号隔开也可以用冒号隔开，但是不建议使用冒号隔开。

import java.io.FileReader;
import java.util.Properties;

public class Text {
    public static void main(String[] args) throws Exception{
        //新建一个输入流对象
        FileReader reader = new FileReader("userinfo");

        //新建一个Map集合
        Properties pro = new Properties();

        //调用Properties对象的Load方法将文件中的数据加载到Map集合中。
        pro.load(reader);//文件中的数据顺着管道加载到Map集合中，其中等号=左边做key，右边做value

        //通过key来获取value
        String username = pro.getProperty("username");
        System.out.println(username);

        String password = pro.getProperty("password");
        System.out.println(password);
        
    }
}