Java学习 第二十八章 IO概述 / 字节流 / 字符流 /IO异常的处理

第二十七章

一、IO

1.1 IO概述

二、字节流

2.1 一切皆为字节

2.2 OutputStream类和FileOutputStream类

java.io.OutputStream:此抽象类是表示输出字节流的所有类的超类

定义了一些子类共性的成员方法：
void close()  关闭此输出流并释放与此流有关的所有系统资源。
void flush()  刷新此输出流并强制写出所有缓冲的输出字节。
void write(byte[] b)   将 b.length 个字节从指定的 byte 数组写入此输出流。
void write(byte[] b, int off, int len)  将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
abstract  void write(int b)   将指定的字节写入此输出流。

FilterOutputStream extends OutputStream

FilterOutputStream:文件字节输出流
作用：把内存中的数据写入到硬盘的文件中
FileOutputStream(String name) 创建一个向具有指定名称的文件中写入数据的输出文件流
 FileOutputStream(File file) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
 参数： String name：目的地是一个文件的路径
        File file： 目的地是一个文件
 构造方法的作用：
        1.创建一个FileOutput对象
        2.会根据构造方法中传递的文件/文件路径，创建一个空的文件
        3.会把FileOutputStream对象指向创建好的文件

2.3 字节输出流写入数据到文件

写入数据的原理（内存–>硬盘）

java程序-->JVM（java虚拟机）-->os（操作系统）->OS调用写数据的方法-->把数据写入到文件中

字节输出流的使用步骤（重点）：

1.创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
2.调用FileOutputStream对象中的方法write，把数据写入到文件中
3.释放资源（流使用会占用一定内存，使用完毕要把内存清空，提高程序效率）

public class Demo01OutputStream {
    public static void main(String[] args) throws IOException {
        //    1.创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
        FileOutputStream fos = new FileOutputStream("Day16-code\\a.txt");
        // 2.调用FileOutputStream对象中的方法write，把数据写入到文件中
        // void write(int b) 将指定字节写入此文件输出流。
        fos.write(97);
       // 3.释放资源（流使用会占用一定内存，使用完毕要把内存清空，提高程序效率）
        fos.close();

    }

}

2.4 文件存储原理和记事本打开文件原理

2.5 字节输出流写多个字节的方法

一次写多个字节的方法：

 void write(byte[] b)   将 b.length 个字节从指定的 byte 数组写入此输出流。
 void write(byte[] b, int off, int len)  将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。

public class Demo02OutputStream {
    public static void main(String[] args) throws IOException {
        //    1.创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
        FileOutputStream fos = new FileOutputStream("Day16-code\\b.txt");
        // 2.调用FileOutputStream对象中的方法write，把数据写入到文件中
        // 在文件中显示100
      /*  fos.write(49);
        fos.write(48);
        fos.write(48);*/
      /*
       void write(byte[] b)   将 b.length 个字节从指定的 byte 数组写入此输出流。
       一次写多个字节：如果写的第一个字节是正数，那么显示的时候会查询ASCII表
                  ：如果写的第一个字节是负数，那么第一个字节和第二个字节组成一个中文显示，
                    查询系统默认码表（GBK）
       */
      byte[] bytes = {65,66,67,68,69};//ABCDE
     // byte[] bytes = {-65,-66,-67,-68,69};//烤郊E
      fos.write(bytes);
      /*
       void write(byte[] b, int off, int len)  把字节数组的一部分写入到文件中
       int  off：数组的开始索引
       int len ： 写几个字节

       */
      fos.write(bytes,1,2);//BC
/*
       写入字符的方法：可以使用String类中方法，把字符串，转换为字节数组
             byte[] getBytes()  把字符串转换为字节数组
 */
        byte[] bytes1 = "你好".getBytes();
        System.out.println(Arrays.toString(bytes1));//[-28, -67, -96, -27, -91, -67]
        fos.write(bytes1);

        //释放资源
        fos.close();


    }
}

2.6 字节输出流的续写和换行

追加/续写：使用两个参数的构造方法：

