Java学习之路9——I/O流框架

一、什么是流

概念：内存与存储设备之间传输数据的通道，内存与磁盘之间的数据交互需要通过流来进行数据传输。

二、流的分类

• 按方向【重点】：

  • 输入流：将<存储设备>中的内容读入到<内存>中。
  • 输入流：将<内存>中的内容写入到<存储设备>中。

• 按单位：

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

• 按功能：

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

三、字节流的抽象类

1、字节流的父类(抽象类):

• InputStream:字节输入流
• OutputStream:字节输出流

2、文件字节流

• FileInputStream：
  • public int read(byte[] b)//从流中读取多个字节，将读到内容存入b数组，返回实际读到的字节数;如果达到文件的尾部，则返回-1。
• FileOutputStream:
  • public void write(byte[] b)//一次写多个字节，将b数组中所有字节，写入输出流。

2.1、FileInputStream基本使用

package com.jjl.IO;
/*
文件字节输入流
 */
import java.io.FileInputStream;
import java.io.IOException;

public class Demo01 {
    public static void main(String[] args) throws IOException {
       test1();
       test2();
       test3();
       System.out.println("运行结束");
    }

    public static void test1() throws IOException {
        //1创建FileInputStream,并指定文件路径
        FileInputStream fis=new FileInputStream("E:\\study_file\\Java\\demo\\IOTest\\test.txt");
        //读取文件
        //第一种读取方式：用read一个字节一个字节的读，效率慢
        System.out.println("用read一个字节一个字节的读，效率慢");
        int data=0;
        while ((data=fis.read())!=-1){
            System.out.println((char)data);
        }
        fis.close();
    }
    public static void test2() throws IOException {
        //1创建FileInputStream,并指定文件路径
        FileInputStream fis=new FileInputStream("E:\\study_file\\Java\\demo\\IOTest\\test.txt");
        //读取文件
        //第二种读取方式：将读字节放在数组里面，一次读指定个数的字节。
        System.out.println("\n将读字节放在数组里面，一次读指定个数的字节");
        byte[] buf=new byte[3];
        int count=fis.read(buf);
        System.out.println(count);
        System.out.println(new String(buf));

        int count1=fis.read(buf);
        System.out.println(count1);
        System.out.println(new String(buf));

        int count2=fis.read(buf);
        System.out.println(count2);
        System.out.println(new String(buf,0,count2));
        fis.close();
    }
    public static void test3() throws IOException {
        //1创建FileInputStream,并指定文件路径
        FileInputStream fis=new FileInputStream("E:\\study_file\\Java\\demo\\IOTest\\test.txt");
        //读取文件
        //第二种读取方式：将读字节放在数组里面，一次读指定个数的字节，并循环输出全部字节。
        System.out.println("\n将读字节放在数组里面，一次读指定个数的字节，并循环输出全部字节");
        byte[] buf=new byte[3];
        int count3=0;
        while ((count3=fis.read(buf))!=-1){
            System.out.println(new String(buf,0,count3));
        }
        //关闭
        fis.close();
    }
}
输出：
用read一个字节一个字节的读，效率慢
a
b
c
d
e
f
g

将读字节放在数组里面，一次读指定个数的字节
3
abc
3
def
1
g

将读字节放在数组里面，一次读指定个数的字节，并循环输出全部字节
abc
def
g
运行结束

2.2、FileOutputsystem的基本使用

package com.jjl.IO;
import java.io.FileOutputStream;
import java.io.IOException;
/*
FileOutputStream
 */
public class Demo02 {
    public static void main(String[] args) throws IOException {
        test1();
    }
    public static void test1() throws IOException {
        //1创建文件字节输出流对象，指定好文件路径和文件名，Java会自动创建好文件
        FileOutputStream fos=new FileOutputStream("E:\\study_file\\Java\\demo\\IOTest\\test1.txt",true);//加上true，则就不会覆盖文件中原有的数据，而是接着原始数据后面输入。
        //写入文件
        //写入单个字节
        fos.write(97);//就是a的字符编码
        fos.write('b');
        fos.write('c');
        //写入字符串
        String string="\nhello word!";
        fos.write(string.getBytes());
        //关闭
        fos.close();
        System.out.println("执行完毕");
    }
}

