[Java] 字节流，字符流

第一章 IO概述

1.1 什么是IO

生活中，我们肯定有过这样的经历： 忘记ctrl + s 可能文件就白白编辑了.

当我们使用u盘的时候,可以将各种文件都拷贝到电脑硬盘里面.

我们把这种数据的传输,可以看做是一种数据的流动, 按照流动的方向,一内存为基准,分为输入input和输出output, 即流向内存的是输入流,流出内存的是输出流

Java中的I/O操作主要是指java.io包下的内容,进行输出,输出操作**.输入也叫做读取数据**,输出也叫做写出数据

1.2 IO的分类

根据数据的流向进行分类:

• 输入流:把数据从其他设备中读入到内存
• **输出流:**把数据从内存中写出到其他设备

根据数据的类型进行分类:

• 字节流
• 字符流

1.4 顶级父类们

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

第二章 字节流

2.1 一切皆为字节

一切文件数据在存储时,都是以二进制数字的形 c 式保存的,都是一个一个的字节,那么传输的时候一样如此. 所以**,字节流可以传输任意文件数据.**

在操作流的时候,我们要明确,无论使用什么流对象,底层传输的始终都是二进制数据

2.2 字节输出流 [ OutputStream]

java.io.OutputStream抽象类时表示字节输出流的所有类的超类, 将指定的字节信息写出到目的地.这个类定义了字节输出流的基本共性的功能方法:

 void close() 
          关闭此输出流并释放与此流有关的所有系统资源。
     
 void flush() 
          刷新此输出流并强制写出所有缓冲的输出字节。 
     
 void write(byte[] b) 
          将 b.length 个字节从指定的 byte 数组写入此输出流。
     
 void write(byte[] b, int off, int len) 
          将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。 
     
abstract  void write(int b) 
          将指定的字节写入此输出流。 

注意： close方法，当我们使用完流的操作的时候，必须调用此方法，释放系统资源

2.3 FileOutputStream类

OutputStream有很多子类,我们从最简单的一个子类开始

构造方法

FileOutputStream(File file) 
          创建一个向指定 File 对象表示的文件中写入数据的文件输出流。 
    
FileOutputStream(File file, boolean append) 
          创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
    
FileOutputStream(FileDescriptor fdObj) 
          创建一个向指定文件描述符处写入数据的输出文件流，该文件描述符表示一个到文件系统中的某个实际文件的现有连接。 
    
FileOutputStream(String name) 
          创建一个向具有指定名称的文件中写入数据的输出文件流。
    
FileOutputStream(String name, boolean append) 
          创建一个向具有指定 name 的文件中写入数据的输出文件流。 

相关方法:

 void close() 
          关闭此文件输出流并释放与此流有关的所有系统资源。 
     
protected  void finalize() 
          清理到文件的连接，并确保在不再引用此文件输出流时调用此流的 close 方法。 
     
 FileChannel getChannel() 
          返回与此文件输出流有关的唯一 FileChannel 对象。 
     
 FileDescriptor getFD() 
          返回与此流有关的文件描述符。 
     
 void write(byte[] b) 
          将 b.length 个字节从指定 byte 数组写入此文件输出流中。 
     
 void write(byte[] b, int off, int len) 
          将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。 
     
 void write(int b) 
          将指定字节写入此文件输出流。 (十进制整数转化为二进制整数,根据ASCII表进行转换)
     		(如果写的第一个字节是负数,那么第一个字节会和第二个字节组成一个中文显示,查询BGK表)

写出字节数据

**写入数据的原理 **

• java程序 —> JVM —> 操作系统 --> 操作系统调用写数据的方法 —> 把数据写到文件中

使用步骤(重点)

1. 创建FileOutputStream对象
2. 调用write方法
3. 释放资源

示例代码:

package demo07;


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


