Java进阶——IO流

IO流

一、文件

1.1、文件流

文件在程序中是以流的形式来操作的

• 流：数据在数据源（文件）和程序（内存）之间经历的路径
• 输入流：数据从数据源（文件）到程序（内存）的路径
• 输入流：数据从程序（内存）到数据源（文件）的路径

1.2、常用的文件操作

1.2.1、创建文件对象相关构造和方法

• new File(String pathname) // 根据路径构建一个File对象
• new File(File parent, String child) // 根据父目录文件+子路径构建
• new File(String parent, String child) // 根据父目录+子路径构建

import org.junit.jupiter.api.Test;import java.io.File;import java.io.IOException;/** * @author java小豪 * @version 1.0.0 * @date 2022/11/13 * @description 实操创建文件的三种方法 */public class FileCreate { public static void main(String[] args) { } /** * 方式一 new File(String pathname) // 根据路径构建一个File对象 */ @Test public void create01() { String filePath = "F:\\file\\test01.txt"; File file = new File(filePath); try { file.createNewFile(); System.out.println("文件创建成功！！！"); } catch (IOException e) { e.printStackTrace(); } } /** * 方式二 new File(File parent, String child) // 根据父目录文件+子路径构建 */ @Test public void create02() { File parentFile = new File("F:\\file\\"); String fileName = "test02.txt"; File file = new File(parentFile, fileName); try { file.createNewFile(); System.out.println("文件创建成功！！！"); } catch (IOException e) { e.printStackTrace(); } } /** * 方式三 new File(String parent, String child) // 根据父目录+子路径构建 */ @Test public void create03() { String parentPath = "F:\\"; String filePath = "file\\test03.txt"; File file = new File(parentPath, filePath); try { file.createNewFile(); System.out.println("文件创建成功！！！"); } catch (IOException e) { e.printStackTrace(); } }}

1.2.2、获取文件的相关信息

• getName：获取文件的名字
• getAbsolutePath：获取文件的绝对路径
• getParent：获得文件的父级目录
• length：获取文件的大小（返回字节数）
• exists：判断文件是否存在
• isFile：判断是否是一个文件
• isDirectory：是不是一个目录