FileOutputStream(String name, boolean append)创建一个向具有指定 name 的文件中写入数据的输出文件流。
FileOutputStream(File file, boolean append) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
参数：
    String name，File file ：写入数据的目的地
    boolean append：追加开关，创建对象不会覆盖原文件，继续在末尾追加写数据。
    false：创建一个新文件，覆盖源文件。
写换行：写换行符号
    windows：\r  \n
    Linux: /n
    mac : /r

public class Demo03OutputStream {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("Day16-code\\c.txt",true);
        for (int i = 0; i < 10; i++) {
            fos.write("你好".getBytes());
            fos.write("\n".getBytes());
        }

        fos.close();

    }
}

2.7 字节输入流（InputStream）

InputStream类和FileInputStream类

java.io.InputStream此抽象类是表示字节输入流的所有类的超类。
       abstract  int read()从输入流中读取数据的下一个字节。
       int read(byte[] b)    从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中
       void close()   关闭此输入流并释放与该流关联的所有系统资源。

java.io.FileInputStream  extends InputStream
  FileInputStream:文件字节输入流
    作用：把硬盘中的数据，读取到内存当中
    构造方法:
       FileInputStream(String name)
        通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。
       FileInputStream(File file)
        通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
       参数：读取文件的数据源
       String name ：文件的路径
       File file： 文件
       构造方法的作用：
            1.会创建一个FileInputStream对象
            2.会把FileInputStream对象指向构造方法中要读取的文件。

2.8 字节输入流（InputStream）读取字节数据

读取数据的原理（硬盘–>内存）

    java程序-->JVM-->OS-->OS读取数据的方法-->读取文件

字节输入流的使用步骤（重点）：
1.创建FileInputStream对象，构造方法中绑定要读取的数据源
2.使用FileInputStream对象中的方法read，读取文件
3.释放资源

public class Demo01InputStream {
    public static void main(String[] args) throws IOException {
      // 1.创建FileInputStream对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("Day16-code\\b.txt");
        //2.使用FileInputStream对象中的方法read，读取文件
       /* int read = fis.read();
        System.out.println(read);//65 A
        int read1 = fis.read();
        System.out.println(read1);//66 B  如果读到最后没有值会显示-1*/
       /*
         读取文件是一个重复的过程，可以使用循环 ，不知道次数，使用while循环，读到-1结束
         布尔表达式(len = fis.read()) != -1
         1.fis.read()读取一个字节
         2.把读取到的字节赋值给len
         3.判断len是否等于-1
        */
        //【重点】用一个变量来接收值然后遍历
       int len = 0;//记录读取到的字节
       while((len = fis.read()) != -1){//读完后指针后移
             System.out.println(len);//65 66 67
           //System.out.println((char)len);//ABC

       }

        //  3.释放资源
        fis.close();
    }

}

2.9 字节输入流一次读取一个字节的原理

2.10 字节输入流一次读取多个字节

字节输入流一次读取多个字节的方法:

int read(byte[] b)    从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中
 明确两件事情：
     1.方法的参数byte[]的作用?
         起到缓冲的作用，存储每次读到的多个字节
         数组的长度一般定义为1024（1kb）或者是1024的整数倍
   2.方法的返回值int是什么？
         每次读取的字节数

String类的构造方法：

String（byte[] bytes）：把字节数组转换为字符串
String（byte[] bytes，int offset,int length）把字节数组的一部分转换为字符串
                   offset数组的开始索引。length转换的字节个数

public class Demo02InputStream {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("Day16-code\\b.txt");
        //使用FileInputStream对象中的read读取文件
        //    int read(byte[] b)    从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中
       /* byte[] bytes = new byte[2];
        int len = fis.read(bytes);
        System.out.println(len);//2
        //System.out.println(Arrays.toString(bytes));//[65, 66]

        // String类的构造方法：String（byte[] bytes）：把字节数组转换为字符串
        System.out.println(new String(bytes));//AB

        len = fis.read(bytes);
        System.out.println(len);//2 每次读取的字节个数
        // String类的构造方法：String（byte[] bytes）：把字节数组转换为字符串
        System.out.println(new String(bytes));//CD

        len = fis.read(bytes);
        System.out.println(len);//2 每次读取的字节个数
        // String类的构造方法：String（byte[] bytes）：把字节数组转换为字符串
        System.out.println(new String(bytes));// -1 CD*/

