I/O集合框架_io集成-CSDN博客

本文链接：https://blog.csdn.net/weixin_58841149/article/details/131747415

什么是流

流是内存和硬件存储设备之间传输数据的通道

流的分类

按照流向来分

输入流：数据从存储设备流向内存
输出流：数据从内存流向存储设备

按照读取的单位进行分类

字节流：以字节为单位读取数据，能够读取所有数据
字符流：以字符为单位读取数据，只能读取文本数据

按照功能分类

节点流：具有实际传输数据的读写功能，真正进行读写操作的流
过滤流：在节点流的基础上增强功能

字节流

字节流的父类(抽象类)

inputSteam：字节输入流
- 常用方法：
  - public int read（）=>进行数据的读写，按照字节
  - public int read（byte [ ] b）=>从输入流中读取一定数量的字节，存放于缓冲区数组b中。
  - public int read（byte [ ] b,int off,int len）=>在数据流中最多len个数据字节读取到b数组中
OutInputSteam：字节输出流
- 常用方法：
  - public void write（int b）=>将指定的字节b写入此输出流
  - public void write（byte [ ] b）=>将b.length长度的字节从byte数组中写到此输入流。
  - public void write（byte [ ] b,int off,int len）=>从偏移量off开始，将byte数组中len个字节写入此输入流。

FileInputSteam输入流的使用

可以单字节或者多字节的读取数据

package com.oop.InputFileSteam;

import java.io.FileInputStream;

/**
 * 字节输入流的简单使用
 *      读取文件
 *      1. 单个字节读取
 *      2.多个字节读取
 *      3.关闭数据流
 */
public class InputFIleSteamTest {
    public static void main(String[] args) throws Exception{
        //创建一个输入数据流对象，同时给他一个数据的位置
        FileInputStream fi = new FileInputStream("d:\\Desktop\\test.txt");
        //1.读取文件
//        fi.read();
        /**
         *         2.单字节读取文件
         *         int date=0;//date用于判断单字节读取完后何时跳出循环
         *         while ((date=fi.read())!=-1){
         *             System.out.print((char) date);
         *         }
         */
        System.out.println("========一次读取多个使用byte数组保存==========");
        //3.一次读取多个字节
        byte[] by=new byte[3];
        int count = 0;
        while ((count=fi.read(by))!=-1){
            //System.out.println(强制类型转换(输出保存数据的数组,从那个数组下标开始,每次读取的个数));
            System.out.println(new String(by,0,count));
        }
        //读取完成后关闭数据流
        fi.close();
        System.out.println();
        System.out.println("关闭数据流成功");
    }
}

OutInputSteam输出流的使用

可以单个或者通过字符串进行多个字节的写入
在使用FileOutputStream构造方法时可以选择对文件进行覆盖或者续写
FileOutputStream fo = new FileOutputStream("d:\\Desktop\\test.txt",true);对文件进行续写
FileOutputStream fo = new FileOutputStream("d:\\Desktop\\test.txt",false);对文件进行覆盖。

package com.oop.InputFileSteam;

import java.io.FileOutputStream;

//演示文件输出流的使用  FileOutputStream
public class OutFileSteam {
    public static void main(String[] args) throws Exception {
        //创建文件输出流对象
        FileOutputStream fo = new FileOutputStream("d:\\Desktop\\test.txt",true);
        //单个字节写入文件
//        fo.write(97);
//        System.out.println("写入成功");
        //一次性写入多个字节
        String s="hello";
        fo.write(s.getBytes());
        System.out.println("写入hello成功");
    }
}

通过FileInputSteam和FileOutputSteam对文件进行复制

在使用FileInputSteam和FileOutputSteam对文件进行复制时，要求对文件一边写入一边输出。

package com.oop.InputFileSteam;

import java.io.FileInputStream;
import java.io.FileOutputStream;

