Java IO框架

yuboyao1012

已于 2023-04-08 14:25:10 修改

阅读量166

点赞数

文章标签： java jvm 开发语言

于 2022-08-30 20:08:52 首次发布

本文链接：https://blog.csdn.net/yuboyao1012/article/details/126611569

版权

塈百日而求新，念三番未发，其二

流

是内存与存储设备(硬盘)之间传输数据的通道。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0boAUQDT-1661861178476)(C:\Users\86156\AppData\Roaming\Typora\typora-user-images\image-20220523023934035.png)]$

数据借助流来传输。

流的分类

按方向来分：

输入流：将存储设备中的内容读入内存
输出流：将内存中的内容写入存储设备中

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zoAUEcO9-1661861178478)(C:\Users\86156\AppData\Roaming\Typora\typora-user-images\image-20220523024212181.png)]$

按单位来分：

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

按照功能来分：

节点流：具有实际传输数据的读写功能
过滤流：在节点流的基础之上增强功能

字节流

字节流的父类(抽象类)：

InputStream(字节输入流)：
- ```
public int read(){}
```
OutpStream(字节输出流)：
- ```
public void write(int n){}
```

抽象类不能实例化，所以需要引用其子类，例如：FileInputStream等

文件字节流

FileInputStream

package com.qf.chap15_1;

import java.io.FileInputStream;

public class Demo01 {
    public static void main(String[] args) throws Exception{
        //1.    创建FileInputStream，并指定文件路径
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");   //因为不确定文件是否肯定存在，有一个小异常，所以需要抛出异常
        //2.    读取文件
        //2.1   单个字节读取
        //fis.read(); 特点：只能挨个读取字节；当读取结束就返回 -1
        /*int data = 0;   //保存读取的字节
        while ((data=fis.read())!=-1){
            //System.out.println(data);     返回得是ASCII码，需要进行强制转换
            System.out.print((char)data);
        }
        System.out.println();*/
        //2.2   一次性读取多个字节
        //学渣法
        /*byte[] buf = new byte[3];
        int count = fis.read(buf);  //把流里的字节读取出来，放进字节数组buf当中去
        System.out.println(new String(buf));
        System.out.println(count);

        int count2= fis.read(buf);
        System.out.println(new String(buf,0,count2));
        System.out.println(count2);*/
        //学霸法
        byte[] buf = new byte[3];
        int count = 0;
        while ((count= fis.read(buf))!=-1){//返回读取元素的个数
            System.out.println(new String(buf,0,count));    //表示字符串buf的从下标0到下标count的元素
        }

        //3.    关闭
        fis.close();
        System.out.println("执行完毕");
    }
}
结果：
abc
de
执行完毕

FunnyTime：文件读完之后没有可读取内容，返回了-1

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XqwON7dB-1661861178480)(C:\Users\86156\AppData\Roaming\Typora\typora-user-images\image-20220523031407935.png)]$

FileOutputStream

package com.qf.chap15_1;

import java.io.FileOutputStream;

public class Demo02 {
    public static void main(String[] args) throws Exception{
        //1.    创建文件字节输出流对象
        FileOutputStream fos = new FileOutputStream("d:\\bbb.txt",true); //同样抛出异常
        //2.    写入文件(不需要自己提前在D盘创建文件)
        fos.write(97);
        fos.write('b');
        fos.write('c');              //结果为abc
        String string = "helloworld";
        fos.write(string.getBytes());   //获取该字符串对应的字符数组 结果为abchelloworld
        //当创建流时添加"true"，就不会清空，没执行一次就会写入一次，执行两次之后结果为：abchelloworldhelloworld
        //3.    关闭
        fos.close();
        System.out.println("执行完毕");

    }
}
结果：
执行完毕

字节流复制文件

基本思想：输入流+输出流

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AlwuiU8t-1661861178480)(C:\Users\86156\AppData\Roaming\Typora\typora-user-images\image-20220523034659078.png)]$