       /*
        使用while循环优化代码
        读到-1结束
        */
       byte[] bytes = new byte[1024];//存储读到的多个字节
        int len = 0;//记录每次读取的有效字节个数
       while ((len = fis.read(bytes)) != -1){
           //String（byte[] bytes，int offset,int length）把字节数组的一部分转换为字符串
           System.out.println(new String(bytes,0,len));
       }


        //释放资源
        fis.close();
    }
}

2.11 练习：文件复制

/*
    文件复制练习：一读一写
    明确：数据源：
          数据的目的地：
     文件复制的步骤：
           1.创建一个字节输入流对象，构造方法中绑定要读取的数据源
           2.创建一个字节输出流对象，构造方法中绑定要写入的目的地
           3.使用字节输入流的read读取文件
           4.使用字节输出流的write，把读取到的字节写入到目的地文件中
           5.释放资源
 */
public class Demo03Practice {
    public static void main(String[] args) throws IOException {
        long s = System.currentTimeMillis();
        //1.创建一个字节输入流对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("Day16-code\\b.txt");

         // 2.创建一个字节输出流对象，构造方法中绑定要写入的目的地
        FileOutputStream fos = new FileOutputStream("f:\\b.txt");
        //一次读取/写入一个字节
        //3.使用字节输入流的read读取文件
       /* int len = 0 ;
        while ((len = fis.read()) != -1){
            //4.使用字节输出流的write，把读取到的字节写入到目的地文件中
            fos.write(len);

        }*/
       //使用数组缓冲读取多个字节，写入多个字节
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = fis.read())!= -1){//len  每次读取的有效字节个数
            fos.write(bytes,0,len);
        }

        //5.释放资源（先关闭写的，后关闭读的，如果写完了，肯定读完了）
        fos.close();
        fis.close();
        long e = System.currentTimeMillis();
        System.out.println("复制文件共耗时"+ (e - s )+"毫秒");



    }
}

三、字符流

3.1 使用字节流读取中文的问题

/*
    使用字节流读取中文文件
    1个中文
        GBK：占用两个字节
        UTF-8：占用三个字节
 */
public class Demo04InputStream {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("Day16-code\\c.txt");
        int len = 0;
        while ((len = fis.read()) != -1){//一次读入一个数据，相当于一次读三分之一个中文，会乱码
            System.out.println(len);
        }
        fis.close();
    }
}

3.2 字符输入流 Reader类和FileReader类

java.io.Reader:字符输入流，是字符输入流最顶层的父类，定义了一些共性的成员方法，是一个抽象类
     共性的成员方法:
          int read() 读取单个字符。
          int read(char[] cbuf) 将字符读入数组。
          abstract  void close()  关闭该流并释放与之关联的所有资源。
java.io.FileReader extends InputStreamReader extends Reader
    FileReader:文件字符输入流
    作用：把硬盘文件中的数据以字符的方式读取到内存当中。
构造方法：
    FileReader(File file)      在给定从中读取数据的 File 的情况下创建一个新 FileReader。
    FileReader(String fileName)在给定从中读取数据的文件名的情况下创建一个新 FileReader。
    参数：读取文件的数据源
          String fileName：文件的路径
          File file：一个文件
    FileReader构造方法的作用:
        1.创建以恶搞FileReader对象
        2.会把FileReader对象指向要读的文件

3.3 字符输入流 读取字符数据

字符输入流使用步骤：

1.创建FileReader对象，构造方法中绑定要读取的数据源
2.使用FileReader对象中的方法read读取文件
3.释放资源

