JavaSE进阶27 - 数据流、标准输出流、File类、序列化和反序列化、IO和Properties联合使用

数据流

DataOutputStream

package com.bjpowernode.javase.io;

import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

/*
java.io.DataOutputStream：数据专属的流。
这个流可以将数据连同数据的类型一并写入文件。
注意：这个文件不是普通文本文档。（这个文件使用记事本打不开。）
 */
public class DataOutputStreamTest {
    
    
    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

package com.bjpowernode.javase.io;

import java.io.DataInputStream;
import java.io.FileInputStream;

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

中国电信开发项目：
    话务员，每天打电话
 */
public class DataInputStreamTest {
    
    
    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 + 1000);
        System.out.println(l);
        System.out.println(f);
        System.out.println(d);
        System.out.println(sex);
        System.out.println(c);


        dis.close();
    }
}

标准输出流

PrintStream

package com.bjpowernode.javase.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;

/*
java.io.PrintStream：标准的字节输出流。默认输出到控制台。
 */
public class PrintStreamTest {
    
    
    public static void main(String[] args) throws Exception {
    
    
        // 联合起来写
        System.out.println("Hello World!");

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

        // 标准输出流不需要手动close()关闭。
        // 可以改变标准输出流的输出方向吗？可以
        /*
        // 这些是之前System类使用过的方法和属性
        System.gc();
        System.currentTimeMillis();
        PrintStream ps2 = System.out;
        System.exit(0);
        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");
    }
}

日志文件

• 日志工具方法

package com.bjpowernode.javase.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
日志工具
 */
public class Logger {
    
    
    public static void log(String msg) {
    
    

        /*
        * 记录日志的方法
        * */

        try {
    
    
            // 指向一个日志文件
            PrintStream 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 strTime = sdf.format(nowTime);

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

• 调用日志工具

package com.bjpowernode.javase.io;

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

java.io.File类

package com.bjpowernode.javase.io;

import java.io.File;

/*
File
    1、File类和四大家族没有关系，所以File类不能完成文件的读和写。
    2、File对象代表什么？
        文件和目录路径名的抽象表示形式。
        C:\Drivers 这是一个File对象。
        C:\Drivers\Lan\Realtek\Readme.txt 也是File对象。
        一个File对象有可能对应的是目录，也可能是文件。
        File只是一个路径名的抽象表示形式。
    3、需要掌握File类中的常用方法。
 */
public class FileTest01 {
    
    
    public static void main(String[] args) throws Exception{
    
    
        // 创建一个File对象
        File f1 = new File("D:\\Java\\Pros\\IdeaPros\\advanced_21\\file");

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

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

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

        /*// 可以创建多重目录吗？可以
        File f2 = new File("D:\\Java\\Pros\\IdeaPros\\advanced_21\\A\\B\\C\\D");
        if(!f2.exists()){
            // 以多重目录的形式新建
            f2.mkdirs();
        }*/

        File f3 = new File("D:\\Java\\Pros\\IdeaPros\\advanced_21\\什么是IO.png");
        // 获取文件的父路径
        String parentPath = f3.getParent();
        System.out.println(parentPath); // D:\Java\Pros\IdeaPros\advanced_21

        File parentFile = f3.getParentFile();
        System.out.println("绝对路径： " + parentFile.getAbsolutePath()); // 绝对路径： D:\Java\Pros\IdeaPros\advanced_21

        File f4 = new File("什么是IO.png");
        System.out.println("绝对路径： " + f4.getAbsolutePath()); // 绝对路径： D:\Java\Pros\IdeaPros\advanced_21\什么是IO.png
    }
}

package com.bjpowernode.javase.io;

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

/*
File类的常用方法：

 */
public class FileTest02 {
    
    
    public static void main(String[] args) {
    
    
        File f1 = new File("D:\\Java\\Pros\\IdeaPros\\advanced_21\\文件的复制原理.png");
        // 获取文件名
        System.out.println("文件名： " + f1.getName());

        // 判断是否是一个目录？判断是否是一个文件？
        System.out.println(f1.isDirectory()); // false

        System.out.println(f1.isFile()); // true

        // 获取文件的最后一次修改时间
        long haoMiao = f1.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(f1.length()); // 95184字节
    }
}

package com.bjpowernode.javase.io;

import java.io.File;

/*
File中的listFiles方法。
 */
public class FileTest03 {
    
    
    public static void main(String[] args) {
    
    
        // File[] listFiles()
        // 获取当前目录下所有的子文件。

        File f = new File("D:\\Java\\Pros\\IdeaPros");
        File[] files = f.listFiles();

        // foreach
        for(File file : files){
    
    
            // System.out.println(file.getAbsolutePath());
            System.out.println(file.getName());
        }
    }
}

目录拷贝

package com.bjpowernode.javase.io;

import java.io.*;

/*
拷贝目录
 */
public class CopyAll {
    
    
    public static void main(String[] args) {
    
    
        // 拷贝源
        File srcFile = new File("D:\\研究生专业课\\综合英语");
        // 拷贝目标
        File destFile = new File("D:\\Java\\Pros\\IdeaPros\\advanced_21");
        // 调用方法拷贝
        copyDir(srcFile, destFile);
    }

    /**
     * 拷贝目录
     * @param srcFile 拷贝源
     * @param destFile 拷贝目标
     */
    private static void copyDir(File srcFile, File destFile) {
    
    
        if(srcFile.isFile()){
    
    
            // srcFile如果是一个文件的话，递归结束。
            // 是文件的时候需要拷贝。
            // ........一边读，一边写
            FileInputStream in = null;
            FileOutputStream out = null;
            try {
    
    
                // 读这个文件
                // D:\研究生专业课\综合英语\录频\PPT展示\1.mp4
                in = new FileInputStream(srcFile);
                // 写到这个文件中
                // D:\Java\Pros\IdeaPros\advanced_21\研究生专业课\综合英语\录频\PPT展示\1.mp4
                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(in != null){
    
    
                    try {
    
    
                        in.close();
                    } catch (IOException e) {
    
    
                        e.printStackTrace();
                    }
                }
                if(out != null){
    
    
                    try {
    
    
                        out.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());
                // D:\研究生专业课\综合英语\录频  源目录
                // D:\Java\Pros\IdeaPros\advanced_21\研究生专业课\综合英语\录频  目标目录
                String srcDir = file.getAbsolutePath();
                //System.out.println(srcDir.substring(3));
                String destDir = (destFile.getAbsolutePath().endsWith("\\") ? destFile.getAbsolutePath() : destFile.getAbsolutePath() + "\\") + srcDir.substring(3);
                //System.out.println(destDir);
                File newFile = new File(destDir);
                if(!newFile.exists()){
    
    
                    // 以多重目录形式
                    newFile.mkdirs();
                }
            }
            // 递归调用
            copyDir(file, destFile);
        }
    }
}

序列化和反序列化

原理

## 序列化的实现

package com.bjpowernode.javase.bean;


import java.io.Serializable;

public class Student implements Serializable {
    
    
    // Java虚拟机看到Serialzable接口之后，会自动生成一个序列化版本号
    // 这里没有手动写出来，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 + '\'' +
                '}';
    }
}

package com.bjpowernode.javase.io;

import com.bjpowernode.javase.bean.Student;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.rmi.server.ExportException;

/*
1、java.io.NotSerializableException：
    Student这个类不支持序列化，需要实现接口Serializable。

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

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

 */
public class ObjectOutputStreamTest01 {
    
    
    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();
    }
}

反序列化的实现

package com.bjpowernode.javase.io;

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

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

序列化多个对象

package com.bjpowernode.javase.bean;

import java.io.Serializable;

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 + '\'' +
                '}';
    }
}

package com.bjpowernode.javase.io;

import com.bjpowernode.javase.bean.User;

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

/*
一次序列化多个对象呢？
    可以，可以将对象放到集合当中，序列化对象。
提示：
    参与序列化的ArrayList集合以及集合中的元素User都需要实现 java.io.Serializable接口。
 */
public class ObjectOutputStreamTest02 {
    
    
    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, "wangwu"));
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("users"));

        // 序列化集合，这个集合对象当中放了许多其他对象、
        oos.writeObject(userList);

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