运行三次后的结果：（第三次运行时在“hello word！”前面加上了换行。）
abchello word!abchello word!abc
hello word!

2.3、使用文件字节流复制图片文件

package com.jjl.IO;
/*
使用文件字节流，实现图片文件复制
 */
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo03 {
    public static void main(String[] args) throws IOException {
        test1();
    }
    public static void test1() throws IOException {
        //1.文件字节输入流
        FileInputStream fis= new FileInputStream("E:\\study_file\\Java\\demo\\IOTest\\test.jpg");
        //2.文件字节输出流
        FileOutputStream fos= new FileOutputStream("E:\\study_file\\Java\\demo\\IOTest\\test1.jpg");
        //3.一边读、一边写
        byte[] buf=new byte[1024];
        int count=0;
        while ((count=fis.read(buf))!=-1){
            fos.write(buf,0,count);
        }
        //3、关闭
        fis.close();
        fos.close();
        System.out.println("复制完成");
    }
}

3、字节缓冲流

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

3.1、BufferedInputStream基本使用

package com.jjl.IO;
/*
使用字节缓冲流读取
 */

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

public class Demo04 {
    public static void main(String[] args) throws IOException {
        text1();
    }
    public static void text1() throws IOException {
        //1创建Bu
        FileInputStream fis=new FileInputStream("E:\\study_file\\Java\\demo\\IOTest\\test.txt");
        BufferedInputStream bis=new BufferedInputStream(fis);
        //2读取
        //实用于小文件
//        int data=0;
//        while ((data=bis.read())!=-1){
//            System.out.println((char) data);
//        }

        //适用于大文件（效率快）
        byte[] buf=new byte[1024];
        int count=0;
        while ((count=bis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //关闭
        bis.close();
    }
}

BufferedOutputStream的基本使用

package com.jjl.IO;

import java.io.*;

/*
使用字节缓冲流写入文件
 */
public class Demo05 {
    public static void main(String[] args) throws IOException {
        test();
    }
    public static void test() throws IOException {
        //1创建字节输出缓冲流
        FileOutputStream fos=new FileOutputStream("E:\\study_file\\Java\\demo\\IOTest\\test2.txt");
        BufferedOutputStream bos=new BufferedOutputStream(fos);

        //1写入文件
        for(int i=0;i<5000;i++){
            bos.write("hello Word!".getBytes());//当字节没有超过8k时，都写入到了缓冲区
            bos.flush();//刷新到磁盘文件
        }
        //关闭（内部会调用flush方法）
        bos.close();
    }
}

四、对象流

• 对象流：ObjectOutputStream/ObjectInputStream。
  • 增强了缓冲区功能
  • 增强了读写8种基本数据类型和字符串功能
  • 增强了读写对象的功能:
    • readObject()从流中读取一个对象
    • write0bject(Object obj)向流中写入一个对象

使用流传输对象的过程称为序列化、反序列化。

1、ObjectOutputStream序列化的基本使用

package com.jjl.IO;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

/*
使用ObjectOutputStream实现对象的序列化
要求：
（1）序列化类必须实现Serializable接口
（2）序列化类中对象属性要求实现Serializable接口
（3）序列号版本号ID，保证序列化的类和反序列化的类是同一个类
（4）使用transient修饰属性，这个属性就不能序列化
（5）静态属性也不能序列化
（6)序列化多个对象,可以借助集合实现
 */
public class Demo06 {
    public static void main(String[] args) throws IOException {
        test();
    }
    public static void test() throws IOException {
        //1创建对象流
        FileOutputStream fos=new FileOutputStream("E:\\study_file\\Java\\demo\\IOTest\\test.bin");
        ObjectOutputStream oos=new ObjectOutputStream(fos);
        //2序列化（单个）
        Student zhangsan=new Student("张三",20);
        Student lisi=new Student("李四",22);
        Student liwu=new Student("李wu",25);
        Student liliu=new Student("李六",25);
        Student liba=new Student("李七",29);
        oos.writeObject(zhangsan);
        oos.writeObject(lisi);
        //序列化（批量）
        ArrayList<Student> list=new ArrayList<>();
        list.add(liwu);
        list.add(liliu);
        list.add(liba);
        oos.writeObject(list);
        //3关闭
        oos.close();
        System.out.println("序列化完成");
    }
}

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

2、ObjectInputStream实现反序列化（读取构造成对象）

package com.jjl.IO;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;

/*
使用ObjectInputStream实现反序列化（读取构造成对象）
 */
public class Demo07 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        test();
    }
    public static void test() throws IOException, ClassNotFoundException {
        //创建对象流
        FileInputStream fis=new FileInputStream("E:\\study_file\\Java\\demo\\IOTest\\test.bin");
        ObjectInputStream ios=new ObjectInputStream(fis);
        //2读取文件（反序列化）
        Student s=(Student) ios.readObject();
        Student s1=(Student) ios.readObject();
        ArrayList<Student> list= (ArrayList<Student>) ios.readObject();
        //关闭
        ios.close();
        System.out.println("执行完毕");
        System.out.println(s.toString());
        System.out.println(s1.toString());
        System.out.println(list.toString());
    }
}

