Java IO流(一)

目录

• IO概述
  • IO的分类
  • 顶级父类们
• 字节流
  • 一切皆为字节
  • 字节输出流【OutputStream】
  • FileOutputStream类
    • 构造方法
    • 写入字节数据
    • 一次写入多个字节的方法
    • 写入字符串的方法
    • 数据追加续写
  • 字节输入流【InputStream】
  • FileInputStream类
    • 构造方法
      • 2.5.2 读取字节数据
    • 一次读取一个字节的方法
    • 一次读取多个字节的方法
• 文件复制练习：一读一写
• 字符流
  • 字符输入流【Reader】
  • FileReader类
    • 构造方法
    • 读取字符数据
  • 字符输出流【Writer】
  • FileWriter
    • 构造方法
    • 关闭和刷新
    • 写数据的其他方法
    • 续写和换行
• IO异常的处理
  • 在 JDK1.7 之前使用 try catch finally 处理流中的异常
  • JDK 7 的新特性
  • JDK 9 的新特性
• 属性集
  • 概述
  • Properties类
    • 构造方法
    • 基本的存储方法
    • store方法
    • load方法

IO概述

IO的分类

根据数据的流向分为：输入流和输出流。

• 输入流：把数据从其他设备上读取到内存中的流。
• 输出流：把数据从内存中写入其他设备上的流。
• I:input 输入（读取）。
• O：output 输出（写入）。
• 流：数据（字符、字节） 1 个字符 = 2 个字节，1 个字节 = 8 个二进制尾位。

顶级父类们

	输入流	输出流
字节流	字节输入流 InputStream	字节输出流 OutputStream
字符流	字符输入流 Reader	字符输出流 Writer

字节流

一切皆为字节

一切文件数据（文本、图片、音频、视频等等）在存储的时候，都是以二进制数字的形式保存，都是一个一个的字节，那么传输时也一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。

字节输出流【OutputStream】

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

定义了一些子类共性的成员方法：

1. public void close()：关闭此输出流并释放与此流相联的任何系统资源。
2. public void flush()：刷新此输出流并强制任何缓冲的输出字节被写出。
3. public void write(byte[] b)：将b.length字节从指定的字节数组写入此输出流。
4. public void write(byte[] b, int off, int len)：从指定的字节数组写入 len字节，从偏移量 off开始输出至此输出流。
5. public abstract void write(int b)：将指定的字节输出流。

FileOutputStream类

• java.io.FileOutputStream extends OutputStream
• FileOutputStream：文件字节输出流
• 作用：把内存中的数据写入到硬盘的文件中。

构造方法

• FileOutputStream(String name)：创建一个向具有指定名称的文件中写入数据的输出文件流。
• FileOutputStream(File file)：创建一个向指定 File对象表示的文件中写入数据的文件输出流。
  • 参数：写入数据的目的地
    • String name：目的地是一个文件的路径。
    • File file：目的地是一个文件。

构造方法的作用：

1. 创建一个FileOutputStream对象。
2. 会根据构造方法中传递的文件 / 文件路径，创建一个空的文件。
3. 会把FileOutputStream对象指向创建好的文件。

写入字节数据

写入数据的原理（内存 --> 硬盘）：
java程序 --> JVM(java虚拟机) --> OS(操作系统) --> OS调用写数据的方法 --> 把数据写入到文件中。

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

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

• 实例：

import java.io.FileOutputStream;
import java.io.IOException;

public class Demo01OutputStream {
    public static void main(String[] args) throws IOException {
        // 1. 创建FileOutputStream对象，构造方法中传递写入数据的目的地
        FileOutputStream fos = new FileOutputStream("D:\aaa\abc.txt");
        // 2. 调用FileOutputStream中的方法，write，把数据写入到文件
        fos.write(97);
        // 3. 释放资源
        fos.close();
       /*
       写入数据的原理：
       写数据的时候会把十进制的97装换成二进制的整数
       硬盘中存储的都是数据的字节
       1 个字节 = 8 个比特位
       注意：
       任意的文本编辑器（记事本、notepad++...)
       在打开文件的时候，都会查询编码表，把字节装换成字符表示
       0~127：查询ASCII表
       其他值：查询系统默认码表（中文系统 GBK）
        */
    }
}

一次写入多个字节的方法

