Java IO流专题
目录
InputStream 字节输入流（以FilelnputStream为例）
OutputStream 字节输出流（以FileOutputStream 为例）
处理流-BufferedReader和BufferedWriter
处理流-BufferedlnputStream和BufferedOutputStream
对象处理流-objectlnputStream和objectOutputStream
处理流-标准输入输出流（System.in&System.out）
转换流-InputStreamReader和OutputStreamWriter
本篇文章包括以下知识点，是看视频做的笔记
常见IO流体系
文件
文件在程序中是以流的形式来操作的
流：数据在数据源（文件、数据库等）和程序（内存）之间经历的路径
输入流：数据从数据源（文件）到程序（内存）的路径
输出流：数据从程序（内存）到数据源（文件）的路径
注意：
数据源不只有文件一种，比如数据库，其他程序传递过来的数据等，文件只是数据源的其中一种
这里的输入输出是相对于内存而言，打个比方，我是内存，我要吃东西，那么吃进来的这个动作就是输入，如果太难吃了吐出来，那么吐出来这个动作就是输出，这里的输入输出是相对于我来说的（此时假设我是个内存）。我总结的经验是，要相对于谁，就把自己当做谁，然后往自己这个方向来的就是输入，从自己这出去的就是输出
Java中的IO操作一般都是相对内存的，所以本文里也默认是相对内润来说的
常用的文件操作
涉及到的就是java.io.File这个类，可以在idea里查看这个类的类图、构造方法等信息。
创建文件
- newFile（Stringpathname）//根据路径构建一个File对象
- newFile（Fileparent,Stringchild）//根据父目录文件+子路径构建
- newFile（Stringparent,Stringchild）//根据父目录+子路径构建
在E盘上分别以上面三种方式创建三个文件，代码如下，试了一下，如果文件已经存在，就不会再创建了
import java.io.File;
import java.io.IOException;
public class CreateFile {
public static void main(String[] args) throws IOException {
// 在盘上分别以三种不同的方式创建文件a1.txt、a2.txt、a3.txt
CreateFile obj = new CreateFile();
obj.create01();
obj.create02();
obj.create03();
}
// newFile（Stringpathname）//根据路径构建一个File对象
public void create01() throws IOException {
String fileName = "e:\\a1.txt";
// 在内存里创建了一个File对象，此时并没有真正的在磁盘里创建文件
File file = new File(fileName);
// 调用createNewFile方法才会真正的在磁盘上创建文件，
// 该方法可能会抛出IOException异常，需要try或抛出去
file.createNewFile();
}
// newFile（Fileparent,Stringchild）//根据父目录文件+子路径构建
public void create02() throws IOException {
File parentFile = new File("e:\\");
String fileName = "a2.txt";
// 在内存里创建了一个File对象，此时并没有真正的在磁盘里创建文件
File file = new File(parentFile, fileName);
// 调用createNewFile方法才会真正的在磁盘上创建文件，
// 该方法可能会抛出IOException异常，需要try或抛出去
file.createNewFile();
}
// newFile（Stringparent,Stringchild）//根据父目录+子路径构建
public void create03() throws IOException {
String parentName = "e:\\";
String fileName = "a3.txt";
// 在内存里创建了一个File对象，此时并没有真正的在磁盘里创建文件
File file = new File(parentName, fileName);
// 调用createNewFile方法才会真正的在磁盘上创建文件，
// 该方法可能会抛出IOException异常，需要try或抛出去
file.createNewFile();
}
}获取文件的相关信息
以下只列举了几个常用的，其他的可以查看File类
- getName：获取文件名字
- getAbsolutePath：获取文件的绝对路径
- getParent：获取文件的父目录
- length：获取文件的大小
- exists：文件是否存在
- isFile：是不是文件
- isDirectory：是不是目录
class FileInfo {
public static void main(String[] args) {
String fileName = "e:\\a1.txt";
File file = new File(fileName);
System.out.println("文件名：" + file.getName());
System.out.println("文件的绝对路径：" + file.getAbsolutePath());
System.out.println("文件的父目录：" + file.getParent());
System.out.println("文件的大小：" + file.length());
System.out.println("文件是否存在：" + file.exists());
System.out.println("是不是文件：" + file.isFile());
System.out.println("是不是目录：" + file.isDirectory());
}
}目录操作
以下方法也是通过File对象进行操作的，不写具体代码了，类似上面的。
- mkdir()：创建一级目录
- mkdirs()：创建多级目录
- delete()：删除文件或空目录
IO流
1/O是lnput/Output的缩写，1/o技术是非常实用的技术，用于处理数据传输如读/写文件，网络通讯等。Java程序中，对于数据的输入/输出操作以”流（stream)”的方式进行。
java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过相应的方法输入或输出数据。
IO流的分类
- 按操作数据单位不同分为：字节流（8bit）按字节读取，一般用于操作二进制文件；字符流（按字符读取），一般用于操作文本文件
- 按数据流的流向不同分为：输入流，输出流
- 按流的角色的不同分为：节点流，处理流/包装流
IO流的四个抽象基类
| （抽象基类） | 字节流 | 字符流 |
|---|---|---|
| 输入流 | InputStream | Reader |
| 输出流 | OutputStream | Writer |
1）Java的lO流共涉及40多个类，实际上非常规则，都是从如上4个抽象基类派生的。
2）由这四个类派生出来的子类名称都是以其父类名作为子类名后缀
InputStream 字节输入流（以FilelnputStream为例）
InputStream抽象类是所有字节输入流类的超类。
InputStream常用的子类
- FilelnputStream:：文件输入流
- BufferedlnputStream：缓冲字节输入流
- ObjectlnputStream：对象字节输入流
它们的类图关系如下
以FilelnputStream为例，完成需求：请使用FilelnputStream读取E盘上的hello.txt文件，并将文件内容显示到控制台，代码如下。FilelnputStream还有其他的构造器和方法，以下只是演示基本使用，有其他的需求可以自己在idea查看或者百度。BufferedlnputStream和ObjectlnputStream使用也是类似的，这里不再演示。
import java.io.FileInputStream;
import java.io.IOException;
class FileInputStream_ {
public static void main(String[] args) {
readFile();
}
public static void readFile() {
String filePath = "e:\\hello.txt";
int read = 0;
int readLen = 0;
byte[] buf = new byte[8];
FileInputStream fileInputStream = null;
try {
// 创建对象FileInputStream
// FileInputStream还有其他的构造器，自行查询
fileInputStream = new FileInputStream(filePath);
// read()方法每次读取一个字节并返回，如果读取到文件末尾就返回-1
// 一般一个汉字对应着几个字节（具体对应几个根据编码确定）
// 所以如果读取的文件中包含中文，这种单个字节读取的方式会输出乱码
// while ((read = fileInputStream.read()) != -1) {
// // read()返回的int类型，将其转成char
// System.out.print((char) read);
// }
// System.out.println();
// read(buf)将每次读取的内容放到字节数组buf中，每次最多读取buf.length（这里字节数组长度为8）个字节
// 返回值为实际读取的字节数，比如最后还剩下6个字节没读，那么readLen的值为6
// 读到文件末尾，返回-1
while ((readLen = fileInputStream.read(buf)) != -1) {
// 将字节数组buf转为字符串输出，从buf的第0个位置开始，截取readLen个字节进行转换
System.out.print(new String(buf, 0, readLen));
}
System.out.println();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
// 关闭对象流
fileInputStream.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}OutputStream 字节输出流（以FileOutputStream 为例）
OutputStream 抽象类是所有字节输出流类的超类。
OutputStream 常用的子类
- FileOutputStream ：文件输出流
类图关系如下
完成需求：使用FileOutputStream在a.txt文件中写入“hello，world”，如果文件不存在，会创建文件（注意：前提是目录已经存在.），代码如下。
class FileOutputStream01 {
public static void main(String[] args) {
writeFile();
}
public static void writeFile() {
String filePath = "e:\\a.txt";
FileOutputStream fileOutputStream = null;
try {
// 如果a.txt文件不存在会创建，前提是它的父目录要存在
// 默认情况下，写入的内容会覆盖文件原先的内容
// 如果想在文件末尾追加而不是覆盖，可以传入true给参数append，即
// new FileOutputStream(filePath, true);
fileOutputStream = new FileOutputStream(filePath);
// 向文件中写入一个字节
// write()方法接收一个int类型，字符a会转成int类型
// fileOutputStream.write('a');
String s = "hello, world!";
// 向文件中写入一个字节数组
// 字符串的getBytes()方法会返回一个字符串s对应的字节数组
// fileOutputStream.write(s.getBytes());
// 向文件中写入一个字节数组的指定位置的数据
// 从字节数组的第一个位置开始（索引从0开始），写入3个字节，即写入“ell”
fileOutputStream.write(s.getBytes(), 1, 3);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
// 关闭文件流
fileOutputStream.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}Reader 字符输入流（以FileReader为例）
Reader抽象类是所有字符输入流类的超类。
Reader常用的子类的类图如下
以FileReader为例讲解，FileReader是字符流，按照字符来操作io。FileReader相关方法如下：
- new FileReader(File / String)：通过一个File对象或文件路径字符串构建FileReader对象
- read()：每次读取单个字符，返回该字符，如果到文件末尾返回-1
- read(char[l)：批量读取多个字符到数组，返回读取到的字符数，如果到文件末尾返回-1
相关API：
- new String(char[])：:将字节数组转换成String
- new String(char[]，off，len)：:将字节数组的指定部分转换成String
使用FileReader从story.txt读取内容（有中文也有英文），并显示，代码如下
class FileReader01 {
public static void main(String[] args) {
readFile();
}
public static void readFile() {
String filePath = "e:\\story.txt";
FileReader fileReader = null;
int read = 0;
char[] cbuf = new char[1024];
try {
// 可以通过文件路径或者File对象创建
fileReader = new FileReader(filePath);
// 单个字符读取
// 如果中文还是乱码就是文件编码和控制台编码不一致，统一一下就好
// while ((read = fileReader.read()) != -1) {
// System.out.print((char) read);
// }
// System.out.println();
// 读取到字符数组，返回实际读取的数据长度
while ((read = fileReader.read(cbuf)) != -1) {
System.out.print(new String(cbuf, 0, read));
}
System.out.println();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
// 关闭文件流
fileReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}Writer 字符输出流(以FileWriter为例讲解)
Writer 抽象类是所有字符输出流类的超类。
Writer 常用的子类的类图如下
以FileWriter为例讲解，FileWriter是字符流，按照字符来操作io。FileWriter常用方法如下
- new FileWriter(File/String)：覆盖模式，相当于流的指针在首端
- new FileWriter(File/String,true)：追加模式，相当于流的指针在尾端
- write(int)：写入单个字符
- write(char[])：写入指定数组
- write(char[l，off，len)：写入指定数组的指定部分
- write(string)：写入整个字符串
- write(string，off，len)：写入字符串的指定部分
相关APl：String类的toCharArray()方法，将String转换成char[]
注意：FileWriter使用后，必须要关闭（close）或刷新（flush），否则写入不到指定的文件
向一个node.txt文件写入一句话“风雨之后，才能见彩虹”，代码如下
class FileWriter01 {
public static void main(String[] args) {
writeFile();
}
public static void writeFile() {
String filePath = "e:\\note.txt";
FileWriter fileWriter = null;
try {
// 如果想要在文件中追加内容，写为：new FileWriter(filePath, true);
// 以下会覆盖文件内容
fileWriter = new FileWriter(filePath);
// 向文件写入一个字符
// fileWriter.write('你');
String s = "风雨之后，才能见彩虹";
// 向文件写入字符串
// fileWriter.write(s);
// 向文件写入字符串的指定部分
// fileWriter.write(s, 0, s.length());
// 向文件写入一个字符数组
// fileWriter.write(s.toCharArray());
// 向文件写入一个字符数组的指定部分
fileWriter.write(s.toCharArray(), 0, 5);
// 刷新
fileWriter.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}节点流和处理流
节点流：可以从一个特定的数据源（数据源就是存在数据的地方，数据源有文件、数组、管道等）读写数据，如FileReader/FileWriter等。
处理流：也叫包装流，是“连接”在已存在的流（节点流或处理流）之上，为程序提供更为强大的读写功能（我的理解就是对节点流进行了包装，提供了更多的功能，节点流和处理流类似int和integer的关系），如BufferedReader、BufferedWriter。
以BufferedReader为例，BufferedReader中有一个类型是Reader的in属性，这个in就可以接收所有的Reader的子类对象，比如FileReader、CharArrayReader等，也就是说通过BufferedReader这个包装流，就可以处理文件、数组等多种数据源，不再像节点流那样，单个节点流只可以处理单一的数据源，也就提供了更强大的功能。其他包装流也同理，可以自己看一下它们的源码。
常见的节点流和处理流如下图所示
节点流和处理流的区别和联系
- 节点流是底层流/低级流，直接跟数据源相接
- 处理流（包装流）包装节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入输出
- 处理流（也叫包装流）对节点流进行包装，使用了修饰器设计模式，不会直接与数据源相连
处理流的功能主要体现在以下两个方面：
- 性能的提高：主要以增加缓冲的方式来提高输入输出的效率
- 操作的便捷：处理流可能提供了一系列便捷的方法来一次输入输出大批量的数据，使用更加灵活方便
处理流-BufferedReader和BufferedWriter
BufferedReader和BufferedWriter属于字符流，是按照字符来读取数据的，关闭时，只需要关闭外层流即可。它们的类图可以自己在idea里查看
class Buffered01 {
public static void main(String[] args) throws IOException {
readFile();
writeFile();
}
// 用BufferedReader读取文本文件，并显示在控制台
public static void readFile() throws IOException {
String filePath = "e:\\story.txt";
BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
String line;
// BufferedReader有很多重载的read()方法，这里只用了一种
// readLine()按行读取文件，当到达文件末尾时，返回null
while ((line = bufferedReader.readLine()) != null) {
System.out.println(line);
}
// 关闭流对象，只需要关闭外层流BufferedReader即可
// 因为外层流的close方法里会调用内层流FileReader的close方法，可以debug验证
bufferedReader.close();
}
// 用BufferedWriter将”早日发家致富“写入文件note.txt
public static void writeFile() throws IOException {
String filePath = "e:\\note.txt";
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));
String s = "早日发家致富";
// BufferedWriter有很多重载的write()方法，这里只用了一种
bufferedWriter.write(s);
bufferedWriter.newLine(); // 插入一个换行
// 关闭外层流
bufferedWriter.close();
}
}处理流-BufferedlnputStream和BufferedOutputStream
BufferedlnputStream和BufferedOutputStream是字节流，是按照字节进行处理的，用法和BufferedReader和BufferedWriter差不多，这里不再写代码。
对象处理流-objectlnputStream和objectOutputStream
序列化和反序列化
- 序列化就是在保存数据时，保存数据的值和数据类型，简单说就是将Java对象保存为字符串
- 反序列化就是在恢复数据时，恢复数据的值和数据类型，简单说就是将字符串还原成对应的Java对象
注意：需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现两个接口之一：Serializable（这是一个标记接口，也就是只起到声明的作用，接口内没有任何的方法，一般推荐使用这个接口），Externalizable
比如一个Dog类对象dog想要序列化，就需要Dog类实现上面两个接口之一
objectlnputStream和objectOutputStream提供了对基本类型或对象类型的序列化和反序列化的方法，ObjectOutputStream提供序列化功能，ObjectlnputStream提供反序列化功能。
objectlnputStream和objectOutputStream操作注意事项：
- 读写顺序要一致，即序列化的顺序是怎样的，反序列化的时候也要是同样的顺序
- 要求序列化或反序列化的对象，需要实现Serializable接口
- 序列化的类中建议添加SerialVersionUiD，为了提高版本的兼容性
- 序列化对象时，默认将里面所有属性都进行序列化，除了static或transient修饰的成员
- 序列化对象时，要求里面属性的类型也需要实现序列化接口
- 序列化具备可继承性，也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化
应用实例代码如下
class ObjectInputAndOutputStream {
public static void main(String[] args) throws IOException, ClassNotFoundException {
saveObj();
getObj();
}
// 使用ObjectOutputStream序列化一个Dog对象(name, age)，并保存到data.dat文件中
public static void saveObj() throws IOException {
String filePath = "e:\\data.dat";
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
Dog dog = new Dog("旺财", 1);
// 向文件中保存基本数据类型
oos.writeInt(100); // int 转成 Integer（实现了 Serializable)
oos.writeBoolean(true); // boolean 转成 Boolean（实现了 Serializable）
oos.writeChar('a'); // char 转成 Character（实现了 Serializable)
oos.writeDouble(9.5); // double 转成 Double（实现了 Serializable）
oos.writeUTF("hello, world!"); // String（实现了 Serializable）
// 调用方法writeObject()将dog对象写入文件
oos.writeObject(dog);
// 关闭流对象
oos.close();
}
// 使用将文件data.dat反序列化成一个Dog对象(name, age)
public static void getObj() throws IOException, ClassNotFoundException {
String filePath = "e:\\data.dat";
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));
// 注意，反序列化读取时的顺序要和存入的顺序一致，否则会报错
// 读取文件中的基本数据类型
System.out.println(ois.readInt());
System.out.println(ois.readBoolean());
System.out.println(ois.readChar());
System.out.println(ois.readDouble());
System.out.println(ois.readUTF());
// 读取文件中的数据并反序列化为Dog对象
Object obj = ois.readObject();
System.out.println(obj);
// 关闭流对象
ois.close();
}
}
// Dog的实例对象要想是实现序列化和反序列化，类必须实现接口Serializable
class Dog implements Serializable {
private String name;
private int age;
// seriaLVersionUID 序列化的版本号，可以提高兼容性
private static final long serialVersionuID = 1L;
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "[name=" + name + ", age=" + age + "]";
}
}处理流-标准输入输出流（System.in&System.out）
见代码注释
class Standard_ {
public static void main(String[] args) {
// 标准输入，键盘
// 传统的方法，Scanner是从标准输入键盘接收数据
// 看源码可以看到System.in的定义： public final static InputStream in
// 所以System.in的编译类型是InputStream
// 下面的输出可以知道System.in的运行类型是BufferedInputStream
System.out.println(System.in.getClass());
// 标准输出，输出到显示屏
// 传统方法System.out.println()"")；是使用out对象将数据输出到显示器
// System.out的定义：public final static PrintStream out
// System.out的编译类型是PrintStream，运行类型也是PrintStream
System.out.println(System.out.getClass());
}
}之前有一次我用标准输入流创建了两个Scanner 对象，如下，当我关闭其中一个s1时，就不能再输入数据，即使此时s2还存在，现在好像明白原因了：因为System.in是final static修饰的，也就是s1和s2共用一个标准输入流，当s1关闭时，也就把System.in关掉了，所以s2想再用这个流对象时，已经不存在了，所以抛出NoSuchElementException的异常
Scanner s1 = new Scanner(System.in);
Scanner s2 = new Scanner(System.in);
System.out.println("请输入1：");
String input1 = s1.nextLine();
System.out.println(input1);
s1.close();
System.out.println("请输入2：");
String input2 = s2.nextLine(); // 这一行代码会抛出异常
System.out.println(input2);
s2.close();
转换流-InputStreamReader和OutputStreamWriter
顾名思义，也就是把字节流转成字符流，从这两个流的名字也可以看出来。转换流可以用来解决中文乱码问题，乱码问题主要是编码方式不同造成的，而字节流可以指定编码方式，我们可以给字节流指定对应的编码方式之后转成字符流进行操作，这样就不会乱码了.
- InputStreamReader：Reader的子类，可以将InputStream（字节流）包装成（转换）Reader（字符流）
- OutputStreamWriter：Writer的子类，实现将OutputStream（字节流）包装成Writer（字符流）
- 当处理纯文本数据时，使用字符流效率更高，并且可以有效解决中文问题，所以建议将字节流转换成字符流，可以在使用时指定编码格式（比如utf-8，gbk，gb2312,Is08859-1等）
class Test01 {
public static void main(String[] args) throws IOException {
readFile();
writeFile();
}
// 将字节流FilelnputStream包装成字符流lnputStreamReader
// 对文件进行读取（按照utf-8格式），进而再包装成BufferedReader
public static void readFile() throws IOException {
String filePath = "e:\\a.txt";
// 创建InputStreamReader对象，并指定字节流的编码方式为utf-8，这是一个包装流
InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), "utf-8");
// 再将isr包装成BufferedReader，BufferedReader也是个包装流
BufferedReader br = new BufferedReader(isr);
String line = br.readLine();
System.out.println(line);
// 关闭最外层的BufferedReader流即可
br.close();
}
// 编程将字节流FileOutputStream包装成字符流OutputStreamWriter
// 对文件进行写入（按照gbk格式，也可以指定其他）
public static void writeFile() throws IOException {
String filePath = "e:\\hello.txt";
// 创建对象并指定编码格式
// 运行之后可以查看文件的编码格式是否是gbk
OutputStreamWriter oiw = new OutputStreamWriter(new FileOutputStream(filePath), "gbk");
String s = "你好呀你好呀";
oiw.write(s);
oiw.close();
}
}打印流-PrintStream和PrintWriter
因为是打印的，所以只有输出没有输入，PrintStream处理字节流，PrintWriter处理字符流。
class Print_ {
public static void main(String[] args) throws IOException {
printStream_();
printWriter_();
}
public static void printStream_() throws IOException {
PrintStream out = System.out;
// 在默认情况下，PrintStream输出数据的位置是标准输出，即显示器
/*
* 查看print()方法的源码，如下，可以知道最终调用的是write方法
* public void print(String s) {
* if (s == null) {
* s = "null";
* }
* write(s);
* }
*/
out.println("hi~");
// 我们也可以直接调用write()方法进行输出/打印，与print方法等价
out.write("hello".getBytes());
out.close();
// 不止可以输出到显示器
// 也可以通过System.setOut()方法修改输出流的输出位置，比如输出到文件等
// 输出到一个文件里，
// 设置之前需要先关闭原来打开的流，不然设置不起作用
System.setOut(new PrintStream("e:\\a.txt"));
// "abcdefaf" 就会输出到文件a.txt中，即写入文件
System.out.println("abcdefaf");
}
public static void printWriter_() throws IOException {
// 传入System.out标准输出，也就是PrintStream创建一个PrintWriter对象
PrintWriter pWriter = new PrintWriter(System.out);
// 原本应该是输出到控制台的，但是在上面的printStream_方法中更改了输出的位置
// 并且是先调用了printStream_方法再调用本方法，所以这里的"hello, world"会输出到a.txt文件中
// 如果单独调用本方法，"hello, world"就会输出到控制台
// 因为System.out是final static修饰的，所以上面的修改在这里也生效
pWriter.print("hello, world");
// 注意，必须要关闭或者调用flush方法，否则就不会输出内容
pWriter.close();
// 输出到文件
PrintWriter pWriter2 = new PrintWriter(new FileWriter("e:\\b.txt"));
pWriter2.println("大家好！");
// 注意，必须要关闭或者调用flush方法，否则就不会输出内容
pWriter2.close();
}
}Properties 类
如下一个配置文件mysql.properties，使用Properties类可以方便的读取ip、user和pwd的值
ip=192.168.0.13
user=root
pwd=12345
Properties 是专门用于读写配置文件的集合类，要求配置文件的格式为：
键1=值1
键2=值2
注意：键值对不需要有空格，值不需要用引号一起来。默认类型是String
Properties的常见方法：
- load()：加载配置文件的键值对到Properties对象，可以传入字符流或字节流，具体可以看该方法接收的形参类型
- list()：将数据显示到指定设备，可以查看该方法的形参就知道可以输出到哪些地方去
- getProperty(key)：:根据键获取值
- setProperty(key, value)：设置键值对到Properties对象，如果key已经存在，就是修改key的值，如果不存在，就是新增key
- store()：将Properties中的键值对存储到配置文件，在idea中，保存信息到配置文件，如果含有中文，会存储为unicode码
class Properties_ {
public static void main(String[] args) throws IOException {
// 使用Properties类完成对mysql.properties的读取
// 1.创建对象
Properties p = new Properties();
// 2.加载指定的配置文件
p.load(new FileReader("io_\\mysql.properties"));
// 3.输出配置文件的内容到控制台（也可以输出到其他地方）
p.list(System.out);
// 4.根据键名获取值
System.out.println(p.getProperty("user"));
// 使用Properties类添加key-val到新文件mysql2.properties中
p.store(new FileWriter("io_\\mysql2.properties"), "保存配置");
// 使用Properties类修改和某个key-val
// 原先不存在port这个key，那么setProperty()就是新增一个新的key-val
p.setProperty("port", "3306");
// 修改密码，pwd已经存在，所以setProperty()就是在修改pwd的值
p.setProperty("pwd", "root");
p.list(System.out);
}
}原文地址：https://blog.csdn.net/2301_77659011/article/details/143484287
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！