输出：
执行完毕
Student{name='张三', age=20}
Student{name='李四', age=22}
[Student{name='李wu', age=25}, Student{name='李六', age=25}, Student{name='李七', age=29}]

五、字符流

1、字符编码

字符编码	说明
ISO-8859-1	收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。
UTF-8	针对Unicode码表的可变长度字符编码
GB2312	简体中文
GBK	简体中文、扩充
BIG5	台湾，繁体中文

2、案例

字节流的弊端

package com.jjl.IO;
import java.io.FileInputStream;
import java.io.IOException;

public class Demo08 {
    public static void main(String[] args) throws IOException {
        test();
    }
    public static void test() throws IOException {
        //1创建一个对象
        FileInputStream fis=new FileInputStream("E:\\study_file\\Java\\demo\\IOTest\\hello.txt");
        int data=0;
        while ((data= fis.read())!=-1){//用这个方式无法读取中文，因为它是一个字节一个字节读取的，而一个中文占两个字节
            System.out.print((char) data);
        }
        fis.close();
    }
}
输出：
hello Word!hello Word!hello Word!å¥½å¥½å­¦ä¹ ï¼ï¼

字节流无法读取中文以及其他操过一个字节表示的字符，因为它是一个字节一个字节读取的，而一个中文和其他字符占两个以上字节

3、字符流的父类（抽象类）：

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

3.1、文件字符流

• FileReader:
  • public int read(char[] c)//从流中读取多个字符，将读到内容存入c数组，返回实际读到的字符数；如果达到文件的尾部，则返回-1。

package com.jjl.IO;
import java.io.FileReader;
import java.io.IOException;

public class Demo09 {
    public static void main(String[] args) throws IOException {
        System.out.println("单个字符读取");
        test();
        System.out.println("\n批量多字符读取");
        test1();
    }

    //一个字符一个字符的读
    public static void test() throws IOException {
        //创建FileReader 文件字符输入流
        FileReader fr = new FileReader("E:\\study_file\\Java\\demo\\IOTest\\hello.txt");
        //2读取
        //2.1单个字符读取
        int data = 0;
        while ((data = fr.read()) != -1) { //一个字符一个字符的读
            System.out.println((char) data);
        }
        //关闭
        fr.close();
    }