• public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。

  • 一次写多个字节
  • 如果写的第一个字节是正数（0~127），那么显示的时候会查询ASCII表。
  • 如果写的第一个字节是负数，那么第一个字节会和第二个字节，两个字节组成一个中文显示，查询系统默认码表（GBK）
  • GBK中一个字是 2 个字节，UTF-8中一个字是 3 个字节。

• public void write(byte[] b, int off, int len)：把字节数组的一部分写入到文件中。

  • int off：数组的开始索引。
  • int len：写几个字节。

写入字符串的方法

可以使用 String类中的方法 getBytes，把字符串装换为字节数组。

• byte[] getBytes()：把字符串装换为字节数组。

• 实例：

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class Demo02FileOutputStream {
    public static void main(String[] args) throws IOException {
        // 创建FileOutputStream对象，构造方法中传递目的地
        FileOutputStream fos = new FileOutputStream("D:\aaa\abc.txt");
        // public void write(byte[] b)
        byte[] bytes = {97, 98, 99, 100};
        fos.write(bytes); // abcd
//        System.out.println(bytes);
//        System.out.println(Arrays.toString(bytes));

        // public void write(byte[] b, int off, int len)
        fos.write(bytes, 1, 3); // abcdbcd

        byte[] bytes2 = {-48, -49, -50, -51, 65};
        System.out.println(Arrays.toString(bytes2));
        fos.write(bytes2); // abcdbcd邢瓮A

        // 写入字符串
        byte[] bytes3 = "你好".getBytes();
        System.out.println(Arrays.toString(bytes3));
        fos.write(bytes3);

        byte[] bytes4 = {-28, -67, -96, -27, -91, -67};
        fos.write(bytes4);
        // 释放资源
        fos.close();
    }
}

数据追加续写

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

• FileOutputStream(String name, boolean append) ：创建一个向具有指定 name 的文件中写入数据的输出文件流。

• FileOutputStream(File file, boolean append) ：创建一个向指定 File 对象表示的文件中写入数据的文件输出流。

  • 参数：
    • String name，File file：写入数据的目的地。
    • boolean append：追加写开关。
      • true：创建对象不会覆盖源文件，继续在文件的末尾追加写数据。
      • false：创建一个新的文件，覆盖源文件。

• 写换行：写换行符

  • windows：
  • Linux：/n
  • mac：/r

• 实例

import java.io.FileOutputStream;
import java.io.IOException;

public class Demo03FileOutputStream {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("D:\aaa\abc.txt", true);

        for (int i = 0; i < 10; i++) {
            fos.write("你好".getBytes());
            // windows 换行
            fos.write("
".getBytes());
        }
        fos.close();
    }
}

字节输入流【InputStream】

• java.io.InputStream：字节输入流
• 此抽象类是表示字节输入流的所有类的超类。

定义了所有子类共性的方法：

1. abstract int read()：从输入流中读取数据的下一个字节。
2. int read(byte[] b)：从输入流中读取一定数量的字节，并将其存储到缓冲区数组 b 中。
3. void close()：关闭此输入流并释放与该流关联的所有系统资源。

FileInputStream类

• java.io.FileInputStream extends InputStream
• FileInputStream：文件字节输入流。
• 作用：把硬盘中的数据读取到内存中使用。

构造方法

• FileInputStream(String name)
• FileInputStream(File file)
  • 参数：读取文件的数据源
    • String name：读取文件的路径。
    • File file：文件

构造方法的作用：

1. 会创建一个FileInputStream对象。
2. 会把FileInputStream对象指向构造方法中要读取的文件。

2.5.2 读取字节数据

读取数据的原理
java程序 --> JVM(java虚拟机) --> OS(操作系统) --> OS调用读数据的方法 --> 读取文件。

• int read()：读取文件中的一个字节并返回，读取到文件的末尾返回 -1。

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

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

一次读取一个字节的方法

• abstract int read();
• 示例：

import java.io.FileInputStream;
import java.io.IOException;

