java磁盘操作与IO流（序列化、Properties类）

一、磁盘操作

1、File类：

（1）创建File对象：

（2）获取文件信息：

（3）判断文件

（4）删除文件

（5）创建文件：

2、Files工具类：

（1）字符操作：

（2）字节操作：

二、IO流：

在 Java 中，IO（Input/Output）流是用于处理设备间数据传输的机制，比如文件读写、网络通信等。IO 流按不同维度可分为多种类型，以下是其核心分类及常用操作示例：

1、IO流的概念：

（1） I 表示Input ，把硬件文件的数据读入到内存的过程，称之输入，负责读。

（2）O表示output ，把内存中的数据写出到硬盘文件的过程称之输出负责写

2、字节操作（字节流）：操作最小单元为字节，可以包含音频视频图片

（1）输入流：InputStream（读）：常用实现类：FileInputStream类、BufferedInputStream类、ObjectInputStream类（反序列化）等。

（1.1）FileInputStream类：基于磁盘中字节内容的输入流。

（1.2） BufferedInputStream类：带有缓冲区的输入流。

（1.3）ObjectInputStream类：对象输入流，进行反序列化操作

（1.4）常用方法：

（2）输出流：OutputStream（写）：常用实现类：FileOutStream类、BufferedOutStream类、ObjectOutputStream类（序列化）等。

（2.1）FileOutStream类：基于磁盘中字节内容的输出流

（2.2）BufferedOutStream类：带有缓冲区的输入流：

（2.3）ObjectOutputStream类：对象输出流，进行序列化操作

（2.4）常用方法：

3、字符操作（字符流）：操作最小单位：txt文本文件或者java文件

（1）输出流：Writer（写）：常用实现类：FileWriter类、BufferedWriter类

（1.1）FileWriter类：也带有缓冲区：缓冲区长度为8192

常用方法：

（1.2）BufferedWriter类：带缓冲区的流，与FileWriter相差不大，多了一个bw.newLine()方法自带换行方法

（2）输入流：Reader(读)：常用实现类：FileReader类、BufferedReader类、

（2.1）FileReader类：

（2.2）常用方法：

（2.3）BufferedReader类：多了一个String readLine( )方法，读取一整行，读取至末尾，返回null

三、Serializable序列化与反序列化：

1、序列化：对象--->二进制

（1）如果想要让某个对象进行序列化操作，要求类必须要实现Serializable接口。

（2）在进行序列化和反序列化时要求类的信息不能有任何的改动，否则会出异常。

（3）如果不能确保类不发生任何变动，则可以加序列化码（成员常量）保证类信息一致

（4）如果不想某个成员变量序列化出去，可以使用transient进行成员变量的修饰（

（5）要求成员变量也标题四要可序列化

2、反序列化：二进制--->对象

四、Properties类：Properties extends Hashtable，实例化对象一键值对存储。

1、常用方法：

（1）Object setProperty(String key, String value)给对象赋值

（2）getProperty(String key)获取键对应的值

（3）getProperty(String key, String defaultValue)获取键对应的值，没有该键，返回默认值

（4）SetstringPropertyNames()获取所有的键

2、将输出流OutputStram和Properties对象p1对象结合，进行p1对象的输出：

3、将输入流InputStream获取到的所有信息传递给p1对象

4、Class对象的getResourceAsStream()可以从classpath中读取指定资源:

一、磁盘操作

java.io.File 类是java提供的针对磁盘中文件和目录对象的一个类。代表操作系统的文件（文件、文件夹）。

1、File类：

（1）创建File对象：

（1.1）public File(String pathname)：以pathname为路径创建File对象，可以是绝对路径或者相对路径.

（1.2）public File(String parent,String child)：以parent为父路径，child为子路径创建File对象

（1.3）public File(File parent,String child)：根据一个父File对象和子文件路径创建File对象

        File f1 = new File("D:\\IoTest\la.txt");--传入一个string path路径File f2 = new File("D:\|IOTest","a.txt");//传入两个路径，分别时父路径和子路径File f3 = new File(new File( "D:\\IoTest"), "a.txt"); //传入两个路径第一个为File类型的对象，第二个为子路径

（2）获取文件信息：

（2.1） public String getName() ：获取文件的名称，带后缀

（2.2） public long length() ：获取文件长度（即：字节数---真实的大小）。不能获取目录的长度--仅表示当前操作系统为保存目录所涉及的长度。