public class Main {
    public static void main(String[] args) throws IOException {
        File f1 = new File("C:\\Users\\CUMT_CJY\\Desktop\\Java", "你爹.txt");
        // 创建对象
        FileOutputStream fos = new FileOutputStream(f1);
        // 调用write方法
        String str = "我是你爹!";

        fos.write(str.getBytes());//文件里面就是我是你爹!
        //释放资源
        fos.close();
    }
}

注意: UTF-8是三个字节一个中文,但是GBK是两个字节一个中文,write使用的是BGK

数据追加续写

用这两个构造方法

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

这两个构造方法,参数里面都需要传入一个boolean类型的值,true表示追加数据,false表示清空原有数据,这样创建的输出流对象,就可以指定是否追加续写了:

实例代码

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class Main {
    public static void main(String[] args) throws IOException {
        File f1 = new File("C:\\Users\\CUMT_CJY\\Desktop\\Java", "你爹.txt");
        // 创建对象
        //释放资源
        FileOutputStream fos = new FileOutputStream(f1,true);
        // 调用write方法
        String str = "我是你爹!";
        String str1 = "你是傻逼!";

        fos.write(str.getBytes());
        fos.write(str1.getBytes());
        fos.write(str.getBytes());
        fos.write(str1.getBytes());
        //运行结果
        //我是你爹!你是傻逼!我是你爹!你是傻逼!
        //可以看出,没有被覆盖,续写了
        fos.close();
    }
}

注意: 构造方法的第二个参数无论是true还是false都是可以续写的

写出换行

使用转义字符

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


public class Main {
    public static void main(String[] args) throws IOException {
        File f1 = new File("C:\\Users\\CUMT_CJY\\Desktop\\Java", "你爹.txt");
        // 创建对象
        //释放资源
        FileOutputStream fos = new FileOutputStream(f1,true);
        // 调用write方法
        String str = "我是你爹!";
        String str1 = "你是傻逼!";
        String str2 = "\n";

        fos.write(str.getBytes());
        fos.write(str1.getBytes());
        fos.write(str2.getBytes());
        fos.write(str1.getBytes());
        //运行结果
        //我是你爹!你是傻逼!
        //你是傻逼!
        //可以看出,这就换行了
        fos.close();
    }
}

注意: Window系统里面换行是\n和\r

mac系统里面是\r (Mac OS X开始与Linux统一)

Linux系统里面是\n

2.4 字节输入流[ InputStream]

java.io.InputStream抽象类是表示字节输入流的所有类的超类,可以读取字节信息到内存中.它定义了字节输入流的基本共性功能方法.

int available() 
          返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）的估计字节数。
    
 void close() 
          关闭此输入流并释放与该流关联的所有系统资源。
    
 void mark(int readlimit) 
          在此输入流中标记当前的位置。 
    
 boolean markSupported() 
          测试此输入流是否支持 mark 和 reset 方法。 
    
abstract int read() 
          从输入流中读取数据的下一个字节。
    
 int read(byte[] b) 
          从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。 
    
 int read(byte[] b, int off, int len) 
          将输入流中最多 len 个数据字节读入 byte 数组。 
    
 void reset() 
          将此流重新定位到最后一次对此输入流调用 mark 方法时的位置。 
    
 long skip(long n) 
          跳过和丢弃此输入流中数据的 n 个字节。 

小贴士: 使用完这个类之后,记得close释放哦!

2.5 FileInputStream类

java.io.FileInputStream类是文件输入流,从文件中读取字符

构造方法

FileInputStream(File file) 
          通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。 
    
FileInputStream(FileDescriptor fdObj) 
          通过使用文件描述符 fdObj 创建一个 FileInputStream，该文件描述符表示到文件系统中某个实际文件的现有连接。 
    
FileInputStream(String name) 
          通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。 
    

注意: 必须要是一个确实存在的文件不然会抛出FileNotFoundException错误

相关方法:

int available() 
          返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。 
    
 void close() 
          关闭此文件输入流并释放与此流有关的所有系统资源。 
    