    public static void test1() throws IOException {
        //创建FileReader 文件字符输入流
        FileReader fr = new FileReader("E:\\study_file\\Java\\demo\\IOTest\\hello.txt");
        //创建字符缓冲区，读取全部内容
        char[] buf=new char[1024];
        int count=0;
        while ((count= fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        fr.close();
    }
}
输出：
单个字符读取
h
e
l
l
o
！
好
好
学
习
！
！

批量多字符读取
hello！好好学习！！

• FileWriter:
  • public void write(String str)//一次写多个字符，将b数组中所有字符，写入输出流。

package com.jjl.IO;

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

public class Demo10 {
    public static void main(String[] args) throws IOException {
       test();
    }
    public static void test() throws IOException {
        //创建Filewriter对象
        FileWriter fw=new FileWriter("E:\\study_file\\Java\\demo\\IOTest\\writer.txt",true);//true,不覆盖源文件内容
        //2写入
        for(int i=0;i<10;i++){
            fw.write("java是最好的语言\n");
            fw.flush();
        }
        //3关闭
        fw.close();
        System.out.println("执行结束");
    }
}

4、字符流复制文件

注意：

• 使用filereader和filewriter复制文本文件，不能复制图片或二进制文件
• 使用字节流可以复制任何文件

package com.jjl.IO;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
使用filereader和filewriter复制文本文件，不能复制图片或二进制文件
使用字节流可以复制任何文件
 */
public class Demo11 {
    public static void main(String[] args) throws IOException {
        test();
    }
    public static void test() throws IOException {
        //创建filereader和filewriter流
        FileReader fr=new FileReader("E:\\study_file\\Java\\demo\\IOTest\\writer.txt");
        FileWriter fw=new FileWriter("E:\\study_file\\Java\\demo\\IOTest\\writer1.txt");
        //读写
        int data=0;
        while ((data=fr.read())!=-1){
            fw.write(data);
            fw.flush();
        }
        fw.close();
        fr.close();
    }
}

5、字符缓冲流

• 缓冲流:BufferedReader/BufferedWriter。高效读写
  • 支持输入换行符。
  • 可一次写一行、读贷行。

5.1、BufferedReader的基本使用

package com.jjl.IO;
import java.io.BufferedReader;
import java.io.FileReader;

/*
使用字符缓冲流读取文件
BuferedReader
 */
public class Demo12 {
    public static void main(String[] args) throws Exception {
        System.out.println("按字符读取");
        test();
        System.out.println("按行读取");
        test1();
    }

    //第一种读取方式
    public static void test() throws Exception{
        //1创建缓冲流
        FileReader fr=new FileReader("E:\\study_file\\Java\\demo\\IOTest\\writer.txt");
        BufferedReader br=new BufferedReader(fr);
        //2读取
        //创建缓冲区
        char[] buf=new char[1024];
        int count=0;
        while ((count= br.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        br.close();
    }

    //第二种读取方式，按行读
    public static void test1() throws Exception{
        //1创建缓冲流
        FileReader fr=new FileReader("E:\\study_file\\Java\\demo\\IOTest\\writer.txt");
        BufferedReader br=new BufferedReader(fr);
        String line=null;
        while ((line=br.readLine())!=null){
            System.out.println(line);
        }
    }
}

5.2、BufferedWriter的基本使用

package com.jjl.IO;

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

public class Demo13 {
    public static void main(String[] args) throws Exception {
        test();
    }
    public static void test() throws Exception{
        //创建BufferedWrite对象
        FileWriter fw=new FileWriter("E:\\study_file\\Java\\demo\\IOTest\\Bwriter.txt");
        BufferedWriter bw=new BufferedWriter(fw);
        //写入
        for(int i=0;i<10;i++){
            bw.write("好好学习天天向上");
            bw.newLine();//换行，写入一个换行符
            bw.flush();
        }
        bw.close();
        System.out.println("run over!");
    }
}

六、打印流

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

package com.jjl.IO;
import java.io.PrintWriter;

public class Demo14 {
    public static void main(String[] args) throws Exception{
        test();
    }
    public static void test() throws Exception{
        //1创建打印流
        PrintWriter pw=new PrintWriter("E:\\study_file\\Java\\demo\\IOTest\\print.txt");
        pw.println(97);
        pw.println(true);
        pw.print(3.51);
        pw.print("sdf");
        pw.close();
        System.out.println("Run.over!");
    }
}

七、转换流

• 桥转换流:InputStreamReader/OutputStreamWriter。
  • 可将字节流转换为字符流。
  • 可设置字符的编码方式。

1、InputStreamReader的基本使用

package com.jjl.IO;

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

/*
使用InputStreamReader读取文件、指定使用的编码
 */
public class Demo15 {
    public static void main(String[] args) throws Exception{
        test();
    }
    public static void test() throws Exception{
        //创建InputStreamReader对象
        FileInputStream fis=new FileInputStream("E:\\study_file\\Java\\demo\\IOTest\\print.txt");
        InputStreamReader isr=new InputStreamReader(fis,"UTF-8");
        //2读取文件
        int data=0;
        while ((data=isr.read())!=-1){
            System.out.print((char)data);
        }
        //关闭
        isr.close();
    }
}

2、OutputStreamWriter的基本使用

package com.jjl.IO;

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

public class Demo16 {
    public static void main(String[] args) throws Exception {
        test();
    }
    public static void test() throws Exception{
        //1创建OutputStreamWriter
        FileOutputStream fos=new FileOutputStream("E:\\study_file\\Java\\demo\\IOTest\\print1.txt");
        OutputStreamWriter osw=new OutputStreamWriter(fos,"gbk");
        //2写入
        for(int i=0;i<10;i++){
            osw.write("中江挂面\n");
            osw.flush();
        }
        osw.close();
        System.out.println("run over!");
    }
}

八、File类

• 概念:代表物理盘符中的一个文件或者文件夹。
• 方法:

  方法名	说明
  createNewFile()	创建一个新文件
  mkdir()	创建一个新目录
  delete()	删除文件或空目录
  exists()	判断File对象所对象所代表的对象是否存在
  getAbsolutePath()	获取文件的绝对路径
  getName()	取得名字
  getParent()	获取文件/目录所在的目录。
  isDirectory ()	是否是目录
  isFile()	是否是文件
  length()	获得文件的长度
  listFiles()	列出目录中的所有内容
  renameTo()	修改文件名为

1、文件操作

package com.jjl.IO.File;

import java.io.File;
import java.io.IOException;
import java.util.Date;

/*
file类是的使用
（1）分隔符
（2）文件操作
（3）文件夹操作
 */
public class Demo01 {
    public static void main(String[] args) throws IOException, InterruptedException {
        test();
        fileDo();
    }
    //(分隔符)
    public static void test(){
        System.out.println("路径分隔符"+ File.pathSeparator);
        System.out.println("名称分隔符"+File.separator);
    }

    //文件操作
    public static void fileDo() throws IOException, InterruptedException {
        //1、创建文件
        File file=new File("E:\\study_file\\Java\\demo\\IOTest\\file_test1.txt");//创建对象
        if(!file.exists()){//判断文件是否存在
            boolean b=file.createNewFile();//创建文件
            System.out.println("创建结果："+b);
        }
        //2、删除文件
        //2.1直接删除
        System.out.println("删除结果："+file.delete());
        //2.2使用jvm退出时删除
        file.deleteOnExit();
        Thread.sleep(5000);//休眠5秒

        //3、获取文件信息
        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()));

        //4判断
        System.out.println("判读文件是否可写"+file.canWrite());
        System.out.println("判断是否是文件"+file.isFile());
        System.out.println("判断是否是隐藏"+file.isHidden());

    }
}

2、文件夹操作

package com.jjl.IO.File;

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

public class Demo02 {
    public static void main(String[] args) throws InterruptedException {
        directory();
    }
    public static void directory() throws InterruptedException {
        //1、创建文件夹
        File dir=new File("E:\\study_file\\Java\\demo\\IOTest\\directory_test");
        System.out.println(dir.toString());
        if(!dir.exists()){
            System.out.println("创建结果："+dir.mkdir());//只能创建单级目录
            //dir.mkdirs();//创建多级目录（递归创建）
        }
        //2、删除
        //2.1直接删除
        System.out.println("删除结果："+dir.delete());//只能删除空目录
        //2.2使用jvm退出时删除
        dir.deleteOnExit();
        Thread.sleep(5000);

        //获取文件夹信息
        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("E:\\study_file\\Java\\demo");
        String[] files=dir2.list();
        for (String string:files){
            System.out.println(string);
        }
    }
}

3、FileFilter接口，文件过滤器

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

package com.jjl.IO.File;
import java.io.File;
import java.io.FileFilter;
/*
筛选出目录下的图片文件
*/
public class Demo03 {
    public static void main(String[] args) {
        test();
    }
    public static void test(){
        File dir=new File("F:\\weicat\\WeChat Files\\wxid_flwgymfj3m6w22\\FileStorage\\Video\\2022-04");
        File[] files=dir.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if(pathname.getName().endsWith(".jpg")){
                    return true;
                }
                return false;
            }
        });
        for (File file:files){
            System.out.println(file.getName());
        }
    }
}