（2.3） public long lastModified() ：获取最后一次的修改时间，毫秒值使用new Date(f1.lastModified());// 返回的是当天时间

package com.yuan.file;import java.io.File;
import java.util.Date;public class Demo01 {public static void main(String[] args) {//存在的目录路径// 小贴士:// 1.一个File对象代表指向硬盘中的一个文件或者目录路径(举例，只代表此路径，不代表里面的内容。举例:地址不是房子，File对象指向地// 2.无论该路径下是否存在文件或者目录，都不影响File对象的创建。File f1 = new File( "D:\\IoTest");System.out.println(f1);///存在的文件路径File f2 = new File( "D:\\IoTest\\a.txt");System.out.println(f2);//不存在的目录路径File f3 = new File( "D:\\IoTest\\aaa");System.out.println(f3);//不存在的文件路径File f4 = new File( "D:\\IoTest\\a.jpg");System.out.println(f4);String str="文件名是:%s 文件大小是:%d  文件最后一次修改时间是:%s\n";//public string getName():获取文件的名称，带后缀//public long length():获取文件长度(即:字节数---真实的大小)。不能获取目录的长度--仅表示当前操作系统为保存目录所涉及的长度//public long lastModified():获取最后一次的修改时间，毫秒值System.out.printf(str,f1.getName(),f1.length(),new Date(f1.lastModified()));System.out.printf(str,f2.getName(),f2.length(),new Date(f2.lastModified()));System.out.printf(str,f3.getName(),f3.length(),new Date(f3.lastModified()));System.out.printf(str,f4.getName(),f4.length(),new Date(f4.lastModified()));}
}

（2.4）public String getAbsolutePath()：获取文件的绝对路径

（2.5） public String getPath() ：获取路径,返回定义文件时使用的路径

（2.6）public String getCannoicalPath() 获取规范路径

package com.yuan.file;import java.io.File;
import java.io.IOException;public class Demo02 {public static void main(String[] args) throws IOException {File f1 = new File(new File( "D:\\IoTest"), "a.txt");System.out.println("文件绝对路径"+f1.getAbsolutePath());System.out.println("文件使用路径"+f1.getPath());System.out.println("文件规范路径"+f1.getCanonicalPath());  //编译时异常//.表示当前路径 .. 表示当前路径的上一层路径File f2 = new File(".\\a.txt");System.out.println("文件绝对路径"+f2.getAbsolutePath());System.out.println("文件使用路径"+f2.getPath());System.out.println("文件规范路径"+f2.getCanonicalPath());  //编译时异常}
}

（2.7）public String[] list() ：获取指定目录下的所有文件或者文件目录的名称数组---注意返回类型

（2.8）public File[] listFiles() ：获取指定目录下的所有文件或者目录的File数组----返回时File

  public static void main(String[] args) {//查看目录下的文件及文件夹//public String[] list();获取指定目录下的文件或者文件目录的名称数组File f1=new File("D:\\IoTest");String[] names=f1.list();System.out.println(Arrays.toString(names));//public File[] listFiles():获取指定目录下的所有文件或者目录的File数组--返回File路径对象File[] files=f1.listFiles();System.out.println(Arrays.toString(files));}

（3）判断文件

（3.1） public boolean exists() ：判断是否存在

（3.2） public boolean isDirectory()：判断是否是目录

（3.3）public boolean isFile() ：判断是否是文件

package com.yuan.file;import java.io.File;public class Demo03 {public static void main(String[] args) {//存在的文件和目录File f1 = new File("D:\\IoTest");File f2 = new File( "D:\\IoTest\\a.txt");//不存在的文件和目录File f3 = new File( "D:\\IoTest\\aaa");File f4 = new File(  "D:\\IoTest\\a.jpg");//判断是否存在String str ="【%s】是否存在%s,是否是文件%s,是否是目录%s\n";//public boolean isFile():判断是否是文件System.out.printf(str,f1.getName(),f1.exists(),f1.isFile(),f1.isDirectory());System.out.printf(str,f2.getName(),f2.exists(),f2.isFile(),f2.isDirectory());System.out.printf(str,f3.getName(),f3.exists(),f3.isFile(),f3.isDirectory());System.out.printf(str,f4.getName(),f4.exists(),f4.isFile(),f4.isDirectory());}
}

（3.4）public boolean canRead() ：判断是否可读

（3.5）public boolean canWrite() ：判断是否可写

（3.6） public boolean isHidden() ：判断是否隐藏

package com.yuan.file;import java.io.File;public class Demo04 {public static void main(String[] args) {File f1=new File("D\\IoTest\\a.txt");System.out.println("是否可读"+f1.canRead());System.out.println("是否可写"+f1.canWrite());System.out.println("是否隐藏"+f1.isHidden());}
}

（4）删除文件

（4.1）public boolean delete()：删除此抽象路径名表示的文件或者文件夹

注意：delete方法只删除文件和空文件夹，是直接删除不走回收站

public class Demo05 {public static void main(String[] args) {//delete 方法删除后不进回收站File f1=new File("D:\\IoTest\\b.txt");File f2=new File("D:\\IoTest\\fileStudy");//删除文件时，要求文件必须存在才能进行删除boolean b1 =f1.delete();System.out.println("f1是否删除成功:"+b1);//只能删除存在的空目录boolean b2=f2.delete();System.out.println("f2是否删除成功:"+b2);}
}

（5）创建文件：

（5.1）public boolean createNewFile()：创建文件。若文件存在，则不创建，返回false

（5.2）public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。

（5.3）public boolean mkdirs() ：创建文件目录。如果上层文件目录不存在，一并创建

public class Demo06 {public static void main(String[] args) throws IOException {File f1 = new File("D:\\IoTest\\b.txt");File f2 = new File("D:\\IoTest\\资料");File f3 = new File("D:\\IoTest\\aaa\\资料");//1.创建文件createNewFile()，文件路径存在，文件不存在的时候为trueboolean b1=f1.createNewFile();System.out.println("创建f1对象是否成功:"+b1);//2.创建文件夹,当文件夹不存在,且父路径存在的时候就可以创建boolean b2 =f2.mkdir();System.out.println("创建f2对象是否成功:"+b2);//3.创建文件来，如果父路径不存在，则一并创建boolean b3 =f3.mkdirs();System.out.println("创建f3对象是否成功:"+b3);}
}

2、Files工具类：

在 Java NIO（New IO）中，java.nio.file.Files 是一个非常实用的工具类，提供了大量静态方法用于操作文件和目录，包括创建、删除、复制、移动、读取、写入等操作。它通常与 Path 接口配合使用，是处理文件系统的重要工具。以下是 Files 工具类的一些常用方法：

（1）字符操作：

（1.1）List<String> list readAllLine(Path path) 按行读取指定路径中的内容

（1.2） write(Path path, List<String> list) 写入字符到指定的路径

public class FilesReadWriteExample {public static void main(String[] args) {// 定义文件路径Path filePath = Paths.get("example.txt");try {// 1. 写入内容到文件List<String> contentToWrite = new ArrayList<>();contentToWrite.add("第一行内容");contentToWrite.add("第二行内容");contentToWrite.add("第三行内容");// 使用write方法写入列表内容到文件Files.write(filePath, contentToWrite);System.out.println("文件写入成功！");// 2. 从文件按行读取内容List<String> readLines = Files.readAllLines(filePath);System.out.println("\n文件读取内容如下：");for (String line : readLines) {System.out.println(line);}} catch (IOException e) {System.out.println("文件操作出错：" + e.getMessage());e.printStackTrace();}}
}

（2）字节操作：

（2.1）byte[] readAllBytes(Path path) 读取文件中的所有字节。

public class Demo01 {public static void main(String[] args) throws IOException {Path p1=new File("D:\\IoTest\\a.txt").toPath();//byte[] readAllBytes(Path path) 读取文件中的所有字节byte[] bytes= Files.readAllBytes(p1);System.out.println(Arrays.toString(bytes));//字符读的方式： 只能读取纯文本类型List<String> list=Files.readAllLines(p1);System.out.println(list);}
}

（2.2） Path write(Path path, byte[] bytes) 写入字节到指定的路径

public class Demo02 {public static void main(String[] args) throws IOException {Path p1 = new File( "D:\\IoTest\\a.txt").toPath();//写 Path write(Path path,byte[] bytes) 写入字节到指定的路径byte[] bytes="我本将心向明月".getBytes();Files.write(p1,bytes);ArrayList<String> list =new ArrayList<>();for (int i =0; i <30 ; i++) {list.add(UUID.randomUUID().toString());}// write(Path path，List<String>list)写入字符到指定的路径Files.write(p1,list, StandardOpenOption.APPEND);System.out.println("写出结束");}
}

二、IO流：

在 Java 中，IO（Input/Output）流是用于处理设备间数据传输的机制，比如文件读写、网络通信等。IO 流按不同维度可分为多种类型，以下是其核心分类及常用操作示例：

1、IO流的概念：

（1） I 表示Input ，把硬件文件的数据读入到内存的过程，称之输入，负责读。

（2）O表示output ，把内存中的数据写出到硬盘文件的过程称之输出负责写

2、字节操作（字节流）：操作最小单元为字节，可以包含音频视频图片

（1）输入流：InputStream（读）：常用实现类：FileInputStream类、BufferedInputStream类、ObjectInputStream类（反序列化）等。

（1.1）FileInputStream类：基于磁盘中字节内容的输入流。

构造方法：

1.FileInputStream(File file)；通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。

2、FileInputStream(String name) 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

public class Demo01 {public static void main(String[] args) throws FileNotFoundException {//注意路径： 一定是一个文件路径，路径一定要存在，如果不存在则出异常//public  FileInputStream（String name）InputStream is1=new FileInputStream("D:\\IoTest\\a.txt");System.out.println(is1);  //获取输入流对象//FileInputStream(File file)InputStream is2=new FileInputStream(new File("D:\\IoTest\\a.txt"));System.out.println(is2);}
}

（1.2） BufferedInputStream类：带有缓冲区的输入流。

作用：没有缓冲区，就好像逛超市没有推车，一次只拿一样东西区结账，缓冲区可以暂时放一堆数据到满为止

（1.3）ObjectInputStream类：对象输入流，进行反序列化操作

（1.4）常用方法：

（1.4.1）int read（）：一个字节一个字节读取，赋值给返回值，植脂末未返回-1

（1.4.2）int read(byte b[])每次读取N个字节，将字节放到字节数组中，读取到末尾返回值-1

（1.4.3）public void close() ：关闭此输入流，并释放与此流相关联的任何系统资源。原因：在IO流进行操作时，当前IO流回占用到一定的内存，由于系统资源宝贵，因此在进行IO操作结束后，调用close方法关闭流，从而释放资源。

package com.yuan.inputstream;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;public class Demo02 {public static void main(String[] args) throws IOException {InputStream is = new FileInputStream("D:\\IoTest\\a.txt");//1、int read()  一个字节一个字节读取，赋值给返回值，植脂末未返回-1
//        int data1 = is.read();
//        System.out.println(data1);
//        int data2 = is.read();
//        System.out.println(data2);
//        int data3 = is.read();
//        System.out.println(data3);
//        int data4 = is.read();
//        System.out.println(data4);
//
//        int data;
//        while ((data = is.read()) != -1) {
//            System.out.println((char) data);
//        }//2.int read(byte b[])每次读取N个字节，将字节放到字节数组中，读取到末尾返回值-1byte[] bytes = new byte[10];//存放每次读取到的字节信息int len;//每次读取的长度1/读取操作while ((len = is.read(bytes)) != -1) {System.out.print("读取到的长度为:" + len + "读到的内容:" + new String(bytes, 0, len)+"\n");}is.close();}
}

（2）输出流：OutputStream（写）：常用实现类：FileOutStream类、BufferedOutStream类、ObjectOutputStream类（序列化）等。

（2.1）FileOutStream类：基于磁盘中字节内容的输出流

构造方法：

public class Demo04 {public static void main(String[] args) throws FileNotFoundException {//1、字节输出流路径一定要是一个文件路径//2、输出流文件对象可以不存在，的但是父路径一定要存在//FileOutputStream（String name）如果路径中有内容，会将路径中的内容覆盖掉OutputStream os=new FileOutputStream("D:\\IoTest\\b.txt");System.out.println(os);//FileOutputStream(File file)OutputStream os1=new FileOutputStream(new File("D:\\IoTest\\b.txt"));System.out.println(os1);}
}

（2.2）BufferedOutStream类：带有缓冲区的输入流：

（2.3）ObjectOutputStream类：对象输出流，进行序列化操作

（2.4）常用方法：

（2.4.1）write(int b)：写入一个字节

（2.4.2）write(byte b[ ])：把这个b字节数组中的所有数据写到关联的设备中(设备包括文件、网络或者其他任何地方)。

（2.4.3）write(byte b[], int off, int len)：把数组b字节中的数据从下标off位置开始往出写，共计写len个元素
（2.4.4）public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。close方法，当完成流的操作时，必须调用此方法，释放系统资源。

public class Demo07 {public static void main(String[] args) {//使用追加写的方式进行字书流的输出，不会对文件信息进行覆盖try (OutputStream os = new FileOutputStream( "D:\\IoTest\\a.txt",  true);BufferedOutputStream bos = new BufferedOutputStream(os);){//window换行号:r\n// linux换行:Ir// mac换行:nbos.write('a');//写出一个字节信息bos.write("rin".getBytes());//写出一个换行信息bos.write("我本将心向明月\r\n".getBytes());//写出一个字节数组信息//获取系统换行String str=System.lineSeparator();for(int i=0;i<5;i++) {String s1 = UUID.randomUUID().toString().substring(0, 8);bos.write((s1 + str).getBytes());}//bos.flush()://删新缓冲流// bos.close();关闭流bos.write("站着还能睡着吗".getBytes());}catch(Exception e) {e.printStackTrace();}}
}

3、字符操作（字符流）：操作最小单位：txt文本文件或者java文件

（1）输出流：Writer（写）：常用实现类：FileWriter类、BufferedWriter类

（1.1）FileWriter类：也带有缓冲区：缓冲区长度为8192

构造方法：

（1.1.1）public FileWriter(String path);

（1.1.2）public FileWriter(File path);

（1.1.3）public FileWriter(String path,boolean append);

（1.1.4） public FileWriter(File path,boolean append);

public class Demo01 {public static void main(String[] args) throws IOException {//字符//FileWriter(String filename)覆盖写Writer w1=new FileWriter("D:\\IoTest\\a.txt");System.out.println(w1);//FileWriter(File file)覆盖写Writer w2=new FileWriter(new File("D:\\IoTest\\a.txt"));System.out.println(w2);//FileWriter(String filename) 不覆盖写Writer w3=new FileWriter("D:\\IoTest\\a.txt",true);System.out.println(w3);//FileWriter(String filename) 不覆盖写Writer w4=new FileWriter("D:\\IoTest\\a.txt",true);System.out.println(w4);}
}

常用方法：

（1.1.5）void write(String str) 写出一整行

（1.1.6） void newLine( ) 创建新行，输出换行符（根据操作系统不同，输出不同的换行符，windows是\r\n，Linux和Mac OS是\n）

public class Demo03 {public static void main(String[] args) {try (BufferedWriter bw=new BufferedWriter(new FileWriter("D:\\IoTest\\c.txt"));){bw.write("你好");bw.newLine();// 自带换行方法bw.write("白日依山尽",0,3);bw.newLine();bw.flush();//刷新bw.close();//关闭，用try-with-resource, 所以不用关了} catch (IOException e) {e.printStackTrace();}}
}

（1.2）BufferedWriter类：带缓冲区的流，与FileWriter相差不大，多了一个bw.newLine()方法自带换行方法

（2）输入流：Reader(读)：常用实现类：FileReader类、BufferedReader类、

（2.1）FileReader类：

构造方法：

（2.1.1）public FileReader(String path);

（2.1.2）public FileReader(File path);

public class Demo01 {public static void main(String[] args) throws FileNotFoundException {//创建字符输入流Reader r1=new FileReader("D:\\IoTest\\b.txt");System.out.println(r1);Reader r2=new FileReader(new File("D:\\IoTest\\b.txt"));System.out.println(r2);}
}

（2.2）常用方法：

（2.2.1）int read（）读取一个字符的数据，如果没有数据则返回-1

（2.2.2）int read(char buf[]) 读取数据存入char数组中，返回读取的长度，如果没有数据则返回-1

（2.2.3）void close(); 关闭此流并释放与此流相关联的任何系统资源。

public class Demo02 {public static void main(String[] args) {try (Reader r1 = new FileReader("D:\\IOTest\\b.txt")) {// 读取单个字符，返回字符对应码表值，当为 -1 读取结束int data = r1.read();System.out.println((char) data);// 循环读取
//            int data;
//            while ((data = r1.read()) != -1) {
//                System.out.print((char) data);
//            }// int read(char buf[])  读取数据存入 char 数组中，返回读取的长度，如果没有数据则返回 -1char[] chars = new char[10];int len;while ((len = r1.read(chars)) != -1) {System.out.print(new String(chars, 0, len));}} catch (IOException e) {e.printStackTrace();}}
}

（2.3）BufferedReader类：多了一个String readLine( )方法，读取一整行，读取至末尾，返回null

三、Serializable序列化与反序列化：

1、序列化：对象--->二进制

（1）如果想要让某个对象进行序列化操作，要求类必须要实现Serializable接口。

（2）在进行序列化和反序列化时要求类的信息不能有任何的改动，否则会出异常。

（3）如果不能确保类不发生任何变动，则可以加序列化码（成员常量）保证类信息一致

（4）如果不想某个成员变量序列化出去，可以使用transient进行成员变量的修饰（

（5）要求成员变量也标题四要可序列化

public class Person implements Serializable {private static final long serialVersionUID = 6710117445303992336L;private String name;private transient int age;private Money money;public Person(String name, int age, Money money) {this.name = name;this.age = age;this.money = money;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +", money=" + money +'}';}
}// 注意：假设 Money 类也需要实现 Serializable 接口才能支持 Person 类的完整序列化，
// 这里补充 Money 类的示例实现（如果实际项目中有该类，需确保其正确实现）
class Money implements Serializable {private double Balance;private String bz;public Money(double balance, String bz) {Balance = balance;this.bz = bz;}
}

public class Demo01 {public static void main(String[] args) {// 序列化：对象->二进制// out// 反序列化：对象<-二进制try (ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("a.txt"));) {Person p1 = new Person("张三", 20, new Money(1768937, "人民币"));// 写出一个对象，序列化。将对象写出到指定的文件中os.writeObject(p1);System.out.println("序列化完成");} catch (IOException e) {e.printStackTrace();}}
}

2、反序列化：二进制--->对象

public class Demo02 {public static void main(String[] args) {// 二进制-->对象// 输入流try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("a.txt"));) {Object obj = ois.readObject();if (obj instanceof Person) {Person p1 = (Person) obj;System.out.println(p1);}} catch (IOException | ClassNotFoundException e) {e.printStackTrace();}}
}

四、Properties类：Properties extends Hashtable<Object,Object>，实例化对象一键值对存储。

1、常用方法：

（1）Object setProperty(String key, String value)给对象赋值

（2）getProperty(String key)获取键对应的值

（3）getProperty(String key, String defaultValue)获取键对应的值，没有该键，返回默认值

（4）Set<String> stringPropertyNames()获取所有的键

public class Demo01 {public static void main(String[] args) {Properties p1=new Properties();//Object setProperty(String key, String value)给对象赋值p1.setProperty("姓名","张三");p1.setProperty("年龄","12");System.out.println(p1);//getProperty(String key)获取键对应的值String name=p1.getProperty("姓名");System.out.println(name);//getProperty(String key, String defaultValue)获取键对应的值，没有该键，返回默认值String name1=p1.getProperty("姓名1","不知道");System.out.println(name1);//获取所有的键Set<String> set=p1.stringPropertyNames();System.out.println(set);}
}

2、将输出流OutputStram和Properties对象p1对象结合，进行p1对象的输出：

public class Demo02 {public static void main(String[] args) throws IOException {Properties p1=new Properties();p1.setProperty("姓名","张三");p1.setProperty("年龄","12");p1.setProperty("性别","男");Writer w1=new FileWriter("b.txt");//将输出流和p1对象结合，进行p1对象的输出p1.store(w1,"helloWorld");w1.close();}
}

3、将输入流InputStream获取到的所有信息传递给p1对象

public class Demo03 {public static void main(String[] args) throws IOException {Properties p1=new Properties();Reader r1=new FileReader("b.txt");//将输入流获取放到的所有信息传递给p1对象p1.load(r1);Set<String> set=p1.stringPropertyNames();for (String s:set) {System.out.println(s+"__"+p1.getProperty(s));}}
}

4、Class对象的getResourceAsStream()可以从classpath中读取指定资源:

public class Demo04 {public static void main(String[] args) throws IOException {//Class对象的getResourceAsStream()可以从classpath中读取指定资源:InputStream is = Demo04.class.getResourceAsStream("/jdbc.properties");Properties p1 = new Properties();p1.load(is);//输入流和p1对象结合//打印链值对for (String key : p1.stringPropertyNames()) {System.out.println(key + "__" + p1.getProperty(key));}is.close();}
}