package com.bjpowernode.javase.io;

import com.bjpowernode.javase.bean.User;

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

/*
反序列化集合
 */
public class ObjectInputStreamTest02 {
    
    
    public static void main(String[] args) throws Exception{
    
    
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("users"));
        /*Object obj = ois.readObject();
        System.out.println(obj instanceof List); // true*/
        List<User> userList = (List<User>)ois.readObject();
        for(User user : userList){
    
    
            System.out.println(user);
        }
        ois.close();
    }
}

transient关键字

package com.bjpowernode.javase.bean;

import java.io.Serializable;

public class User implements Serializable {
    
    
    private int no;
    // transient关键字表示游离的，不参与序列化。
    private transient String name; // 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 + '\'' +
                '}';
    }
}

关于序列化版本号

package com.bjpowernode.javase.bean;


import java.io.Serializable;

public class Student implements Serializable {
    
    
    // Java虚拟机看到Serialzable接口之后，会自动生成一个序列化版本号
    // 这里没有手动写出来，java虚拟机会默认提供这个序列化版本号。
    // 建议将序列化版本号手动的写出来。不建议自动生成
    private static final long serialVersionUID = 1L; // java虚拟机识别一个类的时候先通过类名，如果类名一致，会通过序列化版本号识别。

    private int no;
    private String name;

