Java笔记（二十四）：IO流、文件、Input/OutputStream、Reader、Writer、节点流处理流、序列化反序列化、标准输入输出流、转换流、打印流、Properties类

IO流 – 章节体系图

一、文件

1、什么是文件

文件是保存数据的地方。

2、什么是文件流

2、创建文件对象相关构造器和方法

1）相关方法

① new File(String pathname) //根据路径构建一个File对象；

② new File(File parent,String child) //根据父目录文件+子路径构建一个File对象；

③ new File(String parent,String child) //根据父目录+子路径构建一个File对象；

④ 使用文件对象名.createNewFile()创建新文件。

2）应用实例

public class FileCreate {
    public static void main(String[] args) {
    }

    //方式1
    @Test
    public void create01() {
        String filePath = "d:\\news1.txt";
        File file = new File(filePath);

        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //方式2
    //路径：d:\\news2.txt
    public void create02() {
        File parentFile = new File("d:\\");
        String fileName = "news2.txt";
        File file = new File(parentFile, fileName); //这里只是在内存里创建了file对象，对硬盘没有影响

        try {
            file.createNewFile(); //这一句才是真的才硬盘里创建了文件file（从内存中存过去）
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //方式3
    //路径: d:\\news3.txt
    public void create03() {
        String parentPath = "d:\\";
        String fileName = "news3.txt";
        File file = new File(parentPath,fileName);

        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3、常用的文件操作

1）获取文件的相关信息（getName、length、exists…）

1. getName 得到文件名字
2. getAbsolutePath 得到绝对路径
3. getParent 得到文件父级目录
4. length 文件大小(字节)
5. exists 文件或者目录是否存在
6. isFile 是不是一个文件
7. isDirectory 是不是一个目录

public class FileInformation {
    public static void main(String[] args) {

    }

    public void info() {
        //先创建文件对象
        File file = new File("d:\\news1.txt");
        File file2 = new File("d:\\");

        //调用相应的方法，得到对应信息
        System.out.println("文件名字=" + file.getName());
        //getName、getAbsolutePath、getParent、length、exists、isFile、isDirectory
        System.out.println("文件绝对路径=" + file.getAbsolutePath());
        System.out.println("文件父级目录=" + file.getParent());
        System.out.println("文件大小(字节)=" + file.length());
        //按字节计算，utf-8编码下，一个英文字母一个字节，一个汉字三个字节
        System.out.println("文件是否存在=" + file.exists());//T
        System.out.println("是不是一个文件=" + file.isFile());//T
        System.out.println("file是不是一个目录=" + file.isDirectory());//F
        System.out.println("file2是不是一个目录=" + file2.isDirectory());//T
    }
}

2）目录的操作和文件删除（mkdir、mkdirs、delelte）

1. mkdir 创建一级目录
2. mkdirs 创建多级目录
3. delete 删除空目录或一个文件【注意如果目录下有文件或者目录，则不能删除，只能将其内清空才能删除】

D:\\demo02 是一级目录
D:\\demo\\a\\b\\c 是多级目录

public class Directory_ {
    public static void main(String[] args) {
 
        
    }
 
    //判断 d:\\news1.txt 是否存在，如果存在就删除
    @Test
    public void m1() {
 
        String filePath = "e:\\news1.txt";
        File file = new File(filePath);
        if (file.exists()) {
            if (file.delete()) {
                System.out.println(filePath + "删除成功");
            } else {
                System.out.println(filePath + "删除失败");
            }
        } else {
            System.out.println("该文件不存在...");
        }
 
    }
 
    //判断 D:\\demo02 是否存在，存在就删除，否则提示不存在
    //这里我们需要体会到，在java编程中，目录也被当做文件
    @Test
    public void m2() {
 
        String filePath = "D:\\demo02";
        File file = new File(filePath);
        if (file.exists()) {
            if (file.delete()) {
                System.out.println(filePath + "删除成功");
            } else {
                System.out.println(filePath + "删除失败");
            }
        } else {
            System.out.println("该目录不存在...");
        }
 
    }
 
    //判断 D:\\demo\\a\\b\\c 目录是否存在，如果存在就提示已经存在，否则就创建
    @Test
    public void m3() {
 
        String directoryPath = "D:\\demo\\a\\b\\c"; //多级目录
        File file = new File(directoryPath);
        if (file.exists()) {
            System.out.println(directoryPath + "存在..");
        } else {
            if (file.mkdirs()) { //创建一级目录使用mkdir() ，创建多级目录使用mkdirs()
                System.out.println(directoryPath + "创建成功..");
            } else {
                System.out.println(directoryPath + "创建失败...");
            }
        }
    }
    //判断 D:\\demo 目录是否存在，如果存在就提示已经存在，否则就创建
    @Test
    public void m4() {
 
        String directoryPath = "D:\\demo"; //一级目录
        File file = new File(directoryPath);
        if (file.exists()) {
            System.out.println(directoryPath + "存在..");
        } else {
            if (file.mkdir()) { //创建一级目录使用mkdir() ，创建多级目录使用mkdirs()
                System.out.println(directoryPath + "创建成功..");
            } else {
                System.out.println(directoryPath + "创建失败...");
            }
        }
    }
}

二、IO流原理

1、Java IO流原理

（1）I/O是Input/Output的缩写，I/O技术是非常实用的技术，用于处理数据传输。如读/写文件，网络通讯等；

（2）Java程序中，对于数据的输入/输出操作以“流（stream）”的方式进行；

（3）java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过方法输入或输出数据；

（4）输入input：读取外部数据（磁盘，光盘等存储设备的数据）到程序（内存）中；

（5）输出output：将程序（内存）数据输出到磁盘，光盘等存储设备中。

2、流的分类—字节流/字符流、输入流/输出流、节点流/处理流

（1）按照操作数据单位不同分为：字节流（8bit）【便于处理二进制文件，保证文件不会损失】，字符流（按字符）【便于处理文本文件】；

（2）按数据流的流入不同分为：输入流，输出流；

（3）按流的角色的不同分为：节点流，处理流/包装流。

①  Java的IO流共涉及40多个类，实际上非常规则，都是从如上4个抽象基类派生的；

②  由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。

3、IO流体系图

1）IO流体系图

2）文件VS流

文件相当于仓库里的数据

流相当于过程 / 行动中的数据

三、IO流基本常用类

1、InputStream（字节输入流）

1）FileInputStream

1. int read() //一次读取一个字节，返回数据的ascii码值，想要得到原数据，需要转为char
2. int read(byte[] b) //一次读取多个字节，读取一定字节数的数据，存放到b数组中，并返回实际读取的字节数

if((readLen = fileInputStream.read(b)) != -1){
    //new String(byte bytes[], int offset, int length)底层调用了decode解码方法
    //功能：将[offset,length)下标的字节从bytes[]中取出，并解码转换为字符串
    //当我们使用 new String(byte bytes[], int offset, int length) 将字节流转换为字符串时
    //Java 会根据 UTF-8 的规则将每 3 个字节解码为一个中文字符，从而正确地解码出中文。
    //另一种层面来说，字符流 = 字节流 + 编码表
    System.out.println(new String(b,0,readLen));
}

public class FileInputStream_ {
    public static void main(String[] args) {

    }


    /**
     * read() :一次只读一个字节
     */
    @Test
    public void readFile01() {
        System.out.println("===========read()============");
        String filePath = "d:\\hello.txt"; //如果hello.txt中有中文，会出现乱码
        //因为每次只取一个字节，而一个汉字不止一个字节，（汉字取一半没取全，字节就不是原来的汉字了，所以会乱码）
        //所以文本文件最好用字符流
        int readData = 0;

        FileInputStream fileInputStream = null;
        try {
            //创建FileInputStream对象，用于读取文件
            fileInputStream = new FileInputStream(filePath);
            //从该输入流读取一个字节的数据。 如果没有输入可用，此方法将阻止 --> 报错，需要catch异常。
            //如果返回-1 , 表示读取完毕

            //数据肯定不止一个字节，所以循环遍历，获取数据
            while((readData = fileInputStream.read()) != -1) {
                System.out.print((char)readData);
            }

        } catch (IOException e) { //返回一个大异常：IOException
            e.printStackTrace();
        } finally {
            //关闭文件流，释放资源（不然会有很多“在路上”的流对象指向同一个文件）
            //下面会报错是因为作用域，不能将fileInputStream定义在try中，作用域只在try代码块中
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * read(byte[] b) ：一次读取b.length个字节，读取成功则返回实际读取的字节数
     */
    @Test
    public void readFile02() {
        System.out.println("=========read(byte[] b)==========");
        //1. 文件路径
        String filePath = "d:\\hello.txt";
        //2. 创建流对象
        FileInputStream fileInputStream = null;
        //3. 接收read返回值（实际读取的字节数）
        int readLen;

        try {
            fileInputStream = new FileInputStream(filePath);
            byte[] b = new byte[8]; //一次可以读取8个字节

			//超过8个字节，一次读不完
			//第一次读出hello,wo，第二次读出rld，然后拼在一起
            while((readLen = fileInputStream.read(b)) != -1) { 
                System.out.print(new String(b,0,readLen));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭文件流
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2、OutputStream（字节输出流）

1）FileOutputStream

① 注意构造器：是否为true，决定了写入文件是以追加在末尾的方式还是覆盖原先的数据
② write三种写法

public class OutputStream_ {
    public static void main(String[] args) {

    }

    /**
     * 使用FileOutputStream 将数据写到文件中
     * 如果文件不存在，则创建该文件
     */
    @Test
    public void writeFile() {
        String filePath = "d:\\a.txt"; //假设a.txt和b.txt原本都有"haha"数据
        String filePath2 = "d:\\b.txt";
        FileOutputStream fileOutputStream = null;
        FileOutputStream fileOutputStream2 = null;

        try {
            //构造器1：以覆盖原来的数据方式写入（即，假如a.txt里面有数据，那么就会覆盖a.txt里面的数据）
            fileOutputStream = new FileOutputStream(filePath);
            //构造器2：在原来的数据末尾后追加写入
            fileOutputStream2 = new FileOutputStream(filePath2,true);
            
            //write(int)
            //char与int有自动转换
            fileOutputStream.write('a');  //a.txt ---> a
            fileOutputStream2.write('a'); //b.txt ---> hahaa
            
            //write(byte[] b)
            String str = "123";
            //str.getBytes()-->可以把字符串变成字符数组
            fileOutputStream.write(str.getBytes());  //a.txt ---> a123
            fileOutputStream2.write(str.getBytes()); //b.txt ---> hahaa123
            
            //write(byte[] b,int offset,int len)
            String s = "amazing";
            fileOutputStream.write(s.getBytes(),0,2); //a.txt ---> a123ama
            fileOutputStream2.write(s.getBytes(),0,2); //b.txt ---> hahaa123ama
            
            
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
                fileOutputStream2.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

3、文件拷贝

思路：从一个文件中读取，再写入到另一个文件
先FileInputStream，再FileOutputStream

public class CopyFile {
    public static void main(String[] args) {
        String filePath1 = "d:\\t.txt";
        String filePath2 = "d:\\tt.txt";
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;

        try {
            //输入流
            fileInputStream = new FileInputStream(filePath1);
            //输出流
            fileOutputStream = new FileOutputStream(filePath2);
            //使用字节数组读取
            byte[] buf = new byte[1024];
            //接收返回的字节数
            int readLen = 0;

            while((readLen = fileInputStream.read(buf)) != -1){
                //输出，复制到t2.txt
                fileOutputStream.write(buf,0,readLen);
            }
            System.out.println("拷贝ok~");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(fileInputStream != null) { //避免空指针异常
                    fileInputStream.close();
                }
                if(fileOutputStream != null) {
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

4、FileReader 和 FileWriter（字符输入输出流）

public class FileReader_ {
    public static void main(String[] args) {

    }

    /**
     * read(): 一次读取单个字符
     */
    @Test
    public void fileRead0() {
        String filePath = "d:\\t.txt";
        FileReader fileReader = null;
        try {
            fileReader = new FileReader(filePath);
            //循环读取
            int readData = 0;
            while((readData = fileReader.read()) != -1) {
                System.out.print((char)readData);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * read(char[] ch) ：一次读取ch.length个字符，并存入ch中
     */
    @Test
    public void fileRead1() {
        String filePath = "d:\\t.txt";
        FileReader fileReader = null;

        try {
            fileReader = new FileReader(filePath);
            //设置数组
            char[] cbuf = new char[3];
            //返回的字节数
            int readLen = 0;
            //循环读取
            while((readLen = fileReader.read(cbuf)) != -1) {
                System.out.print(new String(cbuf,0,readLen));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

public class FileWriter_ {
    public static void main(String[] args) {
        String filePath = "d:\\t3.txt";
        FileWriter fileWriter = null;

        try {
            fileWriter = new FileWriter(filePath);

            //写入单个字符
            fileWriter.write('风'); //风
            //写入一个字符串
            fileWriter.write("风雨无阻"); //风风雨无阻

            //写入一个字符数组
            char[] cbuf = {'a','b','c'}; //风风雨无阻abc
            fileWriter.write(cbuf);

            //写入部分字符数组，范围[0,1)
            char[] cbuf2 = {'7','8','9'};
            fileWriter.write(cbuf2,0,1); //风风雨无阻abc7

            System.out.println("写入成功");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //使用FileWriter写入必须关闭或者刷新，因为底层真正实现写入操作的方法是由flush或close进去的
                //FileWriter底层调用的也是FileOutputStream
                //FileWriter.flush();
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

四、节点流和处理流

1、基本介绍

1）节点流

节点流可以从一个特定的数据源【数据源就是存放数据的地方】读写数据，常见节点流如FileReader、FileWriter；

节点流是比较底层的流（直接对数据进行操作）

2）处理流

（也叫包装流），是“连接”在已存在的流（节点流或处理流）之上，为程序提供更为强大的读写功能，也更加灵活，如BufferedReader、BufferedWriter。

处理流例如BufferedReader类中，有属性Reader，即可以封装一个节点流，该节点流可以是任意的，只要是Reader子类。

Reader子类：

BufferedWriter类中，有属性Writer，即可以封装任何一个Writer子类的节点流
Writer子类：

2、节点流和处理流一览图

3、节点流和处理流的区别和联系

【修饰器模式】指在不改变现有对象结构的情况下，动态地给该对象增加一些额外功能的模式。
修饰器模式的主要优点：

1. 修饰器是继承的有力补充，比继承灵活，动态地给一个对象扩展功能，即插即用
2. 将修饰类及没有使用修饰类的类的排列组合，可以实现不同效果
3. 修饰器模式完全遵循开闭原则
   缺点：
4. 修饰器模式会增加许多子类，过度使用会增加程序的复杂性

【模拟修饰器设计模式】

public class Test_ {
    public static void main(String[] args) {
        //想对文件进行多次操作，传入一个FileReader节点流
        BufferedReader_ bufferedReader_ = new BufferedReader_(new FileReader_());
        bufferedReader_.readFiles(10);

        //想对数组进行多次操作，传入一个StringReader节点流
        BufferedReader_ bufferedReader_1 = new BufferedReader_(new StringReader_());
        bufferedReader_1.readString(10);
    }
}

class BufferedReader_ {
    private Reader_ reader_; //属性是 Reader_类型

    public BufferedReader_(Reader_ reader_) {
        this.reader_ = reader_;
    }

    //让方法更加灵活，多次读取文件，或者加缓冲byte[]...
    public void readFiles(int num) {
        for (int i = 0; i < num; i++) {
            reader_.readFile();
        }
    }

    //扩展功能--readString，批量处理字符串
    public void readString(int num) {
        for (int i = 0; i < num; i++) {
            reader_.readString();
        }
    }
}

abstract class Reader_ { //抽象类
    public void readFile(){}
    public void readString(){}
	
	//在Reader_抽象类，使用read方法统一管理
	//调用的时候用动态绑定机制，与传入的参数绑定
	public abstract void read(){}
}

class FileReader_ extends Reader_ {

    public void readFile() {
        System.out.println("对文件进行读取...");
    }
}

class StringReader_ extends Reader_{
    public void readString() {
        System.out.println("读取字符串...");
    }
}

4、处理流-BufferedReader 和 BufferedWriter（字符）

BufferedReader和BufferedWriter属于字符流，是按照字符来读取数据的，关闭时，只需要关闭外层流即可。【因为底层会调用的处理流传入的字节流的close方法】

1）BufferedReader读取文本文件

public class BufferedReader_ {
    public static void main(String[] args) throws IOException {  //直接在这里抛出异常
        String filePath = "d:\\CopyFile.java";
        BufferedReader bufferReader = new BufferedReader(new FileReader(filePath));

        String line = "";
        //按行读取
        //1. bufferedReader.readLine() 是按行读取文件
        //2. 当返回null 时，表示文件读取完毕
        while((line = bufferReader.readLine()) != null) {
            System.out.println(line);
        }

        //关闭外层流即可，传入的new FileWriter(filePath)会在底层关闭
        bufferReader.close();
    }
}

2）BufferedWriter写入文本文件

public class BufferedWriter_ {
    public static void main(String[] args) throws IOException {
        String filePath = "d:\\ww.txt";

        //覆盖
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));
        //追加：在内部节点流传参true
        //BufferedWriter bufferedWriter1 = new BufferedWriter(new FileWriter(filePath,true));
        bufferedWriter.write("今天星期几");
        bufferedWriter.newLine(); //系统换行
        bufferedWriter.write("中午吃什么");

        bufferedWriter.close();
    }
}

3）拷贝：BufferedWriter和BufferedReader合用

public class BufferedCopy_ {
    public static void main(String[] args) {
        //BufferedReader 和 BufferedWriter 是安装字符操作
        //不要去操作 二进制文件[图片，声音，视频，doc, pdf ], 可能造成文件损坏
        String srcFilePath = "d:\\test.java";
        String destFilePath = "d:\\test2.java";
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;

        try {
            bufferedReader = new BufferedReader(new FileReader(srcFilePath));
            bufferedWriter = new BufferedWriter(new FileWriter(destFilePath));

            //读取
            String line = "";
            while((line = bufferedReader.readLine()) != null) {
                //边读边写
                //说明：write写入一行内容，但是没有换行
                bufferedWriter.write(line);
                //插入一个换行
                bufferedWriter.newLine();
            }
            System.out.println("复制完毕");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(bufferedReader != null) {
                    bufferedReader.close();
                }
                if(bufferedWriter != null) {
                    bufferedWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

5、处理流-BufferedInputStream 和 BufferedOutputStream（字节）

1）介绍 BufferedInputStream

BufferedInputStream是字节流，在创建BufferedInputStream时，会创建内部缓冲区数组。

2）介绍 BufferedOutputStream

3）BufferedInputStream和BufferedOutputStream应用实例

/**
 * 拷贝二进制文件
 * 演示使用BufferedOutputStream 和 BufferedInputStream使用
 */
public class BufferedCopy02 {
    public static void main(String[] args) {
        String srcFilePath = "d:\\test.jpg";
        String destFilePath = "d:\\test2.jpg";

        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;

        try {
            bufferedInputStream = new BufferedInputStream(new FileInputStream(srcFilePath));
            bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(destFilePath));

            //设置读取数组
            byte[] buff = new byte[1024]; //一次读取1024个字节
            int readLen = 0;
            //循环读取
            while((readLen = bufferedInputStream.read(buff)) != -1) {
                //写入
                bufferedOutputStream.write(buff,0,readLen);
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭外层流
            try {
                if(bufferedInputStream != null) {
                    bufferedInputStream.close();
                }
                if(bufferedOutputStream != null) {
                    bufferedOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

思考：字节流也可以操作文本文件（因为字节是文件数据的基本单位），但是效率低（一个字节一个字节慢慢读）
但用字符流不能操纵二进制文件，可能导致数据丢失（不能用大单位去操控小单位）

6、对象流-ObjectInputStream和ObjectOutputStream

1）功能

① 提供了对基本类型或对象类型的序列化和反序列化的方法；

② ObjectOutputStream 提供 序列化功能；

③ ObjectInputStream 提供 反序列化功能。

即希望保存文件数据的时候，同时保存文件数据的数据类型

2）序列化和反序列化

优先使用Serializable接口
创建对象的类必须实现接口

3）基本介绍

序列化ObjectOutputStream //写入

public class ObjectOutputStream_ {
    public static void main(String[] args) throws IOException {
        String filePath = "d:\\data.dat";

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));

        //序列化数据到d:\test.java
        //自动装箱
        oos.writeInt(100); // int -> Integer ,该包装类实现了Serializable
        oos.writeBoolean(true); // boolean -> Boolean，该包装类实现了Serializable
        oos.writeChar('c'); //char -> Char
        oos.writeDouble(1.1); //double -> Double
        oos.writeUTF("今天吃什么"); //String
        oos.writeObject(new Dog("小白",2));

        System.out.println("序列化完成");
        oos.close();
    }
}

class Dog implements Serializable {
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }
}

反序列化ObjectInputStream //读取

/**
 * 反序列化
 */
public class ObjectInputStream_ {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        String filePath = "d:\\data.dat";
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));


        //1. 读取(反序列化)的顺序需要和你保存数据(序列化)的顺序一致
        //2. 否则会出现异常
        System.out.println(ois.readInt());
        System.out.println(ois.readBoolean());
        System.out.println(ois.readChar());
        System.out.println(ois.readDouble());
        System.out.println(ois.readUTF());

        //读取对象，注意细节：
        //如果对象对应的类发生变化，需要重新序列化再反序列化，才能获取变化后的数据
        Object dog = ois.readObject(); //这里会ClassNotFoundException抛出异常，readObject底层 会把Object转型成Dog
        System.out.println("运行类型=" + dog.getClass());
        System.out.println("dog信息（默认为全部属性，调用toString方法）=" + dog);

        //默认序列化对象的所有属性，如果想要调用对象方法，需要向下转型 ---> 将对象对应的类放到本类或者本包下
        //或者直接导入原本类所在的包（但要求原本类为public修饰） ---> import io_.outputstream_.Dog;
//        Dog dog2 = (Dog)dog;
//        dog2.getName();

        //关闭流
        ois.close();
    }
}

4）注意事项和使用细节

//2) 如果需要序列化某个类的对象，实现 Serializable
public class Dog implements Serializable {
    private String name;
    private int age;  //6) Integer其实没有直接implements Serializable，而是它的父类Number实现了，但Integer作为它的子类，继承了序列化
    
    //4) 序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
    private static String nation;
    private transient String color;
    
    //5) 序列化对象时，要求里面属性的类型也需要实现序列化接口
    //即，属性中有其他自定义类时，这个自定义类需要实现序列化接口（implements Serializable)
    private Master master = new Master();
 
    //3) serialVersionUID 序列化的版本号，可以提高兼容性（类修改时不会导致对象地址修改）
    private static final long serialVersionUID = 1L;
 
    public Dog(String name, int age, String nation, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
        this.nation = nation;
    }
 
    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}' + nation + " " +master;
    }
 
    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;
    }
}

五、标准输入流与输出流

1、标准输入输出流

public class InputAndOutput {
    public static void main(String[] args) {
        //System 类的in ==> public final static InputStream in = null;
        // System.in 编译类型   InputStream
        // System.in 运行类型   BufferedInputStream
        // 表示的是标准输入 键盘
        System.out.println(System.in.getClass()); //运行类型 BufferedInputStream
 
        //老韩解读
        //1. System类的out ===> public final static PrintStream out = null;
        //2. 编译类型 PrintStream
        //3. 运行类型 PrintStream
        //4. 表示标准输出 显示器
        System.out.println(System.out.getClass()); //运行类型 PrintStream
 
        System.out.println("hello, world~");
 
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入内容");
        String next = scanner.next();
        System.out.println("next=" + next);
    }
}

六、转换流

1、引入

字节流和字符流之间相互转换

解决乱码问题
（utf-8一个中文是三个字节，GBK一个中文两个字节。用utf-8的编码方式读取GBK会出错）

解决方法：现在有GBK的一串中文字符，字节流可以指定编码方式。①先用字节流指定编码方式为utf-8 ②再转换成字符流读取

2、介绍

传参InputStream（字节流），输出InputStreamReader（字符流）

传参OutputStream，输出OutputStreamWriter

3、应用实例

会出现乱码的案例：

public class CodeQuestion {
    public static void main(String[] args) throws IOException {
        //读取e:\\a.txt 文件到程序
        //思路
        //1.  创建字符输入流 BufferedReader [处理流]
        //2. 使用 BufferedReader 对象读取a.txt
        //3. 默认情况下，读取文件是按照 utf-8 编码，若不是，可能出现乱码情况。
        String filePath = "e:\\a.txt";
        BufferedReader br = new BufferedReader(new FileReader(filePath));
 
        String s = br.readLine();
        System.out.println("读取到的内容: " + s);
        br.close();
 
        //InputStreamReader
        //OutputStreamWriter
    }
}

解决乱码：

/**
 * 演示使用 InputStreamReader 转换流解决中文乱码问题
 * 将字节流 FileInputStream 转成字符流  InputStreamReader, 指定编码 gbk/utf-8
 */
public class InputStreamReader_ {
    public static void main(String[] args) throws IOException {
 
        String filePath = "e:\\a.txt";
        //解读
        //1. 把 FileInputStream 转成 InputStreamReader
        //2. 指定编码 gbk
        //InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), "gbk");
        //3. 把 InputStreamReader 传入 BufferedReader
        //BufferedReader br = new BufferedReader(isr);
 
        //将2 和 3 合在一起
        BufferedReader br = new BufferedReader(new InputStreamReader(
                                                    new FileInputStream(filePath), "gbk"));
 
        //4. 读取
        String s = br.readLine();
        System.out.println("读取内容=" + s);
        //5. 关闭外层流
        br.close();
 
    }
}

演示OutputStreamWriter使用

/**
 * 演示 OutputStreamWriter 使用
 * 把FileOutputStream 字节流，转成字符流 OutputStreamWriter
 * 指定处理的编码 gbk/utf-8/utf8
 */
public class OutputStreamWriter_ {
    public static void main(String[] args) throws IOException {
        String filePath = "e:\\hsp.txt";
        String charSet = "utf-8";
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), charSet);  
        osw.write("hi, 哈哈哈");  //保存的文件编码格式会自动设置为charSet格式
        osw.close();
        System.out.println("按照 " + charSet + " 保存文件成功~");
    }
}

七、打印流

打印流只有输出流，没有输出流

1、PrintStream（字节打印流）

可以直接传入一个文件路径

/**
 * 演示PrintStream （字节打印流/输出流）
 */
public class PrintStream_ {
    public static void main(String[] args) throws IOException {
 
        PrintStream out = System.out;//System.out的编译类型和运行类型都是PrintStream
        //在默认情况下，PrintStream 输出数据的位置是 标准输出，即显示器
        /*
             public void print(String s) {
                if (s == null) {
                    s = "null";
                }
                write(s);
            }
         */
        out.print("john, hello");
        //因为print底层使用的是write , 所以我们可以直接调用write进行打印/输出
        out.write("韩顺平,你好".getBytes());
        out.close();
 
        //我们可以去修改打印流输出的位置/设备
        //1. 输出修改成到 "e:\\f1.txt"
        //2. "hello, 韩顺平教育~" 就会输出到 e:\f1.txt⭐
        //3. public static void setOut(PrintStream out) {
        //        checkIO();
        //        setOut0(out); // native 方法，修改了out
        //   }
        //System.out的编译类型和运行类型都是PrintStream
        System.setOut(new PrintStream("e:\\f1.txt"));
        System.out.println("hello, 韩顺平教育~"); 
    }
}

2、PrintWriter（字符打印流）

public class PrintWriter_ {
    public static void main(String[] args) throws IOException {
 
        //PrintWriter printWriter = new PrintWriter(System.out);
        PrintWriter printWriter = new PrintWriter(new FileWriter("e:\\f2.txt"));
        printWriter.print("hi, 北京你好~~~~");  //printWriter有write方法也有print方法，print底层调用的是write方法
        printWriter.close();//flush + 关闭流, 才会将数据写入到文件..
    }
}

八、Properties类

1、基本介绍

1）专门用于读写配置文件的集合类

配置文件的格式：

键=值

2）注意事项

键值对不需要有空格，值不需要用引号括起来，默认类型是String。

3）Properties的常见方法

① load：加载配置文件的键值对到Properties对象；

② list：将数据显示到指定设备；

③ getProperty(key)：根据键获取值；

④ setProperty(key,value)：设置键值对到Properties对象【没有就是新建，有就是修改】；

⑤ store：将Properties中的键值对存储到配置文件中，在IDEA中，保存信息到配置文件，如果含有中文，会存储为unicode码。

2、应用实例

创建myproperties文件：


mysql.properties

ip=192.168.0.13
root=root汤姆
pwd=12345

1）传统方法

public class Properties01 {
    public static void main(String[] args) throws IOException {
        //读取mysql.properties文件
        BufferedReader br = new BufferedReader(new FileReader("src\\mysql.properties"));
        //按行读取
        String line = "";
        while((line = br.readLine()) != null) {
            String[] s = line.split("=");
            System.out.println(s[0] + "是：" + s[1]);
        }
        br.close();
    }
}

2）properties类方法

public class Properties02 {
    public static void main(String[] args) throws IOException {
        //1. 创建Properties对象
        Properties properties = new Properties();

        //2. 加载指定配置文件
        properties.load(new FileReader("src:\\mysql.properties"));

        //3. 把k-v显示再控制台上
        properties.list(System.out);

        //4. 根据key获取对应的值（返回String类型）
        String user = properties.getProperty("user");
        String pwd = properties.getProperty("pwd");
        System.out.println("用户名是：" + user);
        System.out.println("密码是：" + pwd);
    }
}

3、应用实例2

public class Properties03 {
    public static void main(String[] args) throws IOException {
        //新建一个Properties对象
        Properties properties = new Properties();

        //设置配置文件内容
        //如果键值对中的key在文件中存在，那么再次setProperties就是修改value（底层是Hashtable，核心方法是put）
        /*
            if ((entry.hash == hash) && entry.key.equals(key)) { //如果key存在
                V old = entry.value;
                entry.value = value;  //则修改value
                return old;
            }
         */
        properties.setProperty("charset", "utf8"); //键为charset，值为utf8
        properties.setProperty("user", "汤姆");
        properties.setProperty("pwd","abc11");
        //properties.setProperty("pwd","abc1123");  //修改

        //将上述内容存储到properties文件中，如果该文件不存在，则自动创建
        //这里用FileWriter，可以直接保存中文字符
        //如果用FileOutputStream，保存的是中文字符的unicode值
        properties.store(new FileWriter("src\\mysql2.properties"), null); //后一个参数代表注释
        System.out.println("保存配置文件成功");
    }
}

九、章作业

【第一题】

public class homework01 {
    public static void main(String[] args) throws IOException {
        //(1) 判断d盘下是否有mytemp目录，没有则创建
        String directoryPath = "d:\\mytemp";
        File directory = new File(directoryPath);
        if(!directory.exists()) {
            //file.createNewFile();  //这里创建的是没有格式的mytemp文件
            if(directory.mkdir()) { //创建多级目录
                System.out.println("创建" + directoryPath + "目录成功" );
            } else {
                System.out.println("创建" + directoryPath + "目录失败");
            }
        } else {
            System.out.println("目录" + directoryPath + "已经存在");
        }


        //(2) 在d:\\mytemp下创建hello.txt
        //(3) 如果hello.txt已经存在，则提示
        String fileName = "hello.txt";
        File file = new File(directoryPath , fileName);
        if(!(file.exists())) {
            try {
                if(file.createNewFile()) {
                    System.out.println("创建成功");
                } else {
                    System.out.println("创建失败");
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            System.out.println("文件已经存在，无需重复创建");
        }

        //(4) 在hello.txt中写入hello,world~
        String content = "hello,world~";
        BufferedWriter bw = new BufferedWriter(new FileWriter(file.getAbsoluteFile())); //获取绝对路径
        bw.write(content);
        bw.close();
    }
}

---

【第二题】

public class homework02 {
    public static void main(String[] args) throws IOException {
        String filePath = "d:\\a.txt";  //gbk编码文件
        BufferedReader br = new BufferedReader(new InputStreamReader(
                                                            new FileInputStream(filePath),"gbk"));

        String line = "";

        while ((line = br.readLine()) != null) {
            System.out.println(line + ",");
        }
        br.close();
    }
}

---

【第三题】

public class homework03 {
    public static void main(String[] args) throws IOException {
        Properties properties = new Properties();
        properties.load(new FileReader("src\\io_\\homework\\dog.properties"));

        Dog dog = new Dog();
        dog.name = properties.getProperty("name");
        dog.age = Integer.parseInt(properties.getProperty("age"));
        dog.color = properties.getProperty("color");
        System.out.println("======dog对象信息======");
        System.out.println(dog);

        //将创建的Dog对象，序列化到文件dog.dat文件
        String filePath = "d:\\dog.dat";
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));

        oos.writeUTF(dog.name);
        oos.writeInt(dog.age);
        oos.writeUTF(dog.color);
        System.out.println("序列化成功");
        oos.close(); //必须写，不然写入不成功

        //反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));

        System.out.println("======反序列化=======");
        System.out.println("小狗名字：" + ois.readUTF());
        System.out.println("小狗年龄：" + ois.readInt());
        System.out.println("小狗颜色：" + ois.readUTF());
        System.out.println("反序列化成功");
        ois.close();
    }
}
class Dog implements Serializable {
    String name;
    int age;
    String color;

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}';
    }
}