protected  void finalize() 
          确保在不再引用文件输入流时调用其 close 方法。 
    
 FileChannel getChannel() 
          返回与此文件输入流有关的唯一 FileChannel 对象。 
    
 FileDescriptor getFD() 
          返回表示到文件系统中实际文件的连接的 FileDescriptor 对象，该文件系统正被此 FileInputStream 使用。 
    
 int read() 
          从此输入流中读取一个数据字节。 （读取到文件末尾后面的空，则返回-1）
    
 int read(byte[] b) 
          从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。 
    返回的是加入到数组的元素的个数
    
 int read(byte[] b, int off, int len) 
          从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。 
    
 long skip(long n) 
          从输入流中跳过并丢弃 n 个字节的数据。 

读取字节数据

使用read方法，每次可以读取一个字节数据，提升为int类型，读取到文件末尾后面的空，则返回-1

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


public class Main {
    public static void main(String[] args) throws IOException {
        File f1 = new File("C:\\Users\\CUMT_CJY\\Desktop\\Java", "你爹.txt");
        byte[] aaa = new byte[50];

        FileInputStream fis = new FileInputStream(f1);

        fis.read(aaa);

        for (byte b : aaa) {
            System.out.println(b);
        }
        fis.close();
    }
}
//当然，也可以用无参的read方法，使用while来读取，然后用ArrayList<Byte>来接收
int len;
 while ((len = fis.read()) != -1) {
 	System.out.println((char) len);
  }
//注意，这里一定要用一个变量来接受这个判断条件里面的值

读取原理

对象指向的是文件的第一个字节，文件里面有个隐藏的结束标记（操作系统的）

使用read会让对象的指针向后移一位，读取到结束标记之后，JVM就会识别，read方法返回-1

若是要将获取的字符型数组转化为字，那么

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


public class Main {
    public static void main(String[] args) throws IOException {
        File f1 = new File("C:\\Users\\CUMT_CJY\\Desktop\\Java", "你爹.txt");
        byte[] aaa = new byte[1000];

        FileInputStream fis = new FileInputStream(f1);

        fis.read(aaa);

        System.out.println(new String(aaa));
    }
}

当然，如果我们准备的字符数组不够大，那么，使用完read方法之后，指针就会指向读取完之后的位置

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


public class Main {
    public static void main(String[] args) throws IOException {
        File f1 = new File("C:\\Users\\CUMT_CJY\\Desktop\\Java", "你爹.txt");
        byte[] aaa = new byte[3];

        FileInputStream fis = new FileInputStream(f1);

        fis.read(aaa);

        System.out.println(new String(aaa));
        fis.read(aaa);

        System.out.println(new String(aaa));
        fis.read(aaa);

        System.out.println(new String(aaa));
        fis.read(aaa);

        System.out.println(new String(aaa));
    }
}
//运行结果
//我
//是
//你
//爹

2.6 字节流练习: 图片复制

复制原理图解

代码实现:

package demo07;


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


public class Main {
    public static void main(String[] args) throws IOException {
        File f1 = new File("C:\\Users\\CUMT_CJY\\Desktop\\Java\\images\\[Java] 字节流，字符流", "2.png");
        File f2 = new File("C:\\Users\\CUMT_CJY\\Desktop\\Java\\images\\[Java] 字节流，字符流","3.png");
        byte[] aaa = new byte[1024];

        FileInputStream fis = new FileInputStream(f1);
        FileOutputStream fos = new FileOutputStream(f2);

        int len;
        while ((len =  fis.read(aaa))!= -1){
            fos.write(aaa,0,len);
        }
		
        fos.close();
        fis.close();
        

    }
}
//这样写比较正规

流的关闭原则; 先开后关,后开先关

第三章 字符流

当我们使用字节流读取文本文件的时候,就会遇到中文乱码的情况,原因就是一个中文字符是可能占用多个字节,所以Java提供了一些字符流类,以字符为单位读写数据,专门处理文本数据

3.1 字符输入流 [Reader]