package com.qf.chap15_1;

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

public class Demo03 {
    public static void main(String[] args) throws Exception{
        //1.    创建输入流(提前保存图片)
        FileInputStream fis = new FileInputStream("d:\\点赞.png");	
        //2.    创建输出流
        FileOutputStream fos = new FileOutputStream("d:\\002.png");
        //3.    一边读，一边写
        byte[] buf = new byte[1024];
        int count = 0;  //保存实际读取的字节个数
        while ((count = fis.read(buf))!=-1){
            fos.write(buf,0,count);
        }
        //4.    关闭流
        fis.close();
        fos.close();
        System.out.println("复制完毕");

    }
}
结果：
复制完毕	(相应位置有相同的照片)

字节缓冲流

缓冲流：

提高IO效率，减少访问磁盘次数
数据存储在缓冲区当中，flush是将缓存区的内容写入文件中，也可以直接close

输出文件数据：

package com.qf.chap15_1;

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

public class Demo04 {
    public static void main(String[] args) throws Exception {
        //1.    创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);    //实例化缓冲流时需要传一个节点流(底层流)
        //2.    读取
        int data=0;
        while ((data=bis.read())!=-1){      // private static int DEFAULT_BUFFER_SIZE = 8192;
            System.out.print((char)data);
        }
        //当第二次读取的时候发现缓冲区有，就不会读取硬盘，效率也就很快

        //也可以自己创建一个缓冲区
        byte[] buf = new byte[1024];
        int count = 0;
        while ((count=bis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3.    关闭  关闭bis也就可以关闭fis了
        bis.close();
    }
}
结果：
abcdefgabcdefgabcdefgabcdefgabcdefgabcdefgabcdefgabcdefgabcdefgabcdefg

在文件中写入数据：

package com.qf.chap15_1;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

public class Demo05 {
    public static void main(String[] args) throws Exception{
        //1.    创建字节输出缓冲流
        FileOutputStream fos = new FileOutputStream("d:\\buffer.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //2.    写入文件
        for (int i=0;i<10;i++){
            bos.write("helloworld\n".getBytes()); //getBytes()：返回一个字节数组   写入容量为8k的缓冲区了
            bos.flush();    //刷新了硬盘 这样才能在文档中看到输出
        }
        //3.    关闭(内部会调用flush方法)
        bos.close();
    }
}

对象流

包括ObjectOutputStream/ObjectInputStream

增强了缓冲区功能
增强了读写8种基本数据类型和字符串功能
增强了读写对象的功能
- writeObject(Object obj) 向流中写入一个对象：序列化
- readObject() 从流中读取一个对象：反序列化

使用ObjectOutputStream实现对象的序列化：

要求：序列化的类必须实现Serializable接口

先创建Student类：

package com.qf.chap15_1;

import java.io.Serializable;

public class Student implements Serializable {  //标记一下这个Student类可以序列化
    private String name;
    private int age;
    //无参构造
    public Student() {
    }
    //带参构造
    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }
    //getter and setter
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

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

测试范例：

package com.qf.chap15_1;

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

public class Demo06 {
    public static void main(String[] args) throws Exception{
        //1.    创建对象流
        FileOutputStream fos = new FileOutputStream("d:\\stu.bin"); //二进制文件
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //2.    实现序列化/写入操作
        Student zhangsan = new Student(20,"张三");
        Student lisi = new Student(22,"李四");
        ArrayList<Student> list = new ArrayList<>();
        list.add(zhangsan);
        list.add(lisi);
        oos.writeObject(lisi);
        //3.    关闭
        oos.close();
        System.out.println("序列化完毕");
    }
}
结果：
序列化完毕

反序列化

package com.qf.chap15_1;

import java.io.FileInputStream;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

public class Demo07 {
    public static void main(String[] args) throws Exception{
        //1.    创建对象流
        FileInputStream fis = new FileInputStream("d:\\stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        //2.    读取文件(反序列化)
        //Student s = (Student) ois.readObject();
        //Student s2 = (Student) ois.readObject();
        Object list = ois.readObject();
        ArrayList<Student> list1 = (ArrayList<Student>) list;
        //Student s2 = (Student) ois.readObject(); 第二次读取时会出现异常EOFException
        //3.    关闭
        ois.close();
        System.out.println("执行完毕");
        System.out.println(list.toString());

    }
}
结果：
Exception in thread "main" java.lang.ClassCastException: com.qf.chap15_1.Student cannot be cast to java.util.ArrayList
	at com.qf.chap15_1.Demo07.main(Demo07.java:18)

总结序列化和反序列化注意事项

序列化类中必须要实现Serializable接口
序列化类中对象属性要求实现Serializable接口
serialVersionUID/序列化版本号ID一样，可以保证序列化的类和反序列化的类是同一个类
使用transient(瞬间的)修饰属性，该属性就不可以序列化了
静态属性不可以序列化/不能保存到硬盘上
借助集合，序列化多个对象

字节流

字符编码

ISO-8859-1：收录出ASCII外多国的文字符号，只有一个字节，最多只能表示256个字符
UTF-8：针对Unicode码表的可变长度字符编码(1~3B)
GB2312:简体中文
GBK:简体中文、扩充
BIG5：台湾，繁体中文

当编码方式和解码方式不一样时会出现乱码，举例：

package com.qf.chap15_2;

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

public class Demo01 {
    public static void main(String[] args) throws Exception {
        //1.    创建FileInputStream对象
        FileInputStream fis = new FileInputStream("d:\\hello.txt");
        //2.    读取
        int data = 0;
        while((data=fis.read())!=-1){   //一次性读取一个字符
            System.out.println((char)data);
        }
        //3.    关闭
        fis.close();
    }
}

当hello.txt中是英文时可以正常输出，但是当改成汉语时会出现乱码。

因为.txt是UTF-8编码，如图所示：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wZ96sPuZ-1661861178482)(C:\Users\86156\AppData\Roaming\Typora\typora-user-images\image-20220605174750915.png)]$

由于每个汉字是3B，而读取时是一个字节一个字节读取的，进行了拆分，所以出现了问题。所以要是用字符流读取含有中文文件。

字符流

字符流的父类(抽象类)：

Reader：字符输入流
Writer：字符输出流

文件字符流

FileReader

package com.qf.chap15_2;

import java.io.FileReader;

public class Demo02 {
    public static void main(String[] args) throws Exception{
        //1.    创建FileReader 文件字符输入流
        FileReader fr = new FileReader("d:\\hello.txt");
        //2.    读取
        //2.1   单个字符读取
        //int data = 0;
        //while ((data=fr.read())!=-1){   //读取一个字符(3个B)
        //    System.out.println((char)data);
        //}
        //2.2   创建字符缓冲区
        char[] buf = new char[2];   
        int count = 0;
        while ((count= fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));   //通过new字符串来打印字符数组
        }
        //3.    关闭
        fr.close();
    }
}
结果:
按时
上课

FileWriter

package com.qf.chap15_2;

import java.io.FileWriter;

public class Demo03 {
    public static void main(String[] args) throws Exception{
        //1.    创建FileWriter对象
        FileWriter fw = new FileWriter("d:\\write.txt");
        //2.    写入
        for (int i=0;i<10;i++){
            fw.write("java\r\n"); //换行
            fw.flush();
        }
        //3.    关闭
        fw.close();
        System.out.println("执行完毕");
    }
}
结果：
执行完毕

使用字符流复制文本文件

图片等其他二进制文件无法复制(图片没有字符编码，两次转换之后就发生错误)

package com.qf.chap15_2;

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

public class Demo04 {
    public static void main(String[] args) throws Exception{
        //1.    创建FileReader和FileWriter
        FileReader fr = new FileReader("d:\\write.txt");
        FileWriter fw = new FileWriter("d:\\write2.txt");
        //2.     读写
        int data = 0;
        while ((data=fr.read())!=-1){
            fw.write(data);
            fw.flush(); //刷新缓冲区
        }
        //3.    关闭
        fr.close();
        fw.close();
        System.out.println("复制完毕");
    }
}
结果：
复制完毕

字符缓冲流

特点：

高效读写
支持输入换行符
可一次写一行、读一行

分类：

BufferedReader

package com.qf.chap15_2;

import java.io.BufferedReader;
import java.io.FileReader;
import java.nio.Buffer;

public class Demo05 {
    public static void main(String[] args) throws Exception{
        //1.    创建缓冲流
        FileReader fr = new FileReader("d:\\write.txt");
        BufferedReader br = new BufferedReader(fr);
        //2.    读取
        //2.1   第一种方式
//        char[] buf = new char[1024];
//        int count = 0;
//        while ((count=br.read(buf))!=-1){
//            System.out.println(new String(buf,0,count));
//        }
        //2.2   第二种方式，一行一行的读取
        String line = null;
        while ((line=br.readLine())!=null){
            System.out.println(line);
        }
        //3.    关闭
        br.close(); //fr也就关闭了
    }
}
结果：
java
java
java
java
java
java
java
java
java
java

BufferedWriter

package com.qf.chap15_2;

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

public class Demo06 {
    public static void main(String[] args) throws Exception{
        //1.    创建BufferWriter对象
        FileWriter fw = new FileWriter("d:\\buffer.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        //2.    写入
        for (int i = 0; i < 10; i++) {
            bw.write("好好学习");
            bw.newLine();   //写入一个换行符 = /r/n
            bw.flush();
        }
        //3.    关闭
        bw.close();
        System.out.println("执行完毕");
    }
}
结果：
执行完毕

打印流

PrintWriter:

封装了print()/println()方法，支持写入后换行
支持数据原样打印

package com.qf.chap15_2;

import java.io.PrintWriter;

public class Demo07 {
    public static void main(String[] args) throws Exception{
        //1.    创建打印流
        PrintWriter pw = new PrintWriter("d:\\print.txt");
        //2.    打印
        pw.println(97);		//结果就是97，不会变成a
        pw.println(true);
        pw.println(3.14);
        pw.println('a');
        //3.    关闭
        pw.close();
        System.out.println("执行完毕");
    }
}
结果：
执行完毕

转换流

特点：

可将字节转换为字符流
可设置字符的编码方式

分类：

InputStreamReader

是硬盘到内存/字节到字符的桥梁

package com.qf.chap15_3;

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

public class Demo01 {
    public static void main(String[] args) throws Exception{
        //1.    创建InputStreamReader对象
        FileInputStream fis = new FileInputStream("d:\\write.txt");
        //InputStreamReader isr = new InputStreamReader(fis,"utf-8"); //编码相同时结果正常
        InputStreamReader isr = new InputStreamReader(fis,"gbk");   //结果出现乱码
        //2.    读取文件
        int data = 0;
        while ((data=isr.read())!=-1){
            System.out.println((char)data);
        }
        //3.    关闭
        isr.close();
    }
}

OutputStreamWriter

package com.qf.chap15_3;

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

public class Demo02 {
    public static void main(String[] args) throws Exception{
        //1.    创建OutputStreamWriter
        FileOutputStream fos = new FileOutputStream("d:\\info.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
        //2.    写入
        for (int i = 0; i < 10; i++) {
            osw.write("我爱吃菠萝\r\n");
            osw.flush();
        }
        //3.    关闭
        osw.close();
        System.out.println("执行成功");
    }
}
结果：
执行成功

File类

概念：代表物理盘中的一个文件或者文件夹

文件操作和文件夹操作范例

package com.qf.chap15_4;

import javax.xml.crypto.Data;
import java.io.File;
import java.util.Date;

public class Demo01 {
    public static void main(String[] args) throws Exception {
        separator();
        fileOpe();
        directoryOpe();
    }
    //1.    分隔符
    public static void separator(){
        System.out.println("路径分隔符"+ File.pathSeparator);
        System.out.println("名称分隔符"+File.separator);
    }
    //2.    文件操作
    public static void fileOpe() throws Exception{
        //① 创建文件
        File file = new File("d:\\file.txt");   //创建了文件对象，但是文件是不存在的
        System.out.println(file);
        if(!file.exists()) {
            boolean b = file.createNewFile();
            System.out.println("创建结果：" + b);                  //生成文件
        }
        //② 删除文件
        //直接删除
        //System.out.println("删除结果："+file.delete());
        //使用jvm退出时删除
        //file.deleteOnExit();
        //Thread.sleep(5000); //休眠5s之后，jvm退出时就会删除文件
        //③ 获取文件信息
        System.out.println("获取文件的绝对路径"+file.getAbsolutePath()); //如果创建文件时没有d:\\，就会在该项目下进行创建
        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());
        //4.    判断
        System.out.println("是否可写"+file.canWrite()); //右键文件→属性→只读
        System.out.println("是否是文件"+file.isFile());  //区别是文件还是文件夹
        System.out.println("是否隐藏"+file.isHidden()); //右键文件→属性→隐藏
    }
    //3.    文件夹操作
    public static void directoryOpe() throws Exception{
        //① 创建文件夹
        File dir = new File("d:\\aaa\\bbb\\ccc");
        System.out.println(dir);
        if(!dir.exists()){
            //dir.mkdir();   只能创建单极目录
            System.out.println("创建结果："+dir.mkdirs()); //创建多级目录
        }
        //② 删除文件
        //直接删除  要求：只能删除最下级文件夹，并且该文件夹为空
        //System.out.println("删除结果："+dir.delete());
        //使用jvm删除
        //dir.deleteOnExit();
        //Thread.sleep(5000);     //比较有趣的是，如果重复执行jvm删除，ccc文件夹会出现然后被删除
        //③ 获取文件夹信息
        System.out.println("获取绝对路径："+dir.getAbsolutePath());
        System.out.println("获取路径:"+dir.getPath());
        System.out.println("获取文件夹名称:"+dir.getName());
        System.out.println("获取父目录："+dir.getParent());
        System.out.println("获取创建时间："+new Date(dir.lastModified()).toLocaleString());
        //④ 判断
        System.out.println("是否是文件夹："+dir.isDirectory());
        System.out.println("是否是隐藏："+dir.isHidden());
        //⑤ 遍历文件夹
        File dir2 = new File("d:\\图片");
        String[] files = dir2.list();   //用dir2.list()获得一个字符串类型的数组
        System.out.println("-----------------------");
        for (String file : files) {         //对该数组进行遍历
            System.out.println(file);
        }
    }
}
结果
路径分隔符;
名称分隔符\
d:\file.txt
获取文件的绝对路径d:\file.txt
获取路径d:\file.txt
获取文件名称file.txt
获取父目录d:\
获取文件长度11
文件的创建时间2022-6-5 20:30:40
是否可写false
是否是文件true
是否隐藏true
d:\aaa\bbb\ccc
获取绝对路径：d:\aaa\bbb\ccc
获取路径:d:\aaa\bbb\ccc
获取文件夹名称:ccc
获取父目录：d:\aaa\bbb
获取创建时间：2022-6-6 9:12:39
是否是文件夹：true
是否是隐藏：false
-----------------------
微信图片_20220606091639.png

FileFilter接口

当调用File类中的listFiles()方法时，支持传入FileFilter接口实现类，对获取文件进行过滤，只有满足条件的文件才能出现在listFiles()的返回值中

File[] files2 = dir2.listFiles(new FileFilter() {   //使用匿名内部类的方法进行传递
    @Override
    public boolean accept(File pathname) {
        //添加筛选条件    只要jpg文件
        if(pathname.getName().endsWith(".jpg")) {
            return true;
        }
        return false;
    }
});
for (File file : files2) {
    System.out.println(file.getName());
}

递归遍历文件夹和递归删除文件夹

package com.qf.chap15_4;

import java.io.File;

public class ListDemo {
    public static void main(String[] args) {
        System.out.println("----递归遍历文件夹----");
        lisDir(new File("d:\\myfiles"));
        System.out.println("----递归删除文件夹----");
        deleteDir(new File("d:\\myfiles"));
    }
    //1.    递归遍历文件夹
    public static void lisDir(File dir){
        File[] files = dir.listFiles();
        System.out.println(dir.getAbsolutePath());
        if(files!=null&&files.length>0){
            for (File file : files) {
                //如果file还是文件夹，就将其传递给lisDir进行递归
                if(file.isDirectory()){
                    lisDir(file);
                }
                else {
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }
    //2.    递归删除文件夹
    public static void deleteDir(File dir){
        File[] files = dir.listFiles();
        if(files!=null && files.length>0){
            for (File file : files) {
                if(file.isDirectory()){
                    deleteDir(file);    //递归
                }
                else {
                    //删除文件，但是文件夹没有删除
                    System.out.println(file.getAbsolutePath()+"删除："+file.delete());
                }
            }
        }
        //再删除文件夹
        System.out.println(dir.getAbsolutePath()+"删除："+dir.delete());
    }
}
结果：
----递归遍历文件夹----
d:\myfiles
d:\myfiles\新建XLSX工作表.xlsx
d:\myfiles\新建文件夹
d:\myfiles\新建文件夹\新建PPT演示文稿.ppt
d:\myfiles\新建文件夹\新建文本文档.txt
d:\myfiles\新建文件夹 (2)
d:\myfiles\新建文件夹 (2)\新建DOC文档.docx
d:\myfiles\新建文件夹 (2)\新建文本文档.txt
d:\myfiles\新建文本文档.txt
----递归删除文件夹----
d:\myfiles\新建XLSX工作表.xlsx删除：true
d:\myfiles\新建文件夹\新建PPT演示文稿.ppt删除：true
d:\myfiles\新建文件夹\新建文本文档.txt删除：true
d:\myfiles\新建文件夹删除：true
d:\myfiles\新建文件夹 (2)\新建DOC文档.docx删除：true
d:\myfiles\新建文件夹 (2)\新建文本文档.txt删除：true
d:\myfiles\新建文件夹 (2)删除：true
d:\myfiles\新建文本文档.txt删除：true
d:\myfiles删除：true

集合补充：Properties

是属性集合，继承了HashTable，线程安全

特点:

可以存储属性名和属性值(键值对)
属性名和属性值都是字符串类型
没有泛型
和流有关

范例：

package com.qf.chap15_4;

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

public class Demo02 {
    public static void main(String[] args) throws Exception{
        //1.    创建集合
        Properties properties = new Properties();
        //2.    添加数据
        properties.setProperty("username","张三");
        properties.setProperty("age","20");
        System.out.println(properties.toString());
        //3.    遍历
        //3.1   keyset
        //3.2   entryset
        //3.3   stringPropertyNames()
        Set<String> pronames = properties.stringPropertyNames();
        for (String proname : pronames) {
            System.out.println(proname+"========"+properties.getProperty(proname));
        }
        //4.    和流有关的方法
        //①----list----
        //PrintWriter pw = new PrintWriter("d:\\print.txt");
        //properties.list(pw);
        //pw.close(); //结果打印在print.txt当中
        //②----store----
        //FileOutputStream fos = new FileOutputStream("d:\\store.properties");
        //properties.store(fos,"注释");
        //fos.close();
        //③----load----
        Properties properties2 = new Properties();
        FileInputStream fis = new FileInputStream("d:\\store.properties");
        properties2.load(fis);
        fis.close();
        System.out.println(properties2);
    }
}
结果：
{age=20, username=张三}
age========20
username========张三
{age=20, username=张三}