4、案例：

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

package com.jjl.IO.File;

import java.io.File;

/*
递归遍历文件夹
递归删除文件夹
 */
public class Demo04 {
    public static void main(String[] args) {
    	//遍历
        listDir( new File("E:\\study_file\\Java"));
        //删除
        delDir(new File("E:\\study_file\\Java\\demo\\IOTest\\directory_test"));
    }
    public static void listDir(File dir){
        File[] files=dir.listFiles();
        System.out.println(dir.getAbsolutePath());
        if(files!=null&&files.length>0){
            for (File file:files){
                if (file.isDirectory()){
                    listDir(file);//递归遍历
                }else {
                    System.out.println(file.getAbsoluteFile());
                }
            }
        }
    }

    public static void delDir(File dir){
        File[] files=dir.listFiles();
        //System.out.println(dir.getAbsolutePath());
        if(files!=null&&files.length>0){
            for (File file:files){
                if (file.isDirectory()){
                    delDir(file);
                }else {
                    //删除文件
                    file.delete();
                    }
            }
        }
        //删除文件夹
        dir.delete();
    }
}

九、Properties:属性集合

• 特点
  • 1、存储属性名和属性值
  • 2、属性名和属性值都是字符串类型
  • 3、没有泛型
  • 4、和流有关

package com.jjl.IO.Properties;
import java.io.*;
import java.util.Properties;
import java.util.Set;
import static java.lang.System.out;