java.io.Reader抽象类是所有读取字符流的所有类的超类,可以读取字符信息到内存中,它定义了字符输入流的基本共性功能方法

3.2 FileReader类

构造方法

FileReader(File file) 
          在给定从中读取数据的 File 的情况下创建一个新 FileReader。 
    
FileReader(FileDescriptor fd) 
          在给定从中读取数据的 FileDescriptor 的情况下创建一个新 FileReader。 
    
FileReader(String fileName) 
          在给定从中读取数据的文件名的情况下创建一个新 FileReader。 

读取数据

相关方法

abstract  void close() 
          关闭该流并释放与之关联的所有资源。 
 void mark(int readAheadLimit) 
          标记流中的当前位置。 
 boolean markSupported() 
          判断此流是否支持 mark() 操作。 
 int read() 
          读取单个字符。 
 int read(char[] cbuf) 
          将字符读入数组。 
abstract  int read(char[] cbuf, int off, int len) 
          将字符读入数组的某一部分。 
 int read(CharBuffer target) 
          试图将字符读入指定的字符缓冲区。 
 boolean ready() 
          判断是否准备读取此流。 
 void reset() 
          重置该流。 
 long skip(long n)  

示例代码1

package demo02;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        File f1 = new File("C:\\Users\\Pefect\\Desktop\\Java","我是你爹.txt");

        char[]aa = new char[20];

        try {
            FileReader fr  = new FileReader(f1);

            int len = 0;

            while ((len = fr.read())!= -1){
                System.out.println((char) len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

注意： 文件不能是Unicode编码，不然会乱码，经测试 UTF-8可以

示例代码2

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

public class Main {
    public static void main(String[] args) {
        File f1 = new File("C:\\Users\\Pefect\\Desktop\\Java","我是你爹.txt");

        char[]aa = new char[20];
        try {
            FileReader fr = new FileReader(f1);
            fr.read(aa);
        } catch (IOException e) {
            e.fillInStackTrace();
        }
        for (char c : aa) {
            System.out.println(c);
        }

    }
}

3.3 字符输出流 Writer

他是所有写出字符流的所有类的超类，指将指定的字符信息写出到目的地。

有下列常用方法

Writer append(char c) 
          将指定字符添加到此 writer。 
    
 Writer append(CharSequence csq) 
          将指定字符序列添加到此 writer。 
    
 Writer append(CharSequence csq, int start, int end) 
          将指定字符序列的子序列添加到此 writer.Appendable。 
    
abstract  void close() 
          关闭此流，但要先刷新它。
    
abstract  void flush() 
          刷新该流的缓冲。 
    
 void write(char[] cbuf) 
          写入字符数组。 
    
abstract  void write(char[] cbuf, int off, int len) 
          写入字符数组的某一部分。 
    
 void write(int c) 
          写入单个字符。 (根据ASCII码)
    
 void write(String str) 
          写入字符串。 
    
 void write(String str, int off, int len) 
          写入字符串的某一部分。 

3.4 FileWriter类

构造方法

FileWriter(File file) 
          根据给定的 File 对象构造一个 FileWriter 对象。 
    
FileWriter(File file, boolean append) 
          根据给定的 File 对象构造一个 FileWriter 对象。 
    
FileWriter(FileDescriptor fd) 
          构造与某个文件描述符相关联的 FileWriter 对象。 
    
FileWriter(String fileName) 
          根据给定的文件名构造一个 FileWriter 对象。 
    
FileWriter(String fileName, boolean append) 
          根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。 

输出到硬盘

注意，步骤有所不一样

1. 创建FileWriter对象
2. 调用write方法，把数写入到内存缓冲区中（将字符转化为字节的过程）
3. 调用flush方法，把内存缓冲区中的数据刷新到文件中
4. 释放资源

关闭与刷新

​ 因为内置缓冲区的原因，如果不关闭输出流，就无法写出字符到文件中，但是关闭的流对象，是无法继续写出数据的。如果我们既想要写出数据，又想要继续使用流，就需要flush方法了.

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

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        File f1 = new File("C:\\Users\\Pefect\\Desktop\\Java","我是你爹.txt");
        try {
            FileWriter fr = new FileWriter(f1);
            fr.write("你亲爱的妈妈");
            fr.flush();
            
        } catch (IOException e) {
            e.fillInStackTrace();
        }

    }
}

换行和续写

换行的话,懂得都懂,就是使用 \n\r 就可以了

续写的话

FileWriter(File file, boolean append) 
          根据给定的 File 对象构造一个 FileWriter 对象。 
          
 FileWriter(String name, boolean append) 
          根据给定的 File 对象构造一个 FileWriter 对象。      

第四章 IO异常的处理

JDK7之前的处理

之前的入门练习,我们一直把异常抛出,而实际开发中并不能这样处理,建议使用try...catch语句

注意,我之前写的代码都是有问题的

示例代码

package demo02;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        File f1 = new File("C:\\Users\\Pefect\\Desktop\\Java","我是你爹.txt");

        FileWriter fr = null;
        try {
            fr = new FileWriter(f1);
            fr.write("你妈炸了");
            fr.flush();

        } catch (IOException e) {
            e.fillInStackTrace();
        }finally{
               if(fr != null){
                   	try {
                    	fr.close();
                	} catch (IOException e) {
                    	e.printStackTrace();
                	}
               }
        }

    }
}
//这样写才保证了程序的安全性