//文件字节流的数据复制
public class CopyFIleSteam {
    public static void main(String[] args) throws Exception{
        //创建一个字节输入流对象
        FileInputStream fi = new FileInputStream("D:\\Desktop\\1.png");
        //创建一个字节输出流对象
        FileOutputStream fo = new FileOutputStream("D:\\Desktop\\2.png");
        //通过字节流对文件进行复制要求边读边写
        byte[] by=new byte[1024*4];//设置byte缓冲区的大小
        int count=0;
        while ((count=fi.read(by))!=-1){
                //读取一次就写入一次
            fo.write(by,0,count);
        }
        fi.close();
        fo.close();
        System.out.println("复制成功");
    }
}

字节缓冲流BufferedInputStream对文件进行读取

字节缓冲区的读写
- 能够有效的提高字节的写入速度
- 在字节写入前会优先在缓冲流中遍历，已经存在的不用在写入
- 字节缓冲流的使用需要一个底层的字节输入流
- 在关闭数据流时只需要关闭字节缓冲流，不需要关闭底层的字节流

package com.oop.InputFileSteam;

import java.io.BufferedInputStream;
import java.io.FileInputStream;

/**
 * 字节缓冲区的读写
 *      能够有效的提高字节的写入速度
 *      在字节写入前会优先在缓冲流中遍历，已经存在的不用在写入
 *      字节缓冲流的使用需要一个底层的字节输入流
 *      在关闭数据流时只需要关闭字节缓冲流，不需要关闭底层的字节流
 */
public class BufferInputSteam {
    public static void main(String[] args)throws Exception {
        //创建一个底层的字节输入流
        FileInputStream fi = new FileInputStream("d:\\Desktop\\test.txt");
        //创建一个用于读取 fi 的字节缓冲流
        BufferedInputStream bf = new BufferedInputStream(fi);
        //BufferedInputStream有默认设置缓冲区的大小可以不自己在设置缓冲区大小
        byte[] bytes = new byte[1024];
        //读取
        int count=0;
        while ((count=bf.read())!=-1){
            System.out.print((char) count);
        }

    }
}

字节缓冲流BufferedOutputStream对文件进行写入

字节缓冲流的写入会优先写入到BufferedOutputStream所创建的缓冲区中
在写入没有没有大于BufferedOutputStream的缓冲区8K时，内容会优先存放在缓冲区而不是硬盘存储
flush.()直接刷新缓冲区，把缓冲区的数据写入硬盘
在关闭缓冲流时，也会自动调用flush方法
字节缓冲流写入和读取一样需要一个底层的输出流

public class BufferOutputStream {
    public static void main(String[] args)throws Exception {
        //创建一个底层的字节输出流
        FileOutputStream fo = new FileOutputStream("d:\\Desktop\\test1.txt");
        //创建一个缓冲流对象
        BufferedOutputStream bfo = new BufferedOutputStream(fo);
        //使用缓冲区写入
        for(int i=0;i<99;i++){
            //写入缓冲流
            //使用getBytes将字符串转变为byte类型
            bfo.write("hello\t\n".getBytes());
            //刷新缓冲区
            bfo.flush();
        }
        System.out.println("写入完成");
        //关闭
        bfo.close();
    }
}

对象流

对象流有两种：输入=>ObjectInputStream，输出=>ObjectOutputStream
对象流增强了八种基本数据类型和字符串的读写功能
增强了读写对象的功能：
- readObject（）=> 从流中读取对象–也被称为反序列化
- writeObject（）=>向流中写入对象–也被称为序列化

对象的写入=>序列化

用于实现对象流输出，展现对象流中的对象的写入。
想要使用ObjectOutput方法进行对象的序列化，必须要有一个底层的输出流
想要将对象写入流中，对象所对应的类必须要实现Serializable方法
实现案例：创建一个名叫Student的实体类，在Output测试类中实现对象的向流的写入
- Student：

package com.oop.ObjectFlow;

import java.io.Serializable;

/**
 * 创建一个类-用于存储一个对象的属性和方法，便于对象流序列化时的对象实例化
 */
public class Student implements Serializable {
    private String name;
    private int age;