public class Demo04FileInputStream {
    public static void main(String[] args) throws IOException {
        // 1. 创建FileInputStream对象
        FileInputStream fis = new FileInputStream("D:\aaa\123.txt");
        // 2. 调用FileInputStream中的方法read，读取文件
/*
        int len = fis.read();
        System.out.println(len);
*/
        /*
        布尔表达式(len = fis.read()) != -1)
            1. fis.read():读取一个字节
            2. len = fis.read():把读取的字节赋值给变量len
            3. (len = fis.read()) != -1):判断变量len是否不等于-1
        错误写法：
        while (fis.read() != -1) { // 读取
        System.out.println(fis.read());
        }
         */
        int len = 0; // 记录读取到的字节
        while ((len = fis.read()) != -1) {
            System.out.println((char) len);
        }

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

一次读取多个字节的方法

• int read(byte[ ] b)：从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。

明确两件事情：

1. 方法的参数 byte[ ] 的作用？
   • 起到缓冲作用：存储每次读取到的多个字节。
   • 数组的长度一般定义为1024（1KB）或者1024的整数倍。
2. 方法的返回值 int 是什么？
   • 每次读取到的有效字节个数。

String类的构造方法

1. String(byte[ ] byte)：把字节数组转换为字符串。
2. String(byte[ ] byte, int offset, int length)：把字节数组的一部分转换为字符串，
   • offset：数组的开始索引。
   • length：转换的字节个数。

• 示例

import java.io.FileInputStream;
import java.io.IOException;

public class Demo05FileInputStream {
    public static void main(String[] args) throws IOException {
        // 创建FileInputStream对象，构造方法中传递读取的数据源
        FileInputStream fis = new FileInputStream("D:\aaa\123.txt");
        // 创建一个字节数组，用来缓冲一次读取到的字节
        byte[] bytes = new byte[1024];
        // 调用FileInputStream中的方法，read读取数据，参数中传递bytes
/*
        int len = fis.read(bytes);
        System.out.println("len = " + len); // 2
        System.out.println(new String(bytes)); // ab

        len = fis.read(bytes);
        System.out.println("len = " + len); // 1
        System.out.println(new String(bytes)); // cb

        len = fis.read(bytes);
        System.out.println("len = " + len); // -1
        System.out.println(new String(bytes)); // cb
*/
        int len = 0; // 记录读取有效字节的个数
        while ((len = fis.read(bytes)) != -1) {
            System.out.println(new String(bytes, 0, len));
        }

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

文件复制练习：一读一写

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

/*
    文件复制练习：一读一写
    明确：
        数据源：
        数据的目的地：
    文件复制的步骤：
        1. 创建一个字节输入流对象，构造方法中绑定要读取的数据源
        2. 创建一个字节输出流对象，构造方法中绑定要写入的目的地
        3. 使用字节输入流对象中的 read方法读取文件
        4. 使用字节输出流对象中的 write方法，把读取到的字节写入到目的地中
        5. 释放资源
 */
public class Demo05CopyFile {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("C:\Users\Pictures\Saved Pictures\3.jpeg");
        FileOutputStream fos = new FileOutputStream("D:\3.jpeg");

        // 计算文件复制所耗费的时间
        long start = System.currentTimeMillis();

        // 一次读取一个字节，写入一个字节的方式
        /*int len = 0;
        while ((len = fis.read()) != -1) {
            fos.write(len);
        }*/

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


        // 释放资源（先关写的，后关读的；如果写完了，肯定读取完毕了）
        fos.close();
        fis.close();

        long end = System.currentTimeMillis();
        System.out.println("文件复制耗费：" + (end - start) + "毫秒");

    }
}

字符流

当使用字节读取文本文件时，可能会有一个小问题，就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。

字符输入流【Reader】

• java.io.Reader：字符输入流，是字符输入流最顶层的父类，定义了一些共性的成员方法，是一个抽象类。

共性的成员方法：

1. int read()：读取单个字符并返回。
2. int read(char[ ] cbuf)：一次读取多个字符，将字符读入数组。
3. void close()：关闭该流并释放与之关联的所有资源。

FileReader类

• java.io.FileReader extends InputStreamReader extends Reader
• FileReader：文件字符输入流。
• 作用：把硬盘中的数据以字符的方法读取到内存中。

构造方法

• FileReader(String fileName)
• FileReader(File file)
  • 参数：读取文件的数据源
    • String fileName：文件的路径
    • File file：一个文件

FileReader构造方法的作用

1. 创建一个FileReader对象。
2. 会把FileReader对象指向要读取的文件。

字符输入流的使用步骤：

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

String类中的构造方法：

• String(char[ ] value)：把字符数组转换成字符串。
• String(char[ ] value, int offset, int count)： 把字符数组的一部分转换为字符串。
  • offset：数组的开始索引
  • count：转换的个数

读取字符数据

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

public class Demo01Reader {
    public static void main(String[] args) throws IOException {
        // 1. 创建FileReader对象，绑定要读取的数据源
        FileReader fr = new FileReader("D:\aaa\123.txt");
        // 2. 调用FileReader中的方法 read，读取数据

        // 一次读取一个字符
/*
        int len = 0; // 记录读取到的字符
        while ((len = fr.read()) != -1) {
            System.out.println((char)len);
        }
*/

        // 一次读取多个字符
        char[] cs = new char[1024]; // 存储一次读取的多个字符
        int len = 0; // 记录读取的有效字符个数
        while ((len = fr.read(cs)) != -1) {
            System.out.println(new String(cs, 0, len));
        }
    }
}

字符输出流【Writer】

• java.io.Writer：字符输出流，是所有字符输出流的最顶层的父类，是一个抽象类

共性的成员方法：

1. void writer(int c)：写入单个字符。
2. void writer(char[ ] cbuf)：写入字符数组。
3. abstract void writer(char[ ] cbuf, int off, int len)：写入字符数组的一部分，off：数组的开始索引，len：写的字符个数。
4. void writer(String str)：写入字符串。
5. void writer(String str, int off, int len)：写入字符串的一部分，off：字符串的开始索引，len：写入字符的个数。
6. void flush()：刷新该流的缓冲区。
7. void close()：关闭此流，但要先刷新它。

FileWriter

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

构造方法

• FileWriter(File file) ：根据给定的 File 对象构造一个 FileWriter 对象。
• FileWriter(String fileName) ：根据给定的文件名构造一个 FileWriter 对象。
• 参数：写入数据的目的地
  • String fileName：文件的路径。
  • File file：是一个文件。

构造方法的作用：

1. 会创建一个FileWriter对象。
2. 会根据构造方法中传递的文件 / 文件的路径，创建文件。
3. 会把FileWriter对象指向创建好的文件。

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

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

• 示例

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

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

关闭和刷新

flush方法和close方法的区别：

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

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

/*
FileWriter中 flush方法和 close方法的区别：
 */
public class DemoFlushAndClose {
    public static void main(String[] args) throws IOException {
        // 创建字符输出流对象，构造方法中绑定写入数据的目的地
        FileWriter fw = new FileWriter("D:\ideaproject\itcast-code\b.txt");
        // 调用FileWriter中的方法 writer，将数据写入到内存缓冲区中
        fw.write(97);
        // 调用flush方法，刷新内存缓冲区
        fw.flush();

        // 继续写入数据
        fw.write(48);
        // 关闭流对象
        fw.close();
        // fw.write(65); // Stream closed
    }
}

写数据的其他方法

1. void writer(char[ ] cbuf)：写入字符数组。
2. abstract void writer(char[ ] cbuf, int off, int len)：写入字符数组的一部分，off：数组的开始索引，len：写的字符个数。
3. void writer(String str)：写入字符串。
4. void writer(String str, int off, int len)：写入字符串的一部分，off：字符串的开始索引，len：写入字符的个数。

• 示例：

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

/*
    字符输出流写数据的其他方法：
    1. void writer(char[] cbuf)
    2. void writer(char[] cbuf, int off, int len)
    3. void writer(String str)
    4. void writer(String str, int off, int len)
 */
public class Demo02Writer {
    public static void main(String[] args) throws IOException {
        // 创建字符输出流对象
        FileWriter fw = new FileWriter("D:\ideaproject\itcast-code\b.txt");
        // 创建一个字符数组
        char[] cs = new char[]{'a', 'b', 'c', 'd', 'e'};
        // void writer(char[] cbuf)
        fw.write(cs);
        // void writer(char[] cbuf, int off, int len)
        // 写字符数组的一部分
        fw.write(cs, 1, 2);
        // void writer(String str)
        fw.write("传智播客");
        // void writer(String str, int off, int len)
        fw.write("黑马程序员", 2, 3);
        // 释放资源
        fw.close();
    }
}

续写和换行

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

1. FileWriter(String fileName, boolean append)
2. FileWriter(File file, boolean append)
   • 参数：
     • String fileName，File file：写入数据的目的地。
     • boolean append：续写开关
       • true：不会创建新文件覆盖源文件，可以续写。
       • false：创建新的文件覆盖源文件。

换行：换行符号

• windows：
• Linux：
• mac：

当我们单纯读 或者 写文本文件时，使用字符流，其他情况使用字节流。

IO异常的处理

在 JDK1.7 之前使用 try catch finally 处理流中的异常

• 格式：

	try {
		可能会出现异常的代码
	} catch (异常类型 变量名称) {
		异常的处理逻辑
	} finally {
		一定会执行的代码
		（资源释放）
	}
	

• 示例

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

/*
在jdk1.7之前，使用 try cathc finally 处理异常
 */
public class DemoTryCatchFinally {
    public static void main(String[] args) {
        /*
         提高变量 fw 的作用域，让finally可以使用
         【局部变量在定义的时候，可以没有值，但是使用的时候必须有值】

         new FileWriter("w:\ideaproject\itcast-code\b.txt", true);
         执行失败，fw没有值，fw.close 会报错
         */
        FileWriter fw = null;
        try {
            fw = new FileWriter("w:\ideaproject\itcast-code\b.txt", true);
            fw.write("hello java");
        } catch (IOException e) {
            System.out.println(e);

        } finally {
            // 创建对象失败，fw的给定值为null，null是不能调用方法的，
            // 会抛出NullPointerException，需要增加一个判断，不是null，把资源释放
            if (fw != null) {
                try {
                    // fw.close方法声明抛出了IOException异常，所以我们要处理这个异常对象，要么throws，要么try catch
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

JDK 7 的新特性

在try的后边可以增加一个()，在括号中可以定义流对象，那么这个流对象的作用域就在 try中有效，try中的代码执行完毕，会自动把流对象释放，不用写 finally

• 格式：

	try (定义流对象;定义流对象...) {
		可能会产生异常的代码
	} catch (异常类型 变量名称) {
		异常的处理逻辑
	}

• 示例：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
JDK 1.7 的新特性
 */
public class DemoJDK7 {
    public static void main(String[] args) {
        // 流对象的定义
        // 可能会产生异常的代码
        try (FileInputStream fis = new FileInputStream("C:\Users\孙忠杰\Pictures\Saved Pictures\3.jpeg");
             FileOutputStream fos = new FileOutputStream("D:\3.jpeg");) {
            // 一次读取一个字节，写入一个字节的方式
            int len = 0;
            while ((len = fis.read()) != -1) {
                fos.write(len);
            }
        } catch(IOException e){
            // 异常的处理逻辑
            System.out.println(e);
        }
    }
}

JDK 9 的新特性

try的前边可以定义流对象，在try后边的()中可以直接引入流对象的名称（变量名），在try代码执行完毕之后，流对象也可以自动释放掉，不用写finally

• 格式：

        A a = new A();
        B b = new B();
        try (a;b) {
            // 可能产生异常的代码
        } catch (异常类型 变量名称) {
            // 异常的处理逻辑
        }

• 示例：

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

/*
    JDK9新特性
    try的前边可以定义流对象
    在try后边的()中可以直接引入流对象的名称（变量名）
    在try代码执行完毕之后，流对象也可以自动释放掉，不用写finally
    格式：
        A a = new A();
        B b = new B();
        try (a;b) {
            // 可能产生异常的代码
        } catch (异常类型 变量名称) {
            // 异常的处理逻辑
        }
 */
public class DemoJDK9 {
    public static void main(String[] args) throws FileNotFoundException {
        // 1. 创建输入流对象，构造方法中绑定读取数据的目的地
        FileInputStream fis = new FileInputStream("D:\3.jpeg");
        // 2. 创建输出流对象，构造方法中绑定写入数据的目的地
        FileOutputStream fos = new FileOutputStream("d:\aaa\3.jpeg");
        // 引入流对象
        try (fis; fos) {
            // 定义一个字节数组，用来缓冲数据
            byte[] bytes = new byte[1024];
            // 记录读取字节的有效个数
            int len = 0;
            while ((len = fis.read(bytes)) != -1) {
                fos.write(bytes, 0, len);
            }
        } catch (IOException e) {
            System.out.println(e);
        }
    }
}

属性集

概述

java.util.Properties继承于Hashtable，用来表示一个持久的属性集。它使用键值结构存储数据，每个键及其对应的值都是一个字符串，该类也被许多Java类使用，比如获取系统属性的时，System.getProperties()方法返回的就是一个Properties对象。

Properties类

• java.util.Properties 集合 extends Hashtable<K, V> implements Map<K, V>
• Properties 类表示一个持久的属性集。Properties 可保存在流中或从流中加载。
• Properties 集合是唯一一个和IO流向结合的集合
  • 可以使用Properties集合中的方法 store，把集合中的临时数据，持久化写入到硬盘中存储。
  • 可以使用Properties集合中的方法load，把硬盘中保存的的文件（键值对），读取到集合中使用。
• 属性列表中每个键及其对应的值都是一个字符串。
• Peoperties集合是一个双列集合，key和value默认都是字符串。

构造方法

• public Properties()：创建一个空的属性列表

基本的存储方法

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

• Properties集合是一个双列集合，key和value默认都是字符串

• Properties集合有一些操作字符串特有的方法：

  1. Object setProperty(String key, String value)：调用 Hashtable 的方法 put。
  2. Set<String> stringPropertyNames()：返回此属性列表中的键集，其中该键及其对应值是字符串，此方法相当于Map集合中的keySet方法
  3. String getProperty(String key)：通过key找到value值，此方法相当于Map集合中的get(key)方法

• 示例：

import java.util.Properties;
import java.util.Set;

public class Demo01Properties {
    public static void main(String[] args) {
        // 创建Properties集合对象
        Properties prop = new Properties();
        // 使用 setProperty往集合中添加元素
        prop.setProperty("赵丽颖", "168");
        prop.setProperty("迪丽热巴", "165");
        prop.setProperty("马儿扎哈", "170");
        // 使用stringPropertiesNames 把Properties集合中的键取出，存储到一个Set集合中
        Set<String> set = prop.stringPropertyNames();
        // 遍历Set集合,取出Properties集合中的每一个键
        for (String key : set) {
            String value = prop.getProperty(key);
            System.out.println(key + " = " + value);
        }
    }
}

store方法

• 可以使用Properties集合中的 store方法，把集合中的临时数据，持久化写入到硬盘中存储。
• void store(Writer writer, String comments)
• void store(OutputStream out, String comments)
• 参数：
  • OutputStream out：字节输出流，不能写中文。
  • Writer writer：字符输出流，可以写中文。
  • String comments：注释，用来解释说明保存的文件是做什么用的。不能使用中文，会产生乱码，默认是Unicode编码，一般使用" "空字符串。

使用步骤：

1. 创建Properties集合对象，添加数据。
2. 创建字节输出流 / 字符输出流对象，构造方法中绑定要输出的目的地。
3. 使用Properties集合中的 store方法，把集合中的临时数据，持久化写入到硬盘中存储。
4. 释放资源。

• 示例：

import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

public class Demo02Properties {
    public static void main(String[] args) throws IOException {
        // 创建Properties集合对象
        Properties prop = new Properties();
        // 使用 setProperty往集合中添加元素
        prop.setProperty("赵丽颖", "168");
        prop.setProperty("迪丽热巴", "165");
        prop.setProperty("马儿扎哈", "170");

/*
        // 创建字符输出流对象，构造方法中绑定要输出的目的地
        FileWriter fw = new FileWriter("D:\ideaproject\itcast-code\prop.txt");
        // 使用Properties中的方法，store，临时数据 --> 硬盘
        prop.store(fw, "save data");
        // 释放资源
        fw.close();
*/
        // 使用字节输出流输出中文，出现乱码
        prop.store(new FileOutputStream("D:\ideaproject\itcast-code\a.txt"), "");
    }
}

load方法

• 可以使用Properties集合中的方法load，把硬盘中保存的的文件（键值对），读取到集合中使用。
• void load(InputStream inStream)
• void load(Reader reader)
• 参数:
  • InputStream inStream:字节输入流,不能读取含有中文的键值对.
  • Reader reader:字符输入流,能读取含有中文的键值对.

使用步骤:

1. 创建Properties集合对象.
2. 使用Properties集合中的方法 load,读取保存键值对的文件.
3. 遍历Properties集合

注意事项:

1. 存储键值对的文件中,键与值的默认连接符号可以使用=, 空格(其他符号)
2. 存储键值对的文件中,可以使用#进行注释,被注释的键值对不会再被读取.
3. 存储键值对的文件中,键与值默认都是字符串,不用再加引号.

• 示例:

import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

public class Demo03Load {
    public static void main(String[] args) throws IOException {
        // 创建Properties对象
        Properties prop = new Properties();
        // 调用 load方法，读取硬盘中的数据
        prop.load(new FileReader("D:\ideaproject\itcast-code\prop.txt"));
        // 遍历集合
        Set<String> set = prop.stringPropertyNames();
        for (String key : set) {
            String value = prop.getProperty(key);
            System.out.println(key + "=" + value);
        }
    }
}