注意: 这样仍然可能报错,示例代码中如果fr指向的文件是不存在的,那么fr就是一个null,而null不能调用fr方法,所以我们要对close进行一个if判断(上面已经修改)

JDK7 之后

在try之后可以增加一个(), 括号里面可以定义流对象

流对象的作用域只在try之中有效

代码执行完毕,会自动把流对象释放

示例代码

package demo02;

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

public class Main {
    public static void main(String[] args) {

        try (FileWriter fr = new FileWriter("C:\\Users\\Pefect\\Desktop\\Java\\我是你爹.txt")) {
            fr.write("你妈炸了");
            fr.flush();
			//自动释放,不用close方法了
        } catch (IOException e) {
            e.fillInStackTrace();
        }

    }
}
//这样写才保证了程序的安全性

注意: 里面只能是流对象!!!

JDK9 之后

在try前面可以定义流对象

在try后边的()中可以直接引入流对象的名称(变量名),不用finally

这个也会自动释放

示例代码

package demo02;

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

public class Main {
    public static void main(String[] args) throws IOException {
        FileWriter fr = new FileWriter("C:\\Users\\Pefect\\Desktop\\Java\\我是你爹.txt");//这个Throws就可以了
        try (fr) {
            fr.write("你妈炸了");
            fr.flush();
			//这里也是自动调用close释放资源
        } catch (IOException e) {
            e.fillInStackTrace();
        }

    }
}
//这样写才保证了程序的安全性

第五章 属性集

5.1 概述

java.util.Properties 继承于Hashtable, 来表示一个持久的属性集,它使用键值结构存储数据,每个键及其对应值都是一个字符串.

该类也被许多java类使用,比如获取系统属性时,System.getProprties方法返回的就是一个Properties对象

注意,尽管Hashtable已经被HashMap淘汰了,但是properties没有被淘汰,因为这是唯一一个和流相结合的集合

5.2 Properties类

构造方法

Properties() 
          创建一个无默认值的空属性列表。 
Properties(Properties defaults) 
          创建一个带有指定默认值的空属性列表。 

基本的存储方法

void store(OutputStream out, String comments) 
          以适合使用 load(InputStream) 方法加载到 Properties 表中的格式，将此 Properties 			 表中的属性列表（键和元素对）写入输出流。  (不能写入中文)  后面的参数是解释说明(不能使用中文,默认是unicode编码)
    
 void store(Writer writer, String comments) 
          以适合使用 load(Reader) 方法的格式，将此 Properties 表中的属性列表（键和元素对）写		  入输出字符。 (适合用来写入中文)
    
   // store方法把集合中的临时数据,永久的存入硬盘当中
    
 void load(InputStream inStream) 
          从输入流中读取属性列表（键和元素对）。 (不能读取中文)
    
 void load(Reader reader) 
          按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。 