    public Student() {
    }

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

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

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

* OutPut：

package com.oop.ObjectFlow;

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

//用于实现对象流输出，展现对象流中的对象的写入。
//想要使用ObjectOutput方法进行对象的序列化，必须要有一个底层的输出流
//想要将对象写入流中，对象所对应的类必须要实现Serializable方法
public class OutPut {
    public static void main(String[] args) throws Exception{
        //创建一个底层的FileOutputStream输出流
        FileOutputStream fos = new FileOutputStream("D:\\Desktop\\FileObject.text");
        //创建对象流
        ObjectOutputStream oob = new ObjectOutputStream(fos);
        //将对象写入到流中
        //1. 创建一个对象
        Student stu = new Student("何时", 10);
        //使用writeObject方法将对象写入流中
        oob.writeObject(stu);

        System.out.println("==========多个对象的写入==========");
        //创建多个需要写入的对象
        Student zhangsan = new Student("zhangsan", 10);
        Student lisi = new Student("lisi", 48);
        //多个对象的写入可以借助ArrayList类
        ArrayList<Student> list = new ArrayList<>();
        list.add(zhangsan);
        list.add(lisi);
        //对list这个数组进行写入
        oob.writeObject(list);
        System.out.println("对象写入成功");
        oob.close();

    }
}

对象的读取=>反序列化

实现对象从流中进行读取反序列化
反序列化对的实质就是将一个对象的字节流文件读取到计算机中，并且将其生成为一个对象
反序列化需要一个底层节点，就是一个底层的输入流
- 实现案例：创建一个名叫Student的实体类，在Intput测试类中实现对象的向流的读取
Input：

package com.oop.ObjectFlow;

import java.io.FileInputStream;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.lang.reflect.Array;
import java.util.ArrayList;

//实现对象从流中进行读取   反序列化
//反序列化对的实质就是将一个对象的字节流文件读取到计算机中，并且将其生成为一个对象
//反序列化需要一个底层节点，就是一个底层的输入流
public class InPut {
    public static void main(String[] args) throws Exception{
        //创建一个底层的数据输入流
        FileInputStream fis = new FileInputStream("D:\\Desktop\\FileObject.text");
        //创建反序列化的对象流
        ObjectInputStream obs = new ObjectInputStream(fis);
        //反序列化
//        Student s=(Student) obs.readObject();
//        System.out.println(s.toString());

        //批量读取字节流对象的输入
        ArrayList<Student> list=(ArrayList<Student>) obs.readObject();
        //关闭流
        obs.close();
        System.out.println(list.toString());

    }
}

注意事项

序列化的类或者其内部类都必须要实现Serializable方法
序列化的版本号ID是为了保证序列化和反序列化都是使用的同一个类
使用transient和static修饰的属性不能被序列化
想要序列化多个属性可以通过ArrayList实现，能够减少代码的复杂度

字符流抽象类

因为编码的不同，在汉语中一个汉字不止占一个字节，如果使用字节流输出和输出对汉字进行操作，则会导致出现乱码。
字符流抽象类中的FIleRead（）和FIleWrite（）方法是专门用来对字符进行读取和写入的。

字符流的读取=>FIleRead（）

代码举例

package com.oop.InputFileSteam;

import java.io.FileReader;

//字符流读取文件  FIleRead
public class FileRead {
    public static void main(String[] args) throws Exception{
        //创建字符流对象
        FileReader fil = new FileReader("D:\\Desktop\\test 2.txt");
        //单个的读取字符
//        int count=0;
//        while ((count= fil.read())!=-1){
//            System.out.print((char) count);
//        }

        //读取多个字符
        char[] chars = new char[3];//创建缓冲区
        int count=0;
        while ((count= fil.read(chars))!=-1){
            System.out.println(new String(chars,0,count));
        }
        fil.close();
    }
}

字符流的写入=>FileWrite

代码示例

package com.oop.InputFileSteam;

import java.io.FileWriter;

//字符流的写入  =>FileWrite
public class FileWrite {
    public static void main(String[] args) throws Exception{
        //创建一个字符流写入对象
        FileWriter fiw = new FileWriter("D:\\Desktop\\test 3.txt");
        //创建字符串用于保存写入的字符
        String s="你好和发阿发if会儿";
        //写入
        fiw.write(s);
        fiw.flush();
        fiw.close();
        System.out.println("写入成功");
    }
}

字符流的复制

在使用FIleRead和FileWrite对文件进行复制时，只能对文本文件进行复制，对其他文件进行复制时会到时文件编码出错，复制的东西不是原本的文件。

代码示例

package com.oop.InputFileSteam;

import java.io.FileReader;
import java.io.FileWriter;

//使用字符流进行文件的复制
//使用字符流对文件进行复制时，只能对文本文件进行复制，
//  字符流对文件的复制本质是将二进制转为字符，再将字符复制到对应的文件中，而将文件从二进制转为字符后，在将字符复制会导致乱码
public class FileReadAndFileWriteCopy {
    public static void main(String[] args) throws Exception{
        //创建字符输入流
        FileReader fil = new FileReader("D:\\Desktop\\test 3.txt");
        //创建字符输出流
        FileWriter fiw = new FileWriter("D:\\Desktop\\test 4.txt");
        //文件读取和复制
        int count=0;
        while ((count=fil.read())!=-1){
            //边读取边写入
            fiw.write(count);
        }
        fil.close();
        fiw.close();
        System.out.println("搞定");
    }
}

字符流缓冲区：BufferedRead和BufferedWrite

字符流缓冲区的使用和字节流缓冲区的使用作用相同，能提高字符流的效率

BufferedRead

BufferRead中有一个独特的方法readline()能够以行为单位读取文件

代码又来了哦

package com.oop.InputFileSteam;

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

//字符缓冲区，使用方式和字节缓冲区类似
public class BufferRead {
    public static void main(String[] args) throws Exception{
        //创建一个字符流对象
        FileReader fil = new FileReader("D:\\Desktop\\test 3.txt");
        //创建一个字符流缓冲区对象
        BufferedReader br = new BufferedReader(fil);
        //使用老办法，单个字符读取
        //创建一个缓冲区
//        char[] chars = new char[1024];
//        //创建一个count计算读取的字符个数
//        int count=0;
//        while ((count= br.read(chars))!=-1){
//            System.out.println(new String(chars,0,count));
//        }

        //新法子  使用BufferedReader中自带的readline方法对整行进行读取
        //创建一个空字符串用于保存所读取的一行文本
        String s="";
        while ((s=br.readLine())!=null)
        {
            System.out.println(s);
        }
        fil.close();
        br.close();
    }
}

BufferedWrite

BufferedWrite中对写入的数据允许使用换行符
来了来了又来了

package com.oop.InputFileSteam;

import java.io.BufferedWriter;
import java.io.FileWriter;

//字符流缓冲区的写入  =>BufferedWrite
public class BufferWrite {
    public static void main(String[] args) throws  Exception{
        //创建字符输出流
        FileWriter fiw = new FileWriter("D:\\Desktop\\test 5.txt");
        //创建字符缓冲流
        BufferedWriter buf = new BufferedWriter(fiw);
        //写入
        for (int i = 0; i < 10; i++) {
            buf.write("法埃返回安徽日发放【\n");
            buf.flush();
        }
        fiw.close();
        buf.close();
        System.out.println("写入OK");
    }
}

打印流=>PrintWrite

打印流的输出会保存文件原本的样子
打印的数据会覆盖原本文件中存在的数据
代码：

package com.oop.InputFileSteam;

import java.io.PrintWriter;

/**
 * 演示打印流
 * 打印流的输出会保存文件原本的样子
 * 打印的数据会覆盖原本文件中存在的数据
 */
public class PrintWrite {
    public static void main(String[] args) throws Exception{
        //创建一个打印流对象
        PrintWriter pw = new PrintWriter("D:\\Desktop\\test 2.txt");
        //打印  调用println()
        pw.println(48);//打印整形
        pw.println("fd");//字符
        pw.print(9.2);
        pw.close();
        System.out.println("打印完成");

    }
}

转换流：InputStreamReader和OutputStreamWrite

InputStreamReader：将硬盘中的字节流转换为内存中的字符流
OutputStreamWrite：将内存中的字符流转换成硬盘中的字节流
图形解释：
InputStreamReader 的实例代码实例：

package com.oop.InputFileSteam;

import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;

/**
 * InputStreamReader字节流和字符流之间转换的桥梁
 * InputStreamReader 将存储在硬盘中的字节流
 * 字节流的转换需要使用一个字节流节点
 */
public class InputStreamRead {
    public static void main(String[] args)throws Exception {
        //创建一个字节流节点
        FileInputStream fit = new FileInputStream("d:\\Desktop\\test.txt");
        //创建一个转换InputStreamReader的节点
        //nputStreamReader(所需要转换的字节流节点,"字符编码");
        InputStreamReader isr = new InputStreamReader(fit,"gbk");
        int count=0;
        while ((count= isr.read())!=-1){
            System.out.print((char)count);
        }
        isr.close();

    }
}

OutputStreamWrite 的代码实例：

package com.oop.InputFileSteam;

import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

//将内存中的数据转化没硬盘中的字节流数据
public class OutputStreamWrite {
    public static void main(String[] args) throws Exception {
        //创建一个底层的输出流节点
        FileOutputStream fos = new FileOutputStream("d:\\Desktop\\test6.txt");
        //根据底层节点创建对应的转化节点
        //new OutputStreamWriter(转换的对应的底层节点,"转换的对应的编码");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
        //写入
        String str="华府为按时按回复";
        for (int i=0;i<10;i++){
            osw.write(str,0,str.length());
        }
        osw.close();
        System.out.println("搞定");
    }
}

File类

File类中的文件操作和文件夹操作

package com.oop.Fileoperation;

import java.io.FileFilter;
import java.util.Date;

//File对于文件的操作
public class File {
    public static void main(String[] args)throws Exception {
        //输出路径分隔符"/"，和名称分隔符“;”
        sep();
        //创建文件
        fileoper();
        System.out.println("===========文件夹操作=============");
        directory();

    }
    //输出路径分隔符"/"，和名称分隔符“;”
    public static void sep(){
        System.out.println("路径分隔符"+ java.io.File.pathSeparator);
        System.out.println("名称分隔符"+ java.io.File.separator);
    }
    //文件操作
    public static void fileoper() throws Exception{
        //1. 创建文件
            //实例化对象
        java.io.File file = new java.io.File("d:\\Desktop\\test7.txt");
            //创建;使用if判断是否存在
        //file.exists()判断文件是否存在，若不存在则创建
        if (!file.exists()){
            boolean b = file.createNewFile();
            System.out.println("创建结果"+b);
        }
        System.out.println("=========删除文件============");
        //1.使用delete删除
        //System.out.println("删除结果"+file.delete());
        //2.使用jvm虚拟机退出时删除
        //file.deleteOnExit();
        //Thread.sleep(5000);//上一步操作进行休眠处理，即过了固定的时间在执行

        //获取文件信息
            //获取文件绝对地址
        System.out.println("获取文件绝对路径"+file.getAbsolutePath());
            //获取相对路径
        System.out.println("获取文件相对路径"+file.getPath());
            //获取文件名
        System.out.println("获取文件名"+file.getName());
            //获取文件的父目录
        System.out.println("获取文件的父目录"+file.getParent());
            //获取文件长度
        System.out.println("获取文件长度"+file.length());
            //文件创建时间
        System.out.println("文件创建时间"+new Date(file.lastModified()).toLocaleString());

        //判断文件类型
            //文件是否可写
        System.out.println("文件是否可写"+file.canWrite());
            //文件是否隐藏
        System.out.println("文件是否隐藏"+file.isHidden());
            //是否是文件而不是文件夹
        System.out.println("是否是文件"+file.isFile());

    }