public class Demo01Reader {
    public static void main(String[] args) throws IOException {
    // 1.创建FileReader对象，构造方法中绑定要读取的数据源
        FileReader fr = new FileReader("Day16-code\\c.txt");
    //2.使用FileReader对象中的方法read读取文件 （读取单个）
       /* int len = 0;
        while ((len = fr.read())!= -1){
            System.out.print((char)len);//你好abc
    }*/
       /*
        String类的构造方法：
        String(char[] value)  ：把字符数组转换为字符串
        String(char[] value, int offset, int count) ：把字符数组的一部分转化为字符串
        offset 开始索引  count 个数
        */
       //一次读取多个字符
        char[] chars = new char[1024];
        int len = 0;//记录的是每次读取有效数据的个数
        while ((len = fr.read(chars))!= -1){
            System.out.println(new String(chars,0,len));
        }

    // 3.释放资源
        fr.close();

    }
}

3.3 字符输出流-Writer类和FileWriter类

java.io.Writer:字符输出流，是所有字符输出流的最顶层的父类，是一个抽象类
   共性的成员方法：
    abstract  void close()
          关闭此流，但要先刷新它。
    abstract  void flush()
          刷新该流的缓冲。
    void write(char[] cbuf)
          写入字符数组。
    abstract  void write(char[] cbuf, int off, int len)
          写入字符数组的某一部分。
    void write(int c)
          写入单个字符。
    void write(String str)
          写入字符串。
    void write(String str, int off, int len)
          写入字符串的某一部分。


java.io.FileWriter extends OutputStreamWriter extends Writer
   FileWriter:文件输出流
   作用：把内存中的字符数据写入到文件中

   构造方法:
         FileWriter(String fileName) :根据给定的文件名构造一个 FileWriter 对象。
         FileWriter(File file):  根据给定的 File 对象构造一个 FileWriter 对象。

         参数：写入数据的目的地
                String fileName  文件的路径
                File file：是一个文件
           构造方法的作用：
            1.创建FileWriter对象
            2.会根据构造方法中传递的文件/文件路径，创建文件
            3.会把FileWriter对象指向创建好的文件。

3.4 字符输出流的基本使用–写出单个字符到文件

字符输出流的使用步骤:

1.创建FileWriter对象，构造方法中绑定要写入的数据的目的地
2.使用FileWriter对象中的方法write,把数据写入到内存缓冲区中（字符转换为字节的过程）
3.使用FileWriter中的方法flush，把内存缓冲区中的数据，刷新到文件中
4.释放资源（会先把内存缓冲区中的数据，刷新到文件中）

public class Demo02Writer {
    public static void main(String[] args) throws IOException {
        // 1.创建FileWriter对象，构造方法中绑定要写入的数据的目的地
        FileWriter fw = new FileWriter("Day16-code\\d.txt");
        //2.使用FileWriter对象中的方法write,把数据写入到内存缓冲区中（字符转换为字节的过程）
        fw.write(97);
        //    3.使用FileWriter中的方法flush，把内存缓冲区中的数据，刷新到文件中
        fw.flush();
        //  4.释放资源（会先把内存缓冲区中的数据，刷新到文件中）
        fw.close();
    }

}

3.5 flush方法和close方法的区别

flush： 刷新缓冲区，流对象可以继续使用
close： 先刷新缓冲区，然后通知系统释放资源，流对象不可以再被使用了

3.6 字符输出流写数据的其他方法

/*
    字符输出流写数据的其他方法:
        void write(int c)  写入单个字符。
        void write(char[] cbuf, int off ,int len) 写入字符数组的某一部分
        void write(String str)写入字符串。
        void write(String str, int off, int len)  写入字符串的某一部分。

 */
public class Demo03Writer {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("Day16-code\\f.txt");

        //写入字符数组
        char[] cs = {'a','b','c','d','e'};
        fw.write(cs);

        fw.write(cs,1,3);//cbd

        fw.write("cccccc");

        fw.write("程序员",1,2);//序员
    fw.close();
    }
}

3.7 字符输出流的续写和换行

/*
       续写和换行
           FileWriter(String fileName, boolean append)
          根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。
          FileWriter(File file, boolean append)
          根据给定的 File 对象构造一个 FileWriter 对象。
          boolean append :续写开关   true：不会创建新文件覆盖原文件，可以续写
                                    false：创建新的文件覆盖原文件
 */
public class Demo04Writer {
    public static void main(String[] args) throws IOException {
        FileWriter fw= new FileWriter("Day16-code\\f.txt",true);
        for (int i = 0; i < 6; i++) {
            fw.write("Hello"+"\r");
        }

        fw.close();


    }
}