//load方法把硬盘中的文件(键值对形式),读取到集合中
    
 Object setProperty(String key, String value) 
          调用 Hashtable 的方法 put。 
    
 String getProperty(String key) 
          用指定的键在此属性列表中搜索属性。 
    
 String getProperty(String key, String defaultValue) 
          用指定的键在属性列表中搜索属性。 
    
 Set<String> stringPropertyNames() 
          返回此属性列表中的键集，其中该键及其对应值是字符串，如果在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键 

注意: Properties集合是一个双列结合,key和value默认都是字符串

遍历示例代码

package demo07;


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

public class Main {
    public static void main(String[] args) {
        show01();
    }

    private static void show01(){
        Properties prop = new Properties();

        //使用setProperties方法
        prop.setProperty("赵丽颖","168");
        prop.setProperty("迪丽热巴","165");
        prop.setProperty("古力娜扎","178");

        //prop.put("巴啦啦","188");  不要用这个,因为不会强制规定你要用字符串作为参数

        //将键存进一个集合中
        Set<String> set = prop.stringPropertyNames();

        //遍历输出
        for (String s : set) {
            System.out.println(prop.getProperty(s));
        }
        //运行结果
        //168
        //165
        //178
    }
}

写入硬盘示例代码

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

public class Main {
    public static void main(String[] args) throws IOException {
        show02();
    }

    private static void show02() throws IOException {
        Properties prop = new Properties();

        //使用setProperties方法
        prop.setProperty("赵丽颖","168");
        prop.setProperty("迪丽热巴","165");
        prop.setProperty("古力娜扎","178");

        FileWriter fw = new FileWriter("C:\\Users\\CUMT_CJY\\Desktop\\Java\\你	爹.txt");


        //使用流方法来写
        prop.store(fw,"data save");

        //释放资源
        fw.close();

        //运行结果
        //#data save
        //#Thu Apr 01 22:49:20 CST 2021
        //赵丽颖=168
        //迪丽热巴=165
        //古力娜扎=178
   }
}

读取文件中的数据

package demo07;


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

public class Main {
    public static void main(String[] args) throws IOException {
        show02();
    }

    private static void show02() throws IOException {
        Properties prop = new Properties();

        FileReader fr = new FileReader("C:\\Users\\CUMT_CJY\\Desktop\\Java\\你爹.txt");

        prop.load(fr);

        Set<String> set = prop.stringPropertyNames();

        for (String s : set) {
            System.out.println(s + prop.getProperty(s));
        }
        //运行结果
        //赵丽颖168
        //迪丽热巴165
        //古力娜扎178
   }
}

注意: 存储对的文件中,键与值得连接符号可以是 = ,空格

xt");

    //使用流方法来写
    prop.store(fw,"data save");

    //释放资源
    fw.close();

    //运行结果
    //#data save
    //#Thu Apr 01 22:49:20 CST 2021
    //赵丽颖=168
    //迪丽热巴=165
    //古力娜扎=178

}
}

**读取文件中的数据**

```java
package demo07;


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

public class Main {
    public static void main(String[] args) throws IOException {
        show02();
    }

    private static void show02() throws IOException {
        Properties prop = new Properties();

        FileReader fr = new FileReader("C:\\Users\\CUMT_CJY\\Desktop\\Java\\你爹.txt");

        prop.load(fr);

        Set<String> set = prop.stringPropertyNames();

        for (String s : set) {
            System.out.println(s + prop.getProperty(s));
        }
        //运行结果
        //赵丽颖168
        //迪丽热巴165
        //古力娜扎178
   }
}

注意: 存储对的文件中,键与值得连接符号可以是 = ,空格

可以使用#注释内容# 进行注释