    //文件夹操作
    public  static  void directory()throws Exception{
        //创建文件夹对象
        java.io.File file = new java.io.File("d:\\Desktop\\aaa\\bbb\\ccc");
        //判断文件夹是否存在
        if(!file.exists()){
//            file.mkdir();//只能创建单级目录
            file.mkdirs();//创建多级目录
            System.out.println("创建成功");
        }
        //删除目录,只能删除最底层的目录
            //1. 直接删除
        file.delete();
            //2. 通过jvm虚拟机退出删除
//        file.deleteOnExit();

        //获取文件夹信息
        System.out.println("获取文件夹绝对路径"+file.getAbsolutePath());
        System.out.println("获取文件路径"+file.getPath());
        System.out.println("获取文件名"+file.getName());
        System.out.println("获取创建时间"+new Date(file.lastModified()).toLocaleString());

        //判断文件类型
        System.out.println("是否是文件夹"+file.isFile());
        System.out.println("是否隐藏"+file.isHidden());

        //遍历文件夹，能够将文件用String数组或者file数组的形式输出
        java.io.File file1 = new java.io.File("D:\\Desktop\\junior training tool");
        String[] str=file1.list();//遍历整个文件夹
        for (String string: str
             ) {
            System.out.println(string);
        }
        System.out.println("===========FileFilter的使用=============");
        java.io.File[] files = file1.listFiles(new FileFilter() {
            @Override
            public boolean accept(java.io.File pathname) {
                if (pathname.getName().endsWith(".zip")) {
                    return true;
                }
                return false;
            }
        });
        for (java.io.File fi:files) {
            System.out.println(fi.getName());
        }
    }
}

File文件夹的遍历操作

对文件夹内的所有文件包括子文件夹内的所有文件进行递归遍历。

package com.oop.Fileoperation;

import java.io.File;

//对文件夹内的所有文件包括子文件夹内的所有文件进行递归遍历
public class ListFile {
    public static void main(String[] args) throws Exception{
        listfile(new File("D:\\Desktop\\junior training tool"));
    }
    public static void listfile(File dir){
        File[] files = dir.listFiles();
        System.out.println(dir.getAbsolutePath());
        if (files!=null&&files.length>0){
            for (File fi:files
                 ) {
                //判断是否是文件夹
                if (fi.isDirectory()){
                    listfile(fi);//递归
                }
                else {
                    System.out.println(fi.getAbsolutePath());
                }
            }
        }

    }
}

递归删除文件夹中所有文件和文件夹

//对文件夹内的所有文件包括子文件夹内的所有文件进行递归遍历
public class ListFile {
    public static void main(String[] args) throws Exception{
//        listfile(new File("D:\\Desktop\\junior training tool"));
        delete(new File("D:\\Desktop\\aaa"));
    }
 public static void delete(File dir){
        File[] files = dir.listFiles();
        if (files!=null&&files.length>0){
            for (File fi:files) {
                if (fi.isDirectory()){
                    delete(fi);
                }
                else {
                    System.out.println(fi.getAbsolutePath()+"删除"+fi.delete());
                }
            }
        }
        System.out.println(dir.getAbsolutePath()+"删除空文件夹"+dir.delete());
    }

}

补充Properties

Properties是一个属性集合
Properties能存储属性名和属性值，且存储的都是字符串
Properties能进行与流有关的操作
详情请看下回讲解：

package com.oop.Properties;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Set;

//Properties方法的简单使用
public class Properties {
    public static void main(String[] args)throws Exception {
        //Properties集合的创建
        java.util.Properties pro = new java.util.Properties();
        //向创建的集合中添加数据
        //pro.setProperty("属性名","属性值");
        pro.setProperty("name","张三");
        pro.setProperty("age","12");
        System.out.println(pro.toString());
        //遍历properties集合
        Set<String> str = pro.stringPropertyNames();
        for (String s:str
             ) {
            System.out.println("属性名:"+s+"属性值:"+pro.getProperty(s));
        }


        System.out.println("与流有关的操作");
        //打印流，将properties集合中的数据打印到指定路径
        PrintWriter pw = new PrintWriter("D:\\Desktop\\test 8.txt");
        pro.list(pw);
        pw.close();
        System.out.println("打印完成");
        System.out.println("-----store保存方法------");
        //store保存方法
        FileOutputStream fos = new FileOutputStream("D:\\Desktop\\test7.txt");
        //pro.store(保存对象,"保存内容，字符保存");
        //保存的内容只会是对应文件内的注释，且 不能保存汉字
        pro.store(fos,"nihao");
        fos.close();
        System.out.println("保存成功");


        System.out.println("---------load加载方法------");
        FileInputStream fis = new FileInputStream("D:\\Desktop\\test7.txt");
        pro.load(fis);
        //关闭流
        fis.close();
        System.out.println(pro.toString());
    }
}