import org.junit.jupiter.api.Test;import java.io.File;/** * @author java小豪 * @version 1.0.0 * @date 2022/11/13 * @description 获取文件的基本信息 */public class FileInformation { public static void main(String[] args) { } /** * 获取文件信息 */ @Test public void info() { // 先创建文件对象 File file = new File("F:\\file\\test01.txt"); // 调用相应的方法，得到对应的信息 System.out.println("文件名 = " + file.getName()); System.out.println("文件绝对路径 = " + file.getAbsolutePath()); System.out.println("文件父级目录 = " + file.getParent()); System.out.println("文件大小(字节) = " + file.length()); // true System.out.println("文件是否存在 = " + file.exists()); // true System.out.println("是不是一个文件 = " + file.isFile()); // false System.out.println("是不是一个目录 = " + file.isDirectory()); }}

运行结果：

1.2.3、目录的操作和文件删除

• mkdir创建一级目录
• mkdirs创建多级目录
• delete删除空目录或文件

import org.junit.jupiter.api.Test;import java.io.File;/** * @author java小豪 * @version 1.0.0 * @date 2022/11/13 * @description 目录操作 */public class Directory_ { public static void main(String[] args) { } /** * 判断 F:\\file\\test01.txt 是否存在，如果存在就删除 */ @Test public void m1() { String filePath = "f:\\file\\test01.txt"; File file = new File(filePath); if (file.exists()) { if (file.delete()) { System.out.println(filePath + "删除成功"); } else { System.out.println(filePath + "删除失败"); } } else { System.out.println("该文件不存在..."); } } /** * 判断 F:\\file1 是否存在，如果存在就删除 */ @Test public void m2() { String filePath = "f:\\file1"; File file = new File(filePath); if (file.exists()) { if (file.delete()) { System.out.println(filePath + "删除成功"); } else { System.out.println(filePath + "删除失败"); } } else { System.out.println("该目录不存在..."); } } /** * 判断 F:\\file1\\a\\b 是否存在，如果存在就提示已存在，否则就创建 */ @Test public void m3() { String directoryPath = "f:\\file1\\a\\b"; File file = new File(directoryPath); if (file.exists()) { System.out.println(directoryPath + "该目录已存在！！！"); } else { if (file.mkdirs()) { System.out.println(directoryPath + "该目录创建成功！！！"); } else { System.out.println(directoryPath + "该目录创建失败！！！"); } } }}

二、IO流原理及流的分类

2.1、Java IO流的原理

• I/O 是Input/Output的缩写，I/O技术是非常使用的技术，用于处理数据传输。
• Java程序中，对于数据的输入/输出操作以”流(stream)“的方式进行
• java.io包下提供了各种”流“类接口，用以获取不同种类的数据，并通过方法输入或输出数据

2.2、流的分类

• 按操作数据单位不同分为：字节流（8bit），字符流（按字符）
• 按数据流的流向不同分为：输入流，输出流
• 按流的角色不同分为：节点流，处理流/包装流

(抽象基类)

字节流

字符流

输入流

InputStream

Reader

输出流

OutputStream

Writer

2.3、IO流常用的类

2.3.1、InputStream：字节输入流

• InputStream抽象类是所有类字节输入流的超类
• InputStream常用的子类

• FileInputStream：文件输入流
• BufferedInputStream：缓冲字节输入流
• ObjectInputStream：对象字节输入流

FileInputStream常用的方法

代码演示：

import org.junit.jupiter.api.Test;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.IOException;import java.io.OutputStream;/** * @author java小豪 * @version 1.0.0 * @date 2022/11/13 * @description FileInputStream的使用 */public class FileInputStream_ { public static void main(String[] args) { } /** * 演示读取文件 * read只能读取单个字节 * -> 使用read(byte[] b)读取 */ @Test public void readFile1() { String filePath = "F:\\file\\hello.txt"; FileInputStream fileInputStream = null; try { // 创建FileInputStream 对象，用于读取文件 fileInputStream = new FileInputStream(filePath); int readData = 0; while ((readData = fileInputStream.read()) != -1) { // 转成char显示 System.out.print((char) readData); } } catch (IOException e) { e.printStackTrace(); } finally { // 关闭文件流，释放资源 if (fileInputStream != null) { try { fileInputStream.close(); } catch (IOException e) { e.printStackTrace(); } } } } /** * 使用read(byte[] b)读取文件，提高效率 */ @Test public void readFile2() { String filePath = "F:\\file\\hello.txt"; FileInputStream fileInputStream = null; try { // 创建FileInputStream 对象，用于读取文件 fileInputStream = new FileInputStream(filePath); int readLen = 0; // 定义字节数组 byte[] bytes = new byte[10]; // 如果返回-1，表示读取完毕 // 如果读取正常，返回实际读取的字节数 while ((readLen = fileInputStream.read(bytes)) != -1) { // 转成char显示 System.out.print(new String(bytes, 0, readLen)); } } catch (IOException e) { e.printStackTrace(); } finally { // 关闭文件流，释放资源 if (fileInputStream != null) { try { fileInputStream.close(); } catch (IOException e) { e.printStackTrace(); } } } }}

2.3.2、FileOutputStream常用的方法

• 创建FileOutputStream两种方式

• 1.如果 new FileOutputStream(filePath) 创建方式，当写入内容时，会覆盖原来的内容
• 2.如果 new FileOutputStream(filePath, true) 创建方式，当写入内容时，会追加到文件的末尾

• fileOutputStream.write('H')写入一个字节
• fileOutputStream.write(str.getBytes()); 写入字符串 str.getBytes() 可以把字符串 -> 字节数组
• write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。
• fileOutputStream.write(str.getBytes(), 0, str.length());

FileOutputStream的类图

演示代码：

import org.junit.jupiter.api.Test;import java.io.File;import java.io.FileOutputStream;import java.io.IOException;import java.io.OutputStream;/** * @author java小豪 * @version 1.0.0 * @date 2022/11/13 * @description OutputStream的演示 */public class FileOutputStream01 { public static void main(String[] args) { } /** * 演示使用FileOutputStream 将数据写到文件中， * 如果该文件不存在，则创建该文件 */ @Test public void writeFile() { // 创建 FileOutputStream对象 String filePath = "F:\\file\\a.txt"; FileOutputStream fileOutputStream = null; try { // 得到FileOutputStream 对象 // 1.如果 new FileOutputStream(filePath) 创建方式，当写入内容时，会覆盖原来的内容 // 2.如果 new FileOutputStream(filePath, true) 创建方式，当写入内容时，会追加到文件的末尾 fileOutputStream = new FileOutputStream(filePath); // 写入一个字节 // fileOutputStream.write('H'); // 写入字符串 String str = "Hello World!"; // str.getBytes() 可以把字符串 -> 字节数组 // fileOutputStream.write(str.getBytes()); /*write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。 */ fileOutputStream.write(str.getBytes(), 0, str.length()); } catch (IOException e) { e.printStackTrace(); } finally { if (fileOutputStream != null) { try { fileOutputStream.close(); } catch (IOException e) { e.printStackTrace(); } } } }}

FileInputStream和FileOutputStream综合演示

文件拷贝：

import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;/** * @author java小豪 * @version 1.0.0 * @date 2022/11/14 * @description 文件拷贝 */public class FileCopy { public static void main(String[] args) { // 完成文件拷贝 // 1.创建文件的输入流，将文件读入到程序 // 2.创建文件的输出流，将读取到的文件数据，写入到指定的文件 String srcFilePath = "源文件夹路径"; String destFilePath = "目标盘文件路径"; FileInputStream fileInputStream = null; FileOutputStream fileOutputStream = null; try { fileInputStream = new FileInputStream(srcFilePath); fileOutputStream = new FileOutputStream(destFilePath); // 定义一个字节数组 byte[] bytes = new byte[1024]; int readLen = 0; while ((readLen = fileInputStream.read(bytes)) != -1) { // 读取到后，就写入文件 通过 fileOutputStream fileOutputStream.write(bytes, 0, readLen); } System.out.println("拷贝成功！！"); } catch (IOException e) { e.printStackTrace(); } finally { try { // 关闭输入和输出流，关闭资源 if (fileInputStream != null) { fileInputStream.close(); } if (fileOutputStream != null) { fileOutputStream.close(); } } catch (IOException e) { throw new RuntimeException(e); } } }}

2.3.3、FileReader和FileWriter

FileReader和FileWriter是字符流，即按照字符来操作io

1、FileReader

相关方法：

• new FileReader(String/File)
• read:每次读取单个字符，返回该字符，如果到文件末尾返回-1
• read(char[])：批量读取多个字符到数组，返回读取到的字符数组，如果到文件末尾返回-1

相关API：

• new String(char[]): 将char[]转换成String
• new String(char[], off, len): 将char[] 的指定部分转换成String

代码演示：

import org.junit.jupiter.api.Test;import java.io.FileReader;import java.io.IOException;/** * @author java小豪 * @version 1.0.0 * @date 2022/11/14 * @description 字符输入流 */public class FileReader_ { public static void main(String[] args) { } /** * 单个字符读取文件 */ @Test public void readFile1() { String filePath = "F:\\file\\story.txt"; FileReader fileReader = null; int dataLen = 0; try { // 1.创建FileReader对象 fileReader = new FileReader(filePath); // 循环读取 单个字符读取 while ((dataLen = fileReader.read()) != -1) { System.out.print((char) dataLen); } } catch (IOException e) { e.printStackTrace(); } finally { try { if (fileReader != null) { fileReader.close(); } } catch (IOException e) { e.printStackTrace(); } } } /** * 字符数组读取文件 */ @Test public void readFile2() { String filePath = "F:\\file\\story.txt"; FileReader fileReader = null; int readLen = 0; char[] chars = new char[8]; try { // 1.创建FileReader对象 fileReader = new FileReader(filePath); // 循环读取 单个字符读取 while ((readLen = fileReader.read(chars)) != -1) { System.out.print(new String(chars, 0, readLen)); } } catch (IOException e) { e.printStackTrace(); } finally { try { if (fileReader != null) { fileReader.close(); } } catch (IOException e) { e.printStackTrace(); } } }}

2、FileWriter

关系类图：

相关方法：

• new FileWriter(File/String)：覆盖模式，相当于流的指针在首端
• new FileWriter(File/String, true)：追加模式，相当于流的指针在尾端
• writer(int)：写入单个字符
• writer(char[])：写入指定数组
• writer(char[], off, len)：写入指定数组的指定部分
• writer(String)：写入整个字符串
• writer(string, off, len)：写入字符串的指定部分

注意：FileWriter使用后必须要关闭(close)或刷新(flush)，否则写入不到指定的文件。

代码演示：

import org.junit.jupiter.api.Test;import java.io.FileWriter;import java.io.IOException;/** * @author java小豪 * @version 1.0.0 * @date 2022/11/14 * @description 文件写入 */public class FileWwriter_ { public static void main(String[] args) { } @Test public void fileWriter1() { String filePath = "F:\\file\\note.txt"; // 创建FileWriter对象 FileWriter fileWriter = null; char[] chars = {'a', 'b', 'c',}; try { fileWriter = new FileWriter(filePath); // 写入单个字符 fileWriter.write('H'); // 写入指定数组 fileWriter.write(chars); // 写入指定数组的指定部分 fileWriter.write("天苍苍，野茫茫".toCharArray(), 0, 3); // 写入整个字符串 fileWriter.write("你好信阳~"); // 写入字符串的指定部分 fileWriter.write("上海北京", 0, 2); } catch (IOException e) { e.printStackTrace(); } finally { try { if (fileWriter != null) { fileWriter.close(); } } catch (IOException e) { e.printStackTrace(); } } }}

三、节点流和处理流

基本介绍：

• 节点流和处理流

3.1、处理流BufferedReader和BufferedWriter

• BufferedReader和BufferedWriter属于字符流，是按照字符来读取数据的关闭时，只需要关闭外层

BufferedReader代码演示：

import org.junit.jupiter.api.Test;import java.io.BufferedReader;import java.io.FileNotFoundException;import java.io.FileReader;/** * @author java小豪 * @version 1.0.0 * @date 2022/11/16 * @description 处理流 */public class BufferedReader_ { public static void main(String[] args) { } @Test public void read() throws Exception { String filePath = "F:\\file\\story.txt"; // 创建BufferedReader对象 BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath)); // 读取 String line; // 说明 // 1.bufferedReader.readLine() 是按行读取文件 // 2.当返回null 时，表示文件读取完毕 while ((line = bufferedReader.readLine()) != null) { System.out.print(line); } // 关闭流 只需要关闭 BufferedReader, 因为底层会自动关闭 节点流 bufferedReader.close(); }}

**BufferedWriter代码演示：**不能处理二进制文件[pdf/word/声音/图片等]

import org.junit.jupiter.api.Test;import java.io.*;/** * @author java小豪 * @version 1.0.0 * @date 2022/11/16 * @description 文件拷贝 */public class BufferedCopy_ { public static void main(String[] args) { } @Test public void test() { String filePath = "F:\\file\\ok.txt"; String destFilePath = "F:\\file\\ok1.txt"; BufferedReader bufferedReader = null; BufferedWriter bufferedWriter = null; String line; try { bufferedReader = new BufferedReader(new FileReader(filePath)); bufferedWriter = new BufferedWriter(new FileWriter(destFilePath)); // readLine() 读取一行内容，但是没有换行 while ((line = bufferedReader.readLine()) != null) { // 每读取一行就写进去 bufferedWriter.write(line); // 插入一个换行 bufferedWriter.newLine(); } System.out.println("拷贝完毕...."); } catch (IOException e) { e.printStackTrace(); } finally { try { if (bufferedReader != null) { // 关闭流 bufferedReader.close(); } if (bufferedWriter != null) { // 关闭流 bufferedWriter.close(); } } catch (IOException e) { e.printStackTrace(); } } }}

3.2、处理流BufferedInputStream和BufferedOutputStream

• 使用BufferedInputStream和BufferedOutputStream可以完成二进制文件的拷贝

import org.junit.jupiter.api.Test;import java.io.*;/** * @author java小豪 * @version 1.0.0 * @date 2022/11/16 * @description 文件拷贝 */public class BufferedCopy1 { public static void main(String[] args) { } @Test public void copy() { String srcPath = "F:\\file\\1.jpg"; String destPath = "F:\\file\\2.jpg"; // 创建BufferedInputStream和BufferedOutputStream BufferedInputStream bis = null; BufferedOutputStream bos = null; try { bis = new BufferedInputStream(new FileInputStream(srcPath)); bos = new BufferedOutputStream(new FileOutputStream(destPath)); // 循环读取文件，并写入到 destPath byte[] bytes = new byte[1024]; int readLine = 0; // 当返回 -1 时表示读取完毕 while((readLine = bis.read(bytes)) != -1) { bos.write(bytes, 0, readLine); } System.out.println("文件拷贝完毕...."); } catch (IOException e) { e.printStackTrace(); } finally { // 关闭流，关闭外层的处理流 try { if (bis != null) { bis.close(); } if (bos != null) { bos.close(); } } catch (IOException e) { e.printStackTrace(); } } }}

3.3、对象流ObjectInputStream和ObjectOutputStream

• 序列化和反序列化

序列化就是在保存数据时，保存数据的值和数据类型

反序列化就是在恢复数据时，恢复数据的值和数据类型

需要让某个对象支持序列化，必须让其类是可序列化的，必须实现如下两个接口之一：Serializable(标记接口)和Externalizable

ObjectInputStream和ObjectOutputStream的类图：

---

使用ObjectOutputStream 序列化基本数据类行和一个Dog对象(name, age)并保存到data.dat文件里面

import java.io.*;/** * @author java小豪 * @version 1.0.0 * @date 2022/11/16 * @description ObjectOutputStream的使用 */public class ObjectOutputStream_ { public static void main(String[] args) throws IOException { // 序列化后保存的文件格式，不是纯文本，而是按照它的格式保存的 String filePath = "F:\\file\\data.dat"; ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream(filePath)); // 序列化数据 os.write(100); // 自动装箱boolean ----> Boolean (实现了 Serializable) os.writeBoolean(true); // 自动装箱char ----> Character (实现了 Serializable) os.writeChar('a'); os.writeUTF("java小豪"); // 保存一个Dog对象 os.writeObject(new Dog("旺财", 3)); os.close(); System.out.println("数据保存完毕(序列化形式)"); }}// 如果需要序列化某个类的对象，实现Serializableclass Dog implements Serializable { private String name; private int age; public Dog(String name, int age) { this.name = name; this.age = age; }}

• 注意事项

• 读写顺序要一致
• 要求实现序列化或反序列化对象实现Serializable
• 序列化对象时，默认将里面的所有属性都进行序列化，除了static或transient修饰的成员
• 序列化对象时，要求里面的属性的类型也需要实现序列化接口
• 序列化具备可继承性，也就是某类实现了序列化，他的所有子类也已经默认实现了序列化

3.4、标准输入输出流

• System.in和System.out

/** * @author java小豪 * @version 1.0.0 * @date 2022/11/16 * @description 标准输入和输出流 */public class InputAndOutput { public static void main(String[] args) { //System类里面的一个属性 public final static InputStream in = null; // 编译类型 为 InputStream 运行类型 BufferedInputStream System.out.println(System.in.getClass()); // System.out 是 public final static PrintStream out = null; // 编译类型 为 PrintStream 运行类型 为PrintStream 标准输出(显示器) System.out.println(System.out.getClass()); }}

3.5、转换流InputStreamReader和OutputStreamWriter

InputStreamReader： Reader的子类，可以将InputStream(字节流)包装成（转换）Reader（字符流）

OutputStreamWriter： Writer的子类，可以实现将OutputStream(字节流)包装成Writer（字符流）

当处理纯文本数据时，如果使用字符流效率更高，并且可以有效解决中文问题，所以建议将字节流转换成字符流

可以在使用时指定编码格式（比如 utf-8, gbk, gb2312, ISO8855-1等）

InputStreamReader的类图：

---

OutputStream的类图：

---

**示例1：**字节流FileInputStream包装成（转换成）字符流InputStreamReader，对文件进行读取（按照UTF-8/GBK格式）进而包装成BufferedReader

import java.io.*;/** * @author java小豪 * @version 1.0.0 * @date 2022/11/28 * @description 使用InputStreamReader解决中文乱码问题 * <p> * 将字节流 FileInputStream 转换成 InputStreamReader， 指定编码gbk/utf-8 * </p> */public class InputStreamReader_ { public static void main(String[] args) throws IOException { String filePath = "F:\\file\\a.txt"; // 1. new FileInputStream 转成 InputStreamReader 指定编码为GBK InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), "GBK"); // 2. 把 InputStreamReader 传入 BufferedReader BufferedReader br = new BufferedReader(isr); // 将 2 和 3 和在一起 // BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath), "GBK")); // 3. 读取 String s = br.readLine(); System.out.println("读取文件的内容为：" + s); // 4. 关闭外层流 br.close(); }}

---

**示例2：**将字节流FileOutputStream包装成（转换成）字符流OutputStreamWriter，对文件进行写入（按照GBK格式，可以指定其他：UTF-8）

import java.io.FileOutputStream;import java.io.IOException;import java.io.OutputStreamWriter;/** * @author java小豪 * @version 1.0.0 * @date 2022/11/28 * @description 使用OutputStreamWriter将FileOutputStream字节流，转换成字符流 OutputStreamWriter */public class OutputStreamWriter_ { public static void main(String[] args) throws IOException { String filePath = "F:\\file\\a.txt"; String charSet = "UTF-8"; OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), charSet); osw.write("hi, 孙悟空"); osw.close(); System.out.println("按照 " + charSet + "保存文件成功~"); }}

3.6、打印流PrintStream 和 PrintWriter

注意：打印流只有输出流，没有输入流PrintStream的类图

PrintWriter的类图

PrintStream示例：

import java.io.IOException;import java.io.PrintStream;/** * @author java小豪 * @version 1.0.0 * @date 2022/11/28 * @description 演示PrintStream（字节打印流）、 */public class PrintStream_ { public static void main(String[] args) throws IOException { PrintStream ps = System.out; // 默认情况下，PrintStream 输出数据的位置是标准输出 /* public void print(String s) { if (s == null) { s = "null"; } write(s); } */ ps.println("john Hello"); // 因为print底层使用write，所以我们可以调用write进行打印/输出 ps.write("孙悟空，你好".getBytes()); ps.close(); //我们可以修改打印输出流的位置，修改成到 "F:\\file\\f1.txt" System.setOut(new PrintStream("F:\\file\\f1.txt")); System.out.println("hello, 孙悟空"); }}

---

PrintWriter示例：

import java.io.FileWriter;import java.io.IOException;import java.io.PrintWriter;/** * @author java小豪 * @version 1.0.0 * @date 2022/11/28 * @description 演示PrintWriter的使用 */public class PrintWriter_ { public static void main(String[] args) throws IOException {// PrintWriter pw = new PrintWriter(System.out); PrintWriter pw = new PrintWriter(new FileWriter("F:\\file\\f2.txt")); pw.print("hello, 北京~"); pw.close(); }}

四、Properties类

properties类可以轻松的处理*.properties文件

Properties类常见方法：

• load：加载配置文件的键值对到Properties对象
• list：将数据显示到指定位置
• getProperty(key)：根据键获取值
• setProperty(key, value)：设置键值对到Properties对象
• store：将Properties中的键值对存储到配置文件，在idea中保存文件如果有中文，会存储为Unicode码

**示例1：**读取mysql.properties文件，并得到ip，user 和 pwd

• 传统方法

import java.io.BufferedReader;import java.io.FileReader;import java.io.IOException;/** * @author java小豪 * @version 1.0.0 * @date 2022/11/28 * @description 演示Properties类的使用 */public class Properties01 { public static void main(String[] args) throws IOException { // 读取mysql.properties文件并得到ip、user和pwd BufferedReader br = new BufferedReader(new FileReader("src\\mysql.properties")); String line = ""; while((line = br.readLine()) != null ) { String[] split = line.split("="); System.out.println(split[0] + "值是：" + split[1]); } br.close(); }}

• 使用Properties类进行读取

import java.io.FileNotFoundException;import java.io.FileReader;import java.io.IOException;import java.util.Properties;/** * @author java小豪 * @version 1.0.0 * @date 2022/11/28 * @description */public class Properties02 { public static void main(String[] args) throws IOException { // 使用Properties 类来读取mysql.properties 文件 // 1.创建Properties 对象 Properties properties = new Properties(); // 2.加载指定的配置文件 properties.load(new FileReader("src/mysql.properties")); // 3.把k-v显示到控制台 properties.list(System.out); // 4.根据键获取对应的值 String user = properties.getProperty("username"); String pwd = properties.getProperty("password"); System.out.println("用户名=" + user); System.out.println("密码=" + pwd); }}

• 使用Properties修改配置文件

import java.io.FileOutputStream;import java.io.IOException;import java.util.Properties;/** * @author java小豪 * @version 1.0.0 * @date 2022/11/29 * @description */public class Properties03 { public static void main(String[] args) throws IOException { // 使用Properties 类来创建 配置文件，修改配置文件内容 Properties properties = new Properties(); // 创建 // 1.如果该文件没有key，就是创建 // 2.如果该文件有key，就是修改 properties.setProperty("charset", "utf-8"); properties.setProperty("user", "孙悟空"); properties.setProperty("pwd", "888888"); // 将k-v 存储在文件中 properties.store(new FileOutputStream("src\\mysql2.properties"), null); System.out.println("保存文件成功"); }}