一、File类:操作文件
1.构造方法
File类封装的并不是真正的文件,仅仅是一个路径名
-
绝对路径
是一个完整的路径,从盘符开始。“D:\notes\Typora\JavaSE”
-
相对路径
是一个简化的路径,从当前项目根目录开始。“模块名\a.txt”
方法名 | 说明 |
---|---|
File(String pathname) | 通过路径名字符串创建File的对象 |
File(String parent, String child) | 通过父路径名字符串 + 子路径名字符串创建File的对象 |
File(File parent, String child) | 通过父路径名字符串的包装对象 + 子路径名字符串创建File的对象 |
public class FileDemo1 {
public static void main(String[] args) {
File file = new File("D:\\test");
System.out.println(file);
File file1 = new File("D:\\test", "\\demo1");
System.out.println(file1);
File file2 = new File(file1, "\\java.txt");
System.out.println(file2);
}
}
2.创建和删除功能
这些方法是真正的操作硬盘上的文件
创建功能 | 说明 |
---|---|
public boolean createNewFile() | 创建文件,已存在则返回false |
public boolean mkdir() (舍) | 创建目录,已存在则返回false |
public boolean mkdirs() (常用) | 创建多级目录,已存在则返回false |
删除功能 | 说明 |
public boolean delete() (不走回收站) | 只能删除文件或空文件夹 |
public class FileDemo2 {
public static void main(String[] args) throws IOException {
File file = new File("D:\\test");
System.out.println(file);
File file1 = new File("D:\\test", "\\demo1");
System.out.println(file1);
File file2 = new File(file1, "\\java.txt");
System.out.println(file2);
System.out.println(file.mkdir());
System.out.println(file1.mkdirs());
System.out.println(file2.createNewFile());
// 如果要删除的目录其内部还有子目录或者文件,则删除失败。换句话说,只能从内到外一级一级删除
System.out.println(file2.delete());
System.out.println(file1.delete());
System.out.println(file.delete());
}
}
3.判断和获取功能
判断功能 | 说明 |
---|---|
public boolean isDirectory() | 判断路径名表示的File是否为目录 |
public boolean isFile() | 判断路径名表示的File是否为文件 |
public boolean exists() | 判断路径名表示的File是否存在 |
获取功能 | 说明 |
public String getAbsolutePath() | 返回此抽象路径名的绝对路径名字符串 |
public String getPath() | 获取文件或目录的路径名字符串 |
public String getName() | 获取文件或目录的名称 |
public File[] listFiles() | 将该目录下所有文件和目录组成 File类型的数组返回 数组中的每一个元素都是一个完成的路径 |
public class MethodsTest {
public static void main(String[] args) throws IOException {
File file = new File("D:\\test");
System.out.println(file);
File file1 = new File("D:\\test", "\\demo1");
System.out.println(file1);
File file2 = new File(file1, "\\java.txt");
System.out.println(file2);
System.out.println(file.mkdir());
System.out.println(file1.mkdirs());
System.out.println(file2.createNewFile());
------------------------------------------ 以上为准备工作 ----------------------------------------------------
System.out.println("file2.isDirectory() = " + file2.isDirectory());
System.out.println("file2.isFile() = " + file2.isFile());
System.out.println("file2.exists() = " + file2.exists());
System.out.println("file2.getAbsolutePath() = " + file2.getAbsolutePath());
System.out.println("file2.getPath() = " + file2.getPath());
System.out.println("file2.getName() = " + file2.getName());
File file4 = new File(file1, "JavaSE.txt");
file4.createNewFile();
File file5 = new File(file1, "JavaSE");
file5.mkdir();
// 将该目录下所有文件和目录组成 File类型的数组返回
File[] files = file1.listFiles();
for (File file3 : files) {
System.out.println("file3.getName() = " + file3.getName());
}
}
}
------------------------------------------------------------------------------------------------------------
结果:
file2.isDirectory() = false
file2.isFile() = true
file2.exists() = true
file2.getAbsolutePath() = D:\test\demo1\java.txt
file2.getPath() = D:\test\demo1\java.txt
file2.getName() = java.txt
for循环:
file3.getName() = java.txt
file3.getName() = JavaSE
file3.getName() = JavaSE.txt
二、IO流:操作文件中的具体内容
数据的流向是站在内存的角度看的:
从硬盘到内存:称之为 读 intput
从内存到硬盘:称之为 写 output
纯文本:能用记事本打开并读懂的文本
富文本:Office办公软件中word、ppt、excle等都属于富文本
字节:所有类型: .mp3 \ .avi \ .jpg
字符:纯文本: .txt \ .java
1.字节流
1.1写数据
- 注意事项:
①创建字节流对象:第一个参数:文件的路径,若文件不存在,会自动创建。
第二个参数:追加写入,默认为false,若文件存在会将其清空。设置为true则会在文件已有的内容后追加写入。
②写数据:实际写入的内容是该整数在码表中对应的字符
③释放资源:否则该文件会一直处于<在用>状态,没法对它进行任何操作
④创建对象时需要抛出FileNotFoundException异常,写数据和释放资源需要抛出IOException异常。前者继承后者。
public class OutPutDemo {
public static void main(String[] args) throws IOException {
// 1.创建<字节输出流>对象:1.构造方法中会根据传来的参数生成一个File类
// 2.告诉虚拟机要往这个新生成的文件中写入数据
// 3.若文件不存在,会自动创建。若存在,则会把文件清空
FileOutputStream fos = new FileOutputStream("D:\\test\\a.txt");
// 2.写数据:实际写入的内容是该整数在码表中对应的字符
fos.write(98);
// 3.关闭资源:否则该文件会一直处于<在用>状态,没法对它进行任何操作
fos.close();
}
}
- 三种方法:
方法名 | 说明 |
---|---|
void write(int b) | 一次写一个字节 |
void write(byte[] b) | 一次写一个字节数组 |
void write(byte[] b, int off, int len) | (字节数组,从哪开始,写入几个) |
换行方法 | |
void write( “\r\n”.getBytes() ) | windows: \r\n linux: \n mac: \r |
public class OutPutMethods {
public static void main(String[] args) throws IOException {
// 1.一次写一个字节
FileOutputStream fos1 = new FileOutputStream("D:\\test\\1.txt");
fos1.write(97); // a
fos1.close();
// 2.一次写一个字节数组
FileOutputStream fos2 = new FileOutputStream("D:\\test\\2.txt");
byte[] bytes1 = {97, 98, 99};
fos2.write(bytes1); // abc
fos2.close();
// 3.(字节数组,从哪开始,写入几个)
FileOutputStream fos3 = new FileOutputStream("D:\\test\\3.txt");
byte[] bytes2 = {97, 98, 99, 100, 101, 102, 103};
fos3.write(bytes2, 2, 4); // cdef
fos3.close();
}
}
- 异常处理:
若字节流在读写过程中发生异常导致程序终止,而资源没有释放则会导致浪费。
将释放资源的代码放入finally方法体中则一定会执行。除非JVM停止。
public class FinallyDemo {
public static void main(String[] args) throws IOException {
FileOutputStream fos = null;
try {
fos = new FileOutputStream("D:\\test\\1.txt");
fos.write(97);
} catch (IOException e) {
e.printStackTrace();
// finally语句里的代码一定会执行
} finally {
// 如果字节流对象为null,说明没有占用资源,自然不需要再去释放
if(fos != null){
// 而在释放资源的时候也可能会报错,所以再次捕获一下
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
1.2读数据
方法名 | 说明 |
---|---|
int read() | 返回的字符在码表中对应的实际整数 -1说明文件读取完毕 |
int read(byte[] b) | 返回的是实际读取的字节个数 -1说明文件读取完毕 |
- 一次读取一个字节的数据
public class IntPutDemo {
public static void main(String[] args) throws IOException {
// 创建字节输入流对象:读
FileInputStream fis = new FileInputStream("16-io\\src\\com\\skh\\output\\a.txt");
// 通过while循环一个一个字节读取
int read;
// -1说明文件已经读取完毕
while((read = fis.read()) != -1){
System.out.println(read);
}
// 释放资源
fis.close();
}
}
- 复制文件
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
// 先读
FileInputStream fis = new FileInputStream("16-io\\src\\com\\skh\\output\\a.txt");
// 再写
FileOutputStream fos = new FileOutputStream("16-io\\src\\com\\skh\\intput\\a.txt");
int by;
while ((by = fis.read()) != -1) {
// 每个字节的数据读出来后立马写入目标文件
fos.write(by);
}
// 释放资源
fis.close();
fos.close();
}
}
- 复制文件(一次读写多个字节的数据)
public class CopyFileDemo2 {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("16-io\\src\\com\\skh\\output\\a.txt");
FileOutputStream fos = new FileOutputStream("16-io\\src\\com\\skh\\intput\\a.txt");
byte[] bytes = new byte[1024];
int length;
// read(byte[] b)返回的是实际读取的字节个数
while ((length = fis.read(bytes)) != -1) {
// 一次读取并写入一个字节数组
// 因为bytes数组的长度为1024,其中有很多初始化值,如果写入时不加长度限制则会写入很多乱码(空格、问号、null等)
fos.write(bytes,0,length);
}
// 释放资源
fis.close();
fos.close();
}
}
1.3字节缓冲流(重点)
理解:仅仅提供一个缓冲区域,本质还是一个数组,真正读写数据还是字节流对象。内存中数据的处理速度远远快于硬盘与内存之间的交互。缓冲流存在的意义就是减少硬盘与内存之间的交互次数,将反复转运数据的操作在内存中进行,从而提高性能。
- 结合缓冲流,一次读取一个数组,复制文件
public class BufferedStreamDemo {
public static void main(String[] args) throws IOException {
// 创建字节缓冲输入流对象:在底层创建了一个默认长度为8192的字节数组:new byte[8192]
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("16-io\\a.avi"));
// 创建字节缓冲输出流对象:底层同上
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("16-io\\copy.avi"));
byte[] bytes = new byte[1024];
int length;
while ((by = bis.read()) != -1){
bos.write(bytes,0,length);
}
// 释放字节缓冲流时,底层会把相应的字节流也关闭
bis.close();
bos.close();
}
}
2.字符流
处理中文乱码的问题
2.1编码表(字符集)
-
ASCII字符集(American Standard Code for Information Interchange):包括了数字,大小写字符和一些常见的标点符号。
注意:ASCII码表中是没有中文的。
-
GBK:window系统默认的码表。兼容ASCII码表,也包含了21003个汉字,并支持繁体汉字以及部分日韩文字。
注意:GBK是中国的码表,一个中文以两个字节的形式存储。但不包含世界上所有国家的文字。
-
Unicode码表:由国际组织ISO制定,是统一的万国码,计算机科学领域里的一项业界标准,容纳世界上大多数国家的所有常见文字和符号。idea和以后工作默认使用Unicode的UTF-8编解码格式。
注意: Unicode是万国码,以UTF-8编码后一个中文以三个字节的形式存储。UTF-8是一中常用的编码方式,并不是编码表。
2.2编码与解码
编码 | 说明 |
---|---|
byte[] getBytes() | 根据平台默认的字符集将String字符串编码为一系列字节存入数组中 |
byte[] getBytes(String charsetName) | 根据指定的字符集将String字符串编码为一系列字节存入数组中 |
解码 | 说明 |
String(byte[] bytes) | 根据平台默认的字符集解码字节数组来创建字符串 |
String(byte[] bytes, String charsetName) | 根据指定的字符集解码字节数组来创建字符串 |
public class CharListDemo {
public static void main(String[] args) throws UnsupportedEncodingException {
String str = "中国";
// 1.根据默认的字符集将String字符串编码为一系列字节并存入数组中
byte[] bytes1 = str.getBytes();
// 将字节数组toString一下,否则输出的是地址值
String s1 = Arrays.toString(bytes1);
// [-28, -72, -83, -27, -101, -67] 默认字符集为UTF-8,一个中文占三个字节
System.out.println(s1);
// 2.根据指定的字符集编码
byte[] bytes2 = str.getBytes("GBK");
String s2 = Arrays.toString(bytes2);
// [-42, -48, -71, -6] GBK中一个中文占两个字节
System.out.println(s2);
System.out.println("--------------------------------------------------");
byte[] bytes3 = {-28, -72, -83, -27, -101, -67};
byte[] bytes4 = {-42, -48, -71, -6};
// 3.根据平台默认的字符集解码字节数组来创建字符串
String s3 = new String(bytes3);
System.out.println(s3);
// 4.根据指定的字符集解码
String s4 = new String(bytes4, "GBK");
System.out.println(s4);
}
}
2.3写数据
Writer: 用于写入字符流的抽象父类
FileWriter: 用于写入字符流的常用子类
常用构造方法 | 说明 |
---|---|
FileWriter(File file) | 根据给定的 File 对象构造一个 FileWriter 对象 |
FileWriter(String fileName) | 根据给定的文件名构造一个 FileWriter 对象 |
主要成员方法 | 说明 |
void write(int c) | 写一个字符 |
void write(char[] cbuf) | 写入一个字符数组 |
void write(char[] cbuf, int off, int len) | 写入字符数组的一部分,可能会出现角标越界 |
void write(String str) | 写一个字符串 |
void write(String str, int off, int len) | 写一个字符串的一部分,可能会出现角标越界 |
刷新和关闭的方法 | 说明 |
---|---|
flush() | 刷新流,之后还可以继续写数据 |
close() | 关闭流,释放资源,之后不能再写数据。但是在关闭之前会先刷新流 |
public class FileWriterDemo {
public static void main(String[] args) throws IOException {
// 1.先写数据
FileWriter fw = new FileWriter("16-io\\src\\com\\skh\\charstream\\charStream.txt");
// 一次写入一个字符
fw.write(98);
fw.write("\r\n");
// 一次写入一个字符数组
char[] bytes = {99, 100, 101, 102, 103, 104};
fw.write(bytes);
fw.write("\r\n");
// 一次写入一个字符数组的一部分
fw.write(bytes, 2, 3);
fw.write("\r\n");
// 一次写入一个字符串
String s = "skhString";
fw.write(s);
fw.write("\r\n");
// 一次写入一个字符串的一部分
fw.write(s, 3, 5);
// 释放资源
fw.close();
}
}
------------------------------------------------------------------------------------------------------------
结果:
b
cdefgh
efg
skhString
eiMaS
2.4读数据
Reader: 用于读取字符流的抽象父类
FileReader: 用于读取字符流的常用子类
构造方法 | 说明 |
---|---|
FileReader(File file) | 在给定从中读取数据的 File 的情况下创建一个新 FileReader |
FileReader(String fileName) | 在给定从中读取数据的文件名的情况下创建一个新 FileReader |
方法名 | 说明 |
int read() | 一次读一个字符数据 |
int read(char[] cbuf) | 一次读一个字符数组数据 |
public class FileReaderDemo {
public static void main(String[] args) throws IOException {
// 2.再读数据
FileReader fr = new FileReader("16-io\\src\\com\\skh\\charstream\\charStream.txt");
// 一次读取一个字符
int ch;
while ((ch = fr.read()) != -1) {
System.out.print((char) ch);
}
System.out.println("-------------------------上面读取的数据,不能再次读取了-------------------------");
// 一次读取一个字符数组
char[] chars = new char[4];
int length;
while ((length = fr.read(chars)) != -1){
System.out.println(new String(chars,0,length));
}
fr.close();
}
}
------------------------------------------------------------------------------------------------------------
结果:
b
cdefgh
efg
skhString
eiMaS
2.5字符缓冲流
构造方法 | 说明 |
---|---|
BufferedWriter(Writer out) | 创建字符缓冲输出流对象 |
BufferedReader(Reader in) | 创建字符缓冲输入流对象 |
public class CharBufferedStreamDemo {
public static void main(String[] args) throws IOException {
// 字符缓冲输出流:写入的实际内容都是该整数在编码表中对应的字符
BufferedWriter bw = new BufferedWriter(new FileWriter("16-io\\a.txt"));
bw.write(97);
bw.write("\r\n");
char[] chars = {98,99,100,101,102};
bw.write(chars);
bw.write("\r\n");
bw.write(chars,1,3);
bw.write("\r\n");
bw.write("小白程序员");
bw.write("\r\n");
String str = "qwertyui";
bw.write(str,2,4);
bw.write("\r\n");
bw.flush();
bw.close();
// 字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("16-io\\a.txt"));
char[] chars = new char[1024];
int length;
while ((length = br.read(chars)) != -1) {
System.out.println(new String(chars,0,length));
}
br.close();
}
}
特有方法 | 说明 |
---|---|
BufferedWriter void newLine() | 跨平台的回车换行 |
BufferedReader String readLine() | 一次性读一行文字,不会读取换行符。 读取完毕则为null 这里也再次证明已经读取过的数据不能再次读了! |
public class SpecificMethods {
public static void main(String[] args) throws IOException {
// 字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("16-io\\a.txt"));
bw.write(97);
bw.newLine();
bw.close();
// 字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("16-io\\a.txt"));
String str;
while ((str = br.readLine()) != null) {
System.out.println(str);
}
br.close();
}
}
2.6IO流小结
3.转换流
在jdk11之前,因为FileWriter和FileReader不能指定字符集,所以才出现转换流,用来设置字符集
jdk11之后,为了方便进行了优化。FileWriter和FileReader也可以直接指定字符集
OutputStreamReader:转换输出流,是字节流到字符流的桥梁(FileInputStream → InputStreamReader → FileReader)
InputStreamWriter: 转换输入流,是字符流到字节流的桥梁 (FileOutputStream →OutStreamWriter → FileWriter)
构造方法 | 说明 |
---|---|
InputStreamReader(InputStream in) | 使用默认字符编码创建InputStreamReader对象 |
InputStreamReader(InputStream in,String chatset) | 使用指定的字符编码创建InputStreamReader对象 |
OutputStreamWriter(OutputStream out) | 使用默认字符编码创建OutputStreamWriter对象 |
OutputStreamWriter(OutputStream out,String charset) | 使用指定的字符编码创建OutputStreamWriter对象 |
public class TransformStreamDemo {
public static void main(String[] args) throws IOException {
// 转换输出流:指定字符集
// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("16-io\\src\\com\\skh\\TransformStream\\a.txt"), "GBK");
// 转换输出流:默认字符集(UTF-8)
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("16-io\\src\\com\\skh\\TransformStream\\a.txt"));
osw.write("小白程序员");
osw.close();
// 转换输入流:默认字符集(UTF-8)
InputStreamReader isr = new InputStreamReader(new FileInputStream("16-io\\src\\com\\skh\\TransformStream\\a.txt"));
int ch;
while ((ch = isr.read()) != -1) {
System.out.println((char) ch);
}
isr.close();
}
}
4.对象操作流
4.1对象序列化:
构造方法 | 说明 |
---|---|
ObjectOutputStream(OutputStream out) | 创建一个写入指定的OutputStream的ObjectOutputStream |
写对象 | 说明 |
void writeObject(Object obj) | 将指定的对象写入ObjectOutputStream |
public class ObjectStreamDemo {
public static void main(String[] args) throws IOException {
// 对象操作输出流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("16-io\\src\\com\\skh\\ObjectStream\\a.txt"));
Student stu = new Student("王导", 23);
oos.writeObject(stu);
oos.close();
}
}
------------------------------------------------------------------------------------------------------------
结果:
�� sr com.skh.ObjectStream.Student���峩� I ageL namet Ljava/lang/String;xp t 王导
注意:
- 一个对象要想被序列化,该对象所属的类必须必须实现Serializable 接口
- Serializable是一个标记接口,实现该接口,不需要重写任何方法
4.2对象反序列化:
构造方法 | 说明 |
---|---|
ObjectInputStream(InputStream in) | 创建从指定的InputStream读取的ObjectInputStream |
读对象 | 说明 |
Object readObject() | 从ObjectInputStream读取一个对象 |
public class ObjectStreamDemo {
public static void main(String[] args) throws IOException, ClassNotFoundException {
// 对象操作输出流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("16-io\\src\\com\\skh\\ObjectStream\\a.txt"));
Student stu = new Student("王导", 23);
oos.writeObject(stu);
oos.close();
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("16-io\\src\\com\\skh\\ObjectStream\\a.txt"));
Object object = ois.readObject();
Student student = (Student)object;
System.out.println(student);
}
}
------------------------------------------------------------------------------------------------------------
结果:
Student{name='王导', age=23}
4.3 serialVersionUID
自定类时,系统会默认给创建一个serialVersionUID,改变该类中的任何信息都会改变serialVersionUID的数值
所以在序列化了一个对象后,改变类文件,再反序列化对象的时候就会报 InvalidClassException(无效的类异常)
所以要自己手动将serialVersionUID设置为静态的,设置的两个步骤如下👇:
4.4transient(很少用)
如果一个对象中的某个成员变量的值不想被序列化,可以用transient关键字修饰。
这样在进行对象序列化的时候该属性的值就不会写到文件中,反序列化读取的时候会显示对应类型的默认值。
5.Properties
-
它并不是IO体系的成员,而是集合体系的,是一个Map体系的集合类。
-
之所以将它放在IO体系中学习,是因为其中有跟IO相关的方法。
-
Properties类在创建对象时,其后是没有泛型的,意味着可以存任意类型的数据。但在实际使用中只存字符串。
5.1Properties拥有Map集合的所有方法
public class PropertiesDemo1 {
public static void main(String[] args) {
Properties prop = new Properties();
//增
prop.put("小龙女","尹志平");
prop.put("郭襄","杨过");
prop.put("黄蓉","欧阳克");
System.out.println(prop);
//删
prop.remove("郭襄");
System.out.println(prop);
//改
//put --- 如果键不存在,那么就添加,如果键存在,那么就覆盖.
prop.put("小龙女","杨过");
System.out.println(prop);
//查
Object value = prop.get("黄蓉");
System.out.println(value);
//遍历1
Set<Object> keys = prop.keySet();
for (Object key : keys) {
Object value = prop.get(key);
System.out.println(key + "=" + value);
}
//遍历2
Set<Map.Entry<Object, Object>> entries = prop.entrySet();
for (Map.Entry<Object, Object> entry : entries) {
Object key = entry.getKey();
Object value = entry.getValue();
System.out.println(key + "=" + value);
}
}
}
5.2Properties作为Map集合的特有方法
手写 <.properties>文件的规范:键=值,无空格,结尾无分号
方法名 | 说明 |
---|---|
Object setProperty(String key, String value) | 设置集合的键和值,都是String类型,底层调用 Hashtable 的 put 方法。 相当于Map方法中的 put 方法 |
String getProperty(String key) | 使用此属性列表中指定的键搜索属性。相当于Map方法中的 get 方法 |
Set stringPropertyNames() | 返回一个不可修改的键集,其中键及其对应的值是字符串 |
public class PropertiesDemo2 {
public static void main(String[] args) {
//1.Object setProperty(String key, String value)
Properties prop = new Properties();
prop.setProperty("江苏","南京");
prop.setProperty("安徽","南京");
prop.setProperty("山东","济南");
System.out.println(prop);
//2.String getProperty(String key)
String value = prop.getProperty("江苏");
System.out.println(value);
//3.Set<String> stringPropertyNames()
Set<String> keys = prop.stringPropertyNames();
for (String key : keys) {
String value = prop.getProperty(key);
System.out.println(key + "=" + value);
}
}
}
5.3Properties和IO流相结合的方法
方法名 | 说明 |
---|---|
void load(Reader reader) | 将本地文件中的键值对数据读取到集合中 |
void store(Writer writer, String comments) | 将集合中的数据以键值对的形式保存在本地,第二个参数为注释 |
public class LoadDemo {
public static void main(String[] args) throws IOException {
// 创建一个集合
Properties prop = new Properties();
// 创建一个字符输入流对象
FileReader fr = new FileReader("16-io\\src\\com\\skh\\Properties\\prop.properties");
// 调用集合的load方法:此时文件中数据就已经以键值对的形式存储到集合中了
prop.load(fr);
fr.close();
// 数据顺序是不对的?因为Map中的键是无须的,所以只需要查看内容完整即可
System.out.println(prop);
}
}
public class StoreDemo {
public static void main(String[] args) throws IOException {
Properties prop = new Properties();
prop.put("zhangsan","123");
prop.put("lisi","456");
prop.put("wangwu","789");
FileWriter fw = new FileWriter("16-io\\src\\com\\skh\\Properties\\prop.properties");
// 第二个参数为注释,会写在文件的第一行,直接传一个null即可
prop.store(fw,null);
fw.close();
}
}