四、IO异常的处理

4.1 try-catch-finally处理流中的异常

/*
    在jdk1.7之前，使用trycatch finally处理流中的异常
    格式：
        try{
            可能会产生异常的代码
        }catch（异常变量  变量名）{
          异常的处理逻辑
        }finally{
            一定会执行的代码
            资源释放
        }
 */
public class Demo01TryCatch {
    public static void main(String[] args) {
        //提高变量fw的作用域
        //变量在定义的时候可以没有值，使用的时候必须有值
        //fw= new FileWriter("Day16-code\\f.txt",true);执行失败 fw就没有值了
        FileWriter fw = null;
        try{
            //可能会出现异常的代码
            fw= new FileWriter("Day16-code\\f.txt",true);
            for (int i = 0; i < 6; i++) {
                fw.write("Hello"+"\r");
            }


        }catch (IOException e){

            System.out.println(e);
        }finally {
            //创建对象失败了，fw的默认值就是null，null是不能调用方法的，会抛出空指针异常，
            // 需要增加一个判断，不是null再吧资源释放
            //资源释放
            try {
                //fw.close方法声明抛出了IOException，所以我们就得处理这个异常对象
                if (fw != null) {
                    fw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

4.2 JDK7和JDK9流中异常的处理

JDK7

/*
    JDK7的新特性：
        在try的后边可以增加一个（），在括号中可以定义流对象
        那么这个流对象的作用域就在try中有效
        try中的代码执行完毕，会自动吧流对象释放，不用写finally
     格式：
     try(定义流对象;....){
            可能会产生异常的代码
        }catch（异常变量  变量名）{
          异常的处理逻辑


 */
public class Demo02JDK7 {
    public static void main(String[] args) {


        try (
                //1.创建一个字节输入流对象，构造方法中绑定要读取的数据源
                FileInputStream fis = new FileInputStream("Day16-code\\b.txt");

                // 2.创建一个字节输出流对象，构造方法中绑定要写入的目的地
                FileOutputStream fos = new FileOutputStream("f:\\b.txt");
            ){
            //一次读取/写入一个字节,可能会出现异常的代码
            //3.使用字节输入流的read读取文件
            int len = 0;
            while((len =fis.read()) !=-1){
                //4.使用字节输出流的write，把读取到的字节写入到目的地文件中
                fos.write(len);
            }

        }catch(IOException e){
            System.out.println(e);
        }


    }

}

JDK9

/*
    JDK9新特性
    try的前边可以定义流对象
    在try后边的（）中可以直接引入流对象的名称（变量名）
    在try代码执行完毕之后流对象也可以释放，不用写finally
    格式：
        A a = new A();
        B a = new B();
        try(a;b){
            可能会产生异常的代码
        }catch(异常类变量 变量名){
         异常的处理逻辑
         }
 */
public class Demo03JDK9 {
    public static void main(String[] args) throws IOException {
        //1.创建一个字节输入流对象，构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("Day16-code\\b.txt");

        // 2.创建一个字节输出流对象，构造方法中绑定要写入的目的地
        FileOutputStream fos = new FileOutputStream("f:\\b.txt");
        try (fis;fos){
            //一次读取/写入一个字节,可能会出现异常的代码
            //3.使用字节输入流的read读取文件
            int len = 0;
            while((len =fis.read()) !=-1){
                //4.使用字节输出流的write，把读取到的字节写入到目的地文件中
                fos.write(len);
            }

        }catch(IOException e){
            System.out.println(e);
        }

        //fos.write(1);//Stream Closed 不能再写入了

    }
}

五、属性集

5.1 使用Properties集合存储数据，遍历取出Properties集合中的数据

/*
    Properties extends Hashtable<k,v> implements Map<k,v>
    表示了一个持久的属性集。Properties 可保存在流中或从流中加载。
    Properties集合是唯一一个与IO流相结合的集合
        可以使用properties集合中的方法，把集合中的临时数据，持久化写入到硬盘中存储
        可以使用Properties集合中的方法load，吧硬盘中保存的文件（键值对），读取到集合使用
    属性列表中每个键及其对应值都是一个字符串。
        properties集合是一个双列集合，key和value默认都是字符串
*/
public class Demo01Properties {
    public static void main(String[] args) {
        show01();
    }
/*
    使用Properties集合存储数据，遍历取出集合中的数据
    Object setProperty(String key, String value) 调用 Hashtable 的方法 put。
    String getProperty(String key) 通过key找到value值，相当于Map集合中的get(key)
     Set<String> stringPropertyNames()  返回此属性列表中的键集，其中该键及其对应值是字符串，  此方法相当于Map集合中的keySet方法
    */
    private static void show01() {
        Properties prop = new Properties();
        prop.setProperty("赵丽颖","168");
        prop.setProperty("迪丽热巴","165");
        prop.setProperty("迪丽","160");

        //  Set<String> stringPropertyNames()把集合中的键取出
        Set<String> set = prop.stringPropertyNames();

        //遍历set集合，取出Properties集合中的每个键
        for (String key: set
             ) {
            String value = prop.getProperty(key);
            System.out.println(key +"="+ value);

        }
        

    }
}

5.1 Properties集合中的方法store

public class Demo01Properties {
    public static void main(String[] args) throws IOException {
      
        show02();
    }
/*
  可以使用properties集合中的方法store，把集合中的临时数据，持久化写入到硬盘中存储
 void store(OutputStream out, String comments)
 void store(Writer writer, String comments)
 参数：OutputStream out：字节输出流，不能写中文
        Writer writer字符输出流，可以写中文
        String comments：注释，用来解释说明保存的文件是作什么用的
        不能使用中文，会产生乱码，默认是Unicode编码
        一般使用空字符串。

 使用步骤：
        1.创建Properties集合对象，添加数据
        2.创建字节输出流/字符输出流对象，构造方法中绑定要输出的目的地
        3.使用Properties集合中的方法store，把集合中的临时数据持久化写入到硬盘中存储
        4.释放资源
 */
    private static void show02() throws IOException {
        //1.创建Properties集合对象，添加数据
        Properties prop = new Properties();
        prop.setProperty("赵丽颖","168");
        prop.setProperty("迪丽热巴","165");
        prop.setProperty("迪丽","160");
        // 2.创建字节输出流/字符输出流对象，构造方法中绑定要输出的目的地

      //  FileWriter fw = new FileWriter("Day16-code\\prop.txt");
        //3.使用Properties集合中的方法store，把集合中的临时数据持久化写入到硬盘中存储
       // prop.store(fw,"save data");
        //4.释放资源
        //fw.close();

        //字节流/乱码，因为字节流不能写中文
        prop.store(new FileOutputStream("Day16-code\\prop2.txt")," ");

    }
}

5.1 Properties集合中的方法load（重点）

/*
 可以使用Properties集合中的方法load，吧硬盘中保存的文件（键值对），读取到集合使用
        void load(InputStream inStream)
        void load(reader reader)
      参数：
           InputStream：字节输入流
           reader：字符输入流含中文
      使用步骤：
            1.创建Properties集合对象
            2.使用Properties集合对象中的方法load读取保存键值对的文件
            3.遍历Properties集合
       注意：
            1.存储键值对的文件中，键与值默认的链接符号可以使用=，空格（其他符号）
            2.存储键值对的文件中，可以使用#进行注释，被注释的键值对不会再被读取
            3.存储键值对的文件中，键与值默认都是字符串，不用再加引号。
 */
public class Demo02Load {
    public static void main(String[] args) throws IOException {
        // 1.创建Properties集合对象
        Properties prop = new Properties();
        //   2.使用Properties集合对象中的方法load读取保存键值对的文件
        prop.load(new FileReader("Day16-code\\prop.txt"));
        //字节流 因为包含中文，所以会乱码
     //   prop.load(new FileInputStream("Day16-code\\prop.txt"));
        //3.遍历Properties集合
        Set<String> set = prop.stringPropertyNames();
        for (String key : set) {
            String value = prop.getProperty(key);
            System.out.println(key+"="+value);
        }



    }
}