public class Demo01 {
    public static void main(String[] args) throws IOException {
        test();
        test2();
    }
    public static void test() throws IOException {
        //1、创建集合
        Properties properties=new Properties();
        //2、添加数据
        properties.setProperty("username","zhangsan");
        properties.setProperty("age","20");
        out.println(properties);
        //3、遍历
        //3.1------keyset-----
        //3.2----entryset-----
        //3.3-----stringPropertyNames()-------
        Set<String> pronames=properties.stringPropertyNames();
        for (String pro:pronames){
            out.println(pro+":"+properties.getProperty(pro));
        }

        //4和流有关的方法
        //----------list方法-----------
        PrintWriter pw=new PrintWriter("E:\\study_file\\Java\\demo\\IOTest\\properties.txt");
        properties.list(pw);
        pw.close();

        //保存
        //-------store方法---------
        FileOutputStream fos=new FileOutputStream("E:\\study_file\\Java\\demo\\IOTest\\store.peroperties");
        properties.store(fos,"注释");
    }

    //加载
    public static void test2() throws IOException {
        //--------load方法-----
        Properties properties=new Properties();
        FileInputStream fis=new FileInputStream("E:\\study_file\\Java\\demo\\IOTest\\store.peroperties");
        properties.load(fis);
        fis.close();
        out.println(properties.toString());
    }
}

十、总结

• 流的概念:
  • 内存与存储设备之间传输数据的通道。
• 流的分类:
  • 输入流、输出流；字节流、字符流；节点流、过滤流；
• 序列化、反序列化
  • 将对象通过流写入到文件，或将对象通过流读取到内存，必须实现Serializable接口。
• File对象:
  • 代表物理盘符中的一个文件或者文件夹。