    // 过来很久，Student这个类源代码改动了。
    // 源代码改动之后，需要重新编译，编译之后生成了全新的字节码文件。
    // 并且class文件再次运行的时候，java虚拟机生成的序列化版本号也会发生相应的改变。
    private int age;
    //private String addr;

    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 + '\'' +
                ", age=" + age +
                '}';
    }
}

package com.bjpowernode.javase.io;

import com.bjpowernode.javase.bean.Student;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.rmi.server.ExportException;

/*
1、java.io.NotSerializableException：
    Student这个类不支持序列化，需要实现接口Serializable。

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

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

4、序列化版本号有什么用呢？
    java.io.InvalidClassException:
        com.bjpowernode.javase.bean.Student;
        local class incompatible:
            stream classdesc serialVersionUID = -2490588915011604657, （十年后）
            local class serialVersionUID = -1642973173358893535 （十年前）
    java语言中是采用什么机制来区分类的？
        第一：首先通过类名进行比对，如果类名不一样，肯定不是同一个类。
        第二：如果类名一样，再怎么进行类的区别呢？靠序列化版本号进行区分。

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

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

    最终的结论：
        凡是一个类实现了Serializable接口，建议给该类提供一个固定不变的序列化版本号。
        这样，以后这个类即使代码修改了，但是版本号不变，java虚拟机会认为这是同一个类。
 */
public class ObjectOutputStreamTest01 {
    
    
    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();
    }
}

package com.bjpowernode.javase.io;

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

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

IDEA自动生成序列化版本号

• 光标移动到类名上，快捷键：Alt + Enter

package com.bjpowernode.javase.bean;


import java.io.Serializable;

public class Student implements Serializable {
    
    
    // IDEA自动生成序列化 : ALT + Enter
    private static final long serialVersionUID = 9119334117414507990L;
    // Java虚拟机看到Serialzable接口之后，会自动生成一个序列化版本号
    // 这里没有手动写出来，java虚拟机会默认提供这个序列化版本号。
    // 建议将序列化版本号手动的写出来。不建议自动生成
    //private static final long serialVersionUID = 1L; // java虚拟机识别一个类的时候先通过类名，如果类名一致，会通过序列化版本号识别。


    private int no;
    private String name;

    // 过来很久，Student这个类源代码改动了。
    // 源代码改动之后，需要重新编译，编译之后生成了全新的字节码文件。
    // 并且class文件再次运行的时候，java虚拟机生成的序列化版本号也会发生相应的改变。
    private int age;
    //private String addr;

    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 + '\'' +
                ", age=" + age +
                '}';
    }
}

IO和Properties联合使用

• IO流：文件的读和写。
• Properties：是一个Map集合，key和value都是String类型。

# 此文件名为：userinfo.properties
username=root
############在属性配置文件中井号是注释#################
#属性配置文件的key重复的话，value会自动覆盖！
#password=123
password=111
# 最好不要有空格
data = 100
# 不建议使用:
usernamex:admin

package com.bjpowernode.javase.io;

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

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

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

     java规范中有要求：属性配置文件建议以.properties结尾，但这不是必须的。
     这种以.properties结尾的文件在java中被称为：属性配置文件。
     其中Properties是专门存放属性配置文件内容的一个类。
 */
public class IoPropertiesTest01 {
    
    
    public static void main(String[] args) throws Exception{
    
    
        /*
         Properties是一个Map集合，key和value都是String类型。
         想将userinfo文件中的数据加载到Properties对象当中。
         */
        // 新建一个输入流对象 读 从硬盘到内存
        FileReader reader = new FileReader("io/userinfo.properties");

        // 新建一个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);

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

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

    }
}