一、IO流概述
回到目录
Java中I/O操作主要是指使用java.io
包下的内容,进行输入、输出操作。输入也叫做读取数据,输出也叫做作写出数据。
1.1 IO流的分类
按数据的流向分为:输入流和输出流。
- 输入流 :把数据从
其他设备
上读取到内存
中的流。 - 输出流 :把数据从
内存
中写出到其他设备
上的流。
按数据的类型分为:字节流和字符流。
- 字节流 :以字节为单位,读写数据的流。
- 字符流 :以字符为单位,读写数据的流。
- JDK 中后缀是 Stream 是字节流;后缀是 Reader,Writer 是字符流
按功能分类:节点流和处理流
- 节点流:直接与数据源相连,读入或写出
- 处理流:与节点流一块使用,在节点流的基础上,再套接一层
1.2 IO的流向说明图解
1.3 最根本的四大类(顶级父类)
输入流 | 输出流 | |
---|---|---|
字节流 | 字节输入流 InputStream | 字节输出流 OutputStream |
字符流 | 字符输入流 Reader | 字符输出流 Writer |
二、字节流
1、一切皆为字节
一切文件数据(文本、图片、视频等)在存储时,都是以二进制数字的形式保存,都是一个一个字节。字节流可以传输任意的文件数据,在操作流的时候,底层传输的始终为二进制数据。
2、字节输出流(OutputStream,抽象类)
java.io.OutputStream
:字节输出流,此【抽象类】是表示字节输出流的所有类的【超类】。
它定义了字节输出流的基本共性的成员方法:(子类中都可以使用,跟集合一样)
public void close()
:关闭此输出流并释放与此流相关联的任何系统资源。public void flush()
:刷新此输出流并强制任何缓冲的输出字节被写出。public void write(byte[] b)
:将 b.length字节从指定的字节数组写入此输出流。public void write(byte[] b, int off, int len)
:从指定的字节数组写入 len 字节,从偏移量 off 开始输出到此输出流。public abstract void write(int b)
:将指定的字节输出流。
(JDK1.6中)直接已知子类:
ByteArrayOutputStream, FileOutputStream, FilterOutputStream, ObjectOutputStream, OutputStream, PipedOutputStream
现在主要学FileOutputStream这个子类
3、文件字节输出流(FileOutputStream)
java.io.FileOutputStream extends OutputStream
,作用:把内存中的数据写入到硬盘的文件中。
3.1 构造方法(简单的)
FileOutputStream(String name):创建一个向具有指定名称的文件中写入数据的输出文件流。
FileOutputStream(File file) :创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
参数:写入数据的目的地。String name :目的地是一个文件的路径;File file:目的地是一个文件。
构造方法的作用:
- 创建一个FileOutputStream对象
- 会根据构造方法中传递的 文件/文件路径 , 创建一个空的文件
- 会把FileOutputStream对象指向创建好的文件
写入数据的原理(内存—> 硬盘):Java程序 —> JVM(Java虚拟机) —> OS(操作系统) —> OS调用写数据的方法 —> 把数据写入到文件中
3.2 字节输出流的使用(单个、多个字符,续写和换行)
使用步骤:
- 创建一个FileOutputStream对象, 构造方法中传递写入数据的目的地
- 调用FileOutputStream对象中的方法write, 把数据写入到文件中
- 释放资源(流使用会占用一定的内存, 使用完毕要把内存清空, 提高程序的效率)
写入单个字节
public abstract void write(int b)
:将指定的字节输出流。
public class Demo01OutputStream {
public static void main(String[] args) throws IOException {
// 1.创建一个FileOutputStream对象,构造方法中传递写入数据的目的地
FileOutputStream fos = new FileOutputStream(new File("day09-code-IO流\\a.txt"));
// 2.调用FileOutputStream对象中的方法write,把数据写入到文件中
fos.write(97); // ASCII码表中,97代表a
// 3.释放资源(流使用会占用一定的内存,使用完毕要把内存清空,提供程序的效率)
fos.close();
}
}
写入多个字节
-
public void write(byte[] b)
:一次写多个字节,如果写的第一个字节是正数(0-127), 那么显示的时候会查询ASCII表;如果写的第一个字节是负数, 那第一个字节会和第二个字节, 两个字节组成一个中文显示, 查询系统默认码表(GBK)。 -
public void write(byte[] b, int off, int len)
:把字节数组的一部分写入到文件中,int off: 数组的开始索引,int len: 写几个字节 -
写入字符的方法: 可以使用String类中的
getBytes()
方法,把字符串转换为字节数组,再调用FileOutputStream中的write(byte[])
方法
byte[] getBytes()
: 把字符串转换为字节数组
UTF-8中,3个字节是一个中文;GDK中,2个字节是一个中文。
public class Demo01OutputStream {
public static void main(String[] args) throws IOException {
// 1.创建一个FileOutputStream对象,构造方法中传递写入数据的目的地
FileOutputStream fos = new FileOutputStream("day09-code-IO流\\b.txt");
// 2.调用FileOutputStream对象中的方法write,把数据写入到文件中
// public abstract void write(int b) :将指定的字节输出流。
fos.write(49); // ASCII码表中,49代表1
fos.write(48); // ASCII码表中,48代表0
fos.write(48);
// b.txt文件已经被写入了100,但是这种方式麻烦,可以用另外的两个个方法
// public void write(byte[] b)
byte[] bytes = {65, 66, 67, 68, 69}; // 会在文件b.txt里面的100后面加上 ABCDE
fos.write(bytes);
// public void write(byte[] b, int off, int len)
fos.write(byte, 1, 2); // 会在后面加上 BC
// 写入字符串的方法,可以使用String类中的getBytes()方法,把字符串转换为字节数组,再传到write()方法中
byte[] bytes2 = "你好".getBytes();
System.out.println(Arrays.toString(bytes2)); // [-28. -67, -96, -27, -91, -67] UTF-8中,3个字节是一个中文
fos.write(bytes2);
// 3.释放资源(流使用会占用一定的内存,使用完毕要把内存清空,提供程序的效率)
fos.close();
}
}
续写与换行写(使用另外的两个构造方法)
上面的写入实际上就是新建一个文件再重新写(不能续写),而且还只能写在一行(不能换行)。
- 续写:要使用下面带有两个参数的构造方法
FileOutputStream(String name, boolean append)
:创建一个向具有指定 name 的文件中写入数据的输出文件流。FileOutputStream(File file, boolean append)
:创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
参数:
String name,File file: 写入数据的目的地
boolean append: 续写的开关。true: 创建对象不会覆盖源文件, 继续在文件的末尾追加写数据;false: 创建一个新文件, 会覆盖掉源文件
- 换行写:要加上换行符号
windows:\r\n
linux:/n
mac:/r
public class Demo03OutputStream {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("day09-code-IO流\\c.txt", true);
for (int i = 1; i <= 10; i++) {
fos.write("你好".getBytes());
fos.write("\r\n".getBytes());
}
fos.close();
}
}
4、字节输入流(InputStream,抽象类)
回到目录
java.io.InputStream
:字节输入流,此【抽象类】是表示字节输入流的所有类的【超类】。
定义了所有子类共性的成员方法 :
int read()
:从输入流中读取数据的下一个字节。int read(byte[] b)
:从输入流中读取一定数量的字节,并将其存储在缓冲区数组 b 中。void close()
: 关闭此输入流并释放与该流关联的所有系统资源。
现在主要学FileInputStream这个子类
5、文件字节输入流(FileInputStream)
java.io.FileInputStream extends InputStream
:把硬盘文件中的数据 , 读取到内存中使用
5.1 构造方法
FileInputStream(String name)
FileInputStream(File file)
参数:读取文件的数据源
构造方法的作用:
- 会创建一个FileInputStream对象
- 会把FileInputStream对象指向构造方法中要读取的文件
读取数据的原理(硬盘–> 内存):Java程序 --> JVM --> OS --> OS读取数据的方法 --> 读取文件
5.2 字节输入流的使用
使用步骤:
- 创建FileInputStream对象,构造方法中绑定要读取的数据源
- 使用FileInputStream对象中的方法read,读取文件
- 释放资源
读取单个字符
public class Demo01InputStream {
public static void main(String[] args) throws IOException {
// 1.创建FileInputStream对象, 构造方法中绑定要读取的数据源
FileInputStream fis = new FileInputStream("day09-code-IO流\\c.txt");
// 2.使用FileInputStream对象中的方法read, 读取文件
// int read()读取文件中的一个字节并返回, 读取到文件的末尾返回 -1
/*
布尔表达式(len = fis.read())!=-1
1.fis.read(): 读取一个字节
2.len = fis.read(): 把读取到的字节赋值给变量len
【必须要用一个变量来接受读取的数据!!!fis.read()完成后,再来一个fis.read()就会读到下一位】
3.(len = fis.read()) != -1 : 判断变量len是否不等于-1
*/
int len = 0; // 记录读取到的字节
while((len = fis.read()) != -1){
System.out.print((char) len); // abc
}
//3.释放资源
fis.close();
}
}
读取多个字节的方法
int read(byte[] b)
:从输入流中读取一定数量的字节,并将其存储在缓冲区数组 b 中。
字节输入流一次读取多个字节的方法:
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对象,构造方法中绑定要读取的数据源
FileInputStream fis = new FileInputStream("09_IOAndProperties\\b.txt");
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();
}
}
6、字节流读取中文
使用【字节流】读取中文文件,1个中文在GBK中,占用两个字节;在UTF-8中,占用3个字节。读取中文时,可能会显示不完整的字符或乱码,所以要用到【字符流】。
7、字节流的文件复制
三、字符流
回到目录
当使用字节流读取文本文件时,可能会有一个小问题。就是遇到中文字符时,可能不会显示完整的字符,那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类,以字符为单位读写数据,专门用于处理文本文件。
1、字符输入流(Reader类,抽象类)
java.io.Reader
抽象类是表示用于读取字符流的所有类的超类,可以读取字符信息到内存中。
共性的成员方法:
public void close()
:关闭此流并释放与此流相关联的任何系统资源。public int read()
: 从输入流读取一个字符。public int read(char[] cbuf)
: 从输入流中读取一些字符,并将它们存储到字符数组 cbuf中 。
(JDK1.6)中的子类:
BufferedReader, CharArrayReader, FilterReader, InputStreamReader, PipedReader, StringReader
2、文件字符输入流(FileReader)
java.io.FileReader extends InputStreamReader extends Reader
,作用: 把硬盘文件中的数据以字符的方式读取到内存中
2.1 构造方法
FileReader(String fileName)
:创建一个新的 FileReader ,给定要读取的文件的名称。
FileReader(File file)
:创建一个新的 FileReader ,给定要读取的File对象。
参数: 读取文件的数据源
String fileName: 文件的路径
File file: 一个文件
FileReader构造方法的作用:
- 创建一个FileReader对象
- 会把FileReader对象 指向 要读取的文件
2.2 字符输入流的使用
使用步骤:
- 创建FileReader对象, 构造方法中绑定要读取的数据源
- 使用FileReader对象中的方法read读取文件
- 释放资源
c.txt文件内容为:你好abc123###
现在读取其中的内容,代码:
public class Demo02Reader {
public static void main(String[] args) throws IOException {
// 1.创建FileReader对象,构造方法中绑定要读取的数据源
FileReader fr = new FileReader("day09-code-IO流\\c.txt");
// 2.使用FileReader对象中的方法read读取文件
// int read() : 读取单个字符并返回;
// int read(char[] cbuf): 一次读取多个字符, 将字符读入数组
char[] cs = new char[1024]; // 存储读取到的多个字符
int len = 0; // 记录的是每次读取的有效字符个数
while ((len = fr.read(cs)) != -1) {
/*
String类的构造方法:
String(char[] value)——把字符数组转换为字符串
String(char[] value, int offset, int count)——把字符数组的一部分转换为字符串,offset数组的开始索引,count转换的个数
*/
System.out.println(new String(cs, 0, len));
}
//3.释放资源
fr.close();
}
}
3、字符输出流(Writer类,抽象类)
java.io.Writer
:字符输出流, 是所有 字符输出流 最顶层的父类, 是一个抽象类
共性的成员方法:
void write(int c)
:写入单个字符。void write(char[] cbuf)
:写入字符数组。abstract void write(char[] cbuf, int off, int len)
:写入字符数组的某一部分,off数组的开始索引,len写的字符个数。void write(String str)
:写入字符串。void write(String str, int off, int len)
:写入字符串的某一部分,off字符串的开始索引,len写的字符个数。void flush()
:刷新该流的缓冲。void close()
:关闭此流,但要先刷新它。
它的子类有很多,现在只用OutputStreamWriter的子类FileWriter
4、文件字符输出流(FileWriter)
java.io.FileWriter extends OutputStreamWriter extends Writer
,作用: 把内存中字符数据写出到文件中
4.1 构造方法
FileWriter(File file)
:根据给定的 File 对象构造一个 FileWriter 对象。
FileWriter(String fileName)
: 根据给定的文件名构造一个 FileWriter 对象。
构造方法的作用:
- 会创建一个FileWriter对象
- 会根据构造方法中传递的文件/文件的路径,创建文件
- 会把FileWriter对象指向创建好的文件
4.2 字符输出流的使用(单个、多个字符,续写和换行)
使用步骤:
- 创建FileWriter对象, 构造方法中绑定要写入数据的目的地
- 使用FileWriter中的方法write, 把数据写入到【内存缓冲区】(字符转换为字节的过程)
- 使用FileWriter中的方法flush, 把【内存缓冲区】中的数据刷新到文件中
- 释放资源(会先把【内存缓冲区】中的数据刷新到文件中,这样就可以省略第3步了)
public class Demo01Writer {
public static void main(String[] args) throws IOException {
// 1.创建FileWriter对象,构造方法中绑定要写入数据的目的地
FileWriter fw = new FileWriter("09_IOAndProperties\\d.txt");
// 2.使用FileWriter中的方法write, 把数据写入到【内存缓冲区】(字符转换为字节的过程)
// void write(int c) 写入单个字符。
fw.write(97);
// 3.使用FileWriter中的方法flush, 把内存缓冲区中的数据, 刷新到文件中
// fw.flush();
// 4.释放资源(会先把内存缓冲区中的数据刷新到文件中,这样就可以省略第3步了)
fw.close();
}
}
上面是单个写入字符,下面是多个字符写入,以及续写和换行
import java.io.FileWriter;
import java.io.IOException;
/*
字符输出流写数据的其他方法
- void write(char[] cbuf):写入字符数组。
- abstract void write(char[] cbuf, int off, int len):写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
- void write(String str):写入字符串。
- void write(String str, int off, int len):写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
*/
public class Demo03Writer {
public static void main(String[] args) throws IOException {
FileWriter fw = new FileWriter("09_IOAndProperties\\f.txt");
char[] cs = {'a', 'b', 'c', 'd', 'e'};
// void write(char[] cbuf): 写入字符数组。
fw.write(cs); // abcde
// void write(char[] cbuf, int off, int len): 写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
fw.write(cs, 1, 3); // bcd
// void write(String str): 写入字符串。
fw.write("德玛西亚"); // 德玛西亚
// void write(String str, int off, int len): 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
fw.write("诺克萨斯之手", 0, 4); // 诺克萨斯
fw.close();
}
}
续写和换行,跟【字节输出流】是一摸一样的
-
续写:要使用下面带有两个参数的构造方法
-
FileWriter(String name, boolean append)
:创建一个向具有指定 name 的文件中写入数据的输出文件流。 -
FileWriter(File file, boolean append)
:创建一个向指定 File 对象表示的文件中写入数据的文件输出流。 -
换行写:要加上换行符号
windows:\r\n
linux:/n
mac:/r
FileWriter fw = new FileWriter("09_IOAndProperties\\g.txt",true);
for (int i = 0; i <10 ; i++) {
fw.write("HelloWorld"+i+"\r\n");
}
fw.close();
4.3 flush方法和close方法的区别
- flush :刷新缓冲区,流对象可以继续使用。
- close : 先刷新缓冲区,然后通知系统释放资源,流对象不可以再被使用了。
四、IO异常处理
回到目录
之前的练习,一直throws把异常抛出,而实际开发中并不能这样处理,建议使用try...catch...finally
代码块来处理异常部分
1、JDK7之前,处理IO异常很麻烦
在JDK7之前使用try...catch...finally
处理流中的异常,非常麻烦
格式:
try{
可能会产出异常的代码
}catch(异常类变量 变量名){
异常的处理逻辑
}finally{
一定会执行的代码
资源释放
}
public class Demo01TryCatch {
public static void main(String[] args) {
// 提高变量fw的作用域, 让finally可以使用
// 变量在定义的时候, 可以没有值, 但是使用变量的时候,必须有值
FileWriter fw = null;
try{
// 可能会产出异常的代码
fw = new FileWriter("w:\\09_IOAndProperties\\g.txt",true);
for (int i = 0; i <10 ; i++) {
fw.write("HelloWorld"+i+"\r\n");
}
}catch(IOException e){
// 异常的处理逻辑
System.out.println(e); // 直接打印异常
}finally {
// 一定会执行的代码
// 创建对象失败了, fw的默认值就是null, null是不能调用方法的, 会抛出NullPointerException,
// 需要增加一个判断, 如果fw不是null再把资源释放
if(fw!=null){
try {
// fw.close方法声明抛出了IOException异常对象, 所以我们就的处理这个异常对象, 要么throws, 要么try...catch
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
2、JDK7处理IO异常的新特性
在try的后边可以增加一个(),在括号中可以定义流对象,那么这个流对象的作用域就在try中有效,try中的代码执行完毕,会自动把流对象释放,不用写finally(省了一大堆代码)
格式:
try(定义流对象; 定义流对象....){
可能会产出异常的代码
}catch(异常类变量 变量名){
异常的处理逻辑
}
public class Demo02JDK7 {
public static void main(String[] args) {
try ( // 1.创建一个字节输入流对象, 构造方法中绑定要读取的数据源
FileInputStream fis = new FileInputStream("c:\\1.jpg");
// 2.创建一个字节输出流对象, 构造方法中绑定要写入的目的地
FileOutputStream fos = new FileOutputStream("d:\\1.jpg");) {
// 可能会产出异常的代码
// 一次读取一个字节写入一个字节的方式
// 3.使用字节输入流对象中的方法read读取文件
int len = 0;
while ((len = fis.read()) != -1) {
// 4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
fos.write(len);
}
} catch (IOException e) {
//异常的处理逻辑
System.out.println(e);
}
}
}
3、JDK9处理IO异常的新特性
try的前边可以定义流对象,在try后边的()中可以直接引入流对象的名称(变量名),在try代码执行完毕之后,流对象也可以释放掉,不用写finally
格式:
A a = new A();
B b = new B();
try(a, b){
可能会产出异常的代码
} catch(异常类变量 变量名){
异常的处理逻辑
}
public static void main(String[] args) throws IOException {
// 1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
FileInputStream fis = new FileInputStream("c:\\1.jpg");
// 2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
FileOutputStream fos = new FileOutputStream("d:\\1.jpg");
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);
}
}
五、属性集
1、Properties集合概述
java.util.Properties集合
继承Hashtable
,表示一个持久的属性集。虽然Hashtab集合被HashMap集合淘汰了,但Properties集合依旧活跃。
java.util.Properties集合 extends Hashtable<k,v> implements Map<k,v>
Properties
是一个唯一和IO流相结合的集合
- 可以使用Properties集合中的方法store,把集合中的临时数据,持久化写入到硬盘中存储
- 可以使用Properties集合中的方法load,把硬盘中保存的文件(键值对),读取到集合中使用
- Properties集合是一个双列集合,key和value默认都是字符串
2、Properties集合的使用
使用Properties集合存储数据,遍历取出Properties集合中的数据
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集合对象
Properties prop = new Properties();
//使用setProperty往集合中添加数据,只能传字符串类型
prop.setProperty("赵丽颖", "168"); // prop.put(1,true); 可以使用,但那不是特有的方法
prop.setProperty("迪丽热巴", "165");
prop.setProperty("古力娜扎", "160");
// 使用 stringPropertyNames方法 把 Properties集合 中的【键】取出, 存储到一个 Set集合
Set<String> set = prop.stringPropertyNames();
// 遍历Set集合, 取出 Properties集合 的每一个键
for (String key : set) {
// 使用 getProperty方法通过key获取value
String value = prop.getProperty(key);
System.out.println(key + "=" + value);
}
}
3、Properties集合中的store方法
可以使用Properties集合中的方法store, 把集合中的临时数据, 持久化写入到硬盘中存储
void store(OutputStream out, String comments)
:OutputStream out: 【字节输出流】 不能写中文void store(Writer writer, String comments)
:Writer writer: 【字符输出流】可以写中文
String comments: 注释, 用来解释说明保存的文件是做什么用的。不能使用中文, 会产生乱码,默认是Unicode编码,一般使用空字符串("")
使用步骤:
- 创建Properties集合对象, 添加数据
- 创建【字节输出流 / 字符输出流】对象, 构造方法中绑定要输出的目的地
- 使用Properties集合中的方法store, 把集合中的临时数据, 持久化写入到硬盘中存储
- 释放资源
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("09_IOAndProperties\\prop.txt");
// 3.使用Properties集合中的方法store, 把集合中的临时数据, 持久化写入到硬盘中存储
prop.store(fw, "save data");
// 4.释放资源
fw.close();
}
3、Properties集合中的load方法
可以使用Properties集合中的方法load, 把硬盘中保存的文件(键值对), 读取到集合中使用
void load(InputStream inStream)
:InputStream inStream: 字节输入流, 不能读取含有中文的键值对void load(Reader reader)
:Reader reader: 字符输入流, 能读取含有中文的键值对
使用步骤:
- 创建Properties集合对象
- 使用Properties集合对象中的load方法读取保存键值对的文件
- 遍历Properties集合
注意:
- 存储键值对的【文件中】, 键与值默认的连接符号多使用 =、空格(或其他符号)
- 存储键值对的【文件中】, 可以使用 # 进行注释, 被注释的键值对不会再被load读取
- 存储键值对的【文件中】, 键与值默认都是字符串, 不用再加引号
private static void show03() throws IOException {
// 1.创建Properties集合对象
Properties prop = new Properties();
// 2.使用Properties集合对象中的方法load读取保存键值对的文件
prop.load(new FileReader("09_IOAndProperties\\prop.txt")); // 多用字符流,可以读取汉字
// 3.遍历Properties集合
Set<String> set = prop.stringPropertyNames();
for (String key : set) {
String value = prop.getProperty(key);
System.out.println(key + "=" + value);
}
}