头歌java课程实验（Java中的IO流操作）
任务描述
本关任务：使用File类对文件进行基本操作
1.打印输出改file类对象是否可写
2.打印输出改file类对象的绝对路径
3.重命名file.txt为newfile.txt
4.删除newfile.txt文件
相关知识
1.File类概述
File类用于封装一个路径，这个路径可以是从系统盘符开始的绝对路径，如：“D:\file\a.txt”，也可以是相对于当前目录而言的相对路径，如：“src\Hello.java”。File类内部封装的路径可以指向一个文件，也可以指向一个目录，在File类中提供了针对这些文件或目录的一些常规操作。
文件和目录路径名的抽象表示形式，表示一个文件或文件夹，并提供了一系列操作文件或文件夹的方法
File类中提供了一系列方法，用于操作其内部封装的路径指向的文件或者目录，例如判断文件/目录是否存在、创建、删除文件/目录等。
2. 构造方法
方法 功能描述
File(String pathname) 根据路径得到File对象
File(String parent,String child) 根据目录和子文件/目录得到对象
File(File parent,String child) 根据父File对象和子文件/目录得到对象
示例代码
package cn.itcast_01;
import java.io.File;
/*
* 我们要想实现IO的操作，就必须知道硬盘上文件的表现形式。
* 而Java就提供了一个类File供我们使用。
*
* File:文件和目录(文件夹)路径名的抽象表示形式
* 构造方法：
* File(String pathname)：根据一个路径得到File对象
* File(String parent, String child):根据一个目录和一个子文件/目录得到File对象
* File(File parent, String child):根据一个父File对象和一个子文件/目录得到File对象
*/
public class FileDemo {
public static void main(String[] args) {
// File(String pathname)：根据一个路径得到File对象
// 把e:\\demo\\a.txt封装成一个File对象
File file = new File("E:\\demo\\a.txt");
// File(String parent, String child):根据一个目录和一个子文件/目录得到File对象
File file2 = new File("E:\\demo", "a.txt");
// File(File parent, String child):根据一个父File对象和一个子文件/目录得到File对象
File file3 = new File("e:\\demo");
File file4 = new File(file3, "a.txt");
// 以上三种方式其实效果一样
}
}
创建功能
返回值 方法 功能描述
boolean createNewFile() 创建文件
File createTempFile() 创建一个用于缓存的临时文件
boolean mkdir() 创建文件夹
boolean mkdirs() 创建多级文件夹，如果父级文件夹不存在，会自动创建
代码示例
package cn.itcast_02;
import java.io.File;
import java.io.IOException;
/*
*创建功能：
*public boolean createNewFile():创建文件 如果存在这样的文件，就不创建了
*public boolean mkdir():创建文件夹 如果存在这样的文件夹，就不创建了
*public boolean mkdirs():创建文件夹,如果父文件夹不存在，会帮你创建出来
*/
public class FileDemo {
public static void main(String[] args) throws IOException {
// 需求：我要在e盘目录下创建一个文件夹demo
File file = new File("e:\\demo");
System.out.println("mkdir:" + file.mkdir());
// 需求:我要在e盘目录demo下创建一个文件a.txt
File file2 = new File("e:\\demo\\a.txt");
System.out.println("createNewFile:" + file2.createNewFile());
// 需求：我要在e盘目录test下创建一个文件b.txt
// Exception in thread "main" java.io.IOException: 系统找不到指定的路径。
// 注意：要想在某个目录下创建内容，该目录首先必须存在。
// File file3 = new File("e:\\test\\b.txt");
// System.out.println("createNewFile:" + file3.createNewFile());
// 需求:我要在e盘目录test下创建aaa目录
// File file4 = new File("e:\\test\\aaa");
// System.out.println("mkdir:" + file4.mkdir());
// File file5 = new File("e:\\test");
// File file6 = new File("e:\\test\\aaa");
// System.out.println("mkdir:" + file5.mkdir());
// System.out.println("mkdir:" + file6.mkdir());
// 其实我们有更简单的方法
File file7 = new File("e:\\aaa\\bbb\\ccc\\ddd");
System.out.println("mkdirs:" + file7.mkdirs());
// 看下面的这个东西：
File file8 = new File("e:\\liuyi\\a.txt");
System.out.println("mkdirs:" + file8.mkdirs());
}
}
3. 删除功能
返回值 方法 功能描述
boolean delete() 删除文件或文件夹
void deleteOnExit() JVM退出时删除File对象对应的文件和目录
代码示例
package cn.itcast_03;
import java.io.File;
import java.io.IOException;
/*
* 删除功能:public boolean delete()
*
* 注意：
* A:如果你创建文件或者文件夹忘了写盘符路径，那么，默认在项目路径下。
* B:Java中的删除不走回收站。
* C:要删除一个文件夹，请注意该文件夹内不能包含文件或者文件夹
*/
public class FileDemo {
public static void main(String[] args) throws IOException {
// 创建文件
// File file = new File("e:\\a.txt");
// System.out.println("createNewFile:" + file.createNewFile());
// 我不小心写成这个样子了
File file = new File("a.txt");
System.out.println("createNewFile:" + file.createNewFile());
// 继续玩几个
File file2 = new File("aaa\\bbb\\ccc");
System.out.println("mkdirs:" + file2.mkdirs());
// 删除功能：我要删除a.txt这个文件
File file3 = new File("a.txt");
System.out.println("delete:" + file3.delete());
// 删除功能：我要删除ccc这个文件夹
File file4 = new File("aaa\\bbb\\ccc");
System.out.println("delete:" + file4.delete());
// 删除功能：我要删除aaa文件夹
// File file5 = new File("aaa");
// System.out.println("delete:" + file5.delete());
File file6 = new File("aaa\\bbb");
File file7 = new File("aaa");
System.out.println("delete:" + file6.delete());
System.out.println("delete:" + file7.delete());
}
}
4. 重命名功能
方法 功能描述
renamneTo(File dest) 路径名相同就是重命名，不一样就是改名加剪切
代码示例
package cn.itcast_04;
import java.io.File;
/*
* 重命名功能:public boolean renameTo(File dest)
* 如果路径名相同，就是改名。
* 如果路径名不同，就是改名并剪切。
*
* 路径以盘符开始：绝对路径 c:\\a.txt
* 路径不以盘符开始：相对路径 a.txt
*/
public class FileDemo {
public static void main(String[] args) {
// 创建一个文件对象
// File file = new File("林青霞.jpg");
// // 需求：我要修改这个文件的名称为"东方不败.jpg"
// File newFile = new File("东方不败.jpg");
// System.out.println("renameTo:" + file.renameTo(newFile));
File file2 = new File("东方不败.jpg");
File newFile2 = new File("e:\\林青霞.jpg");
System.out.println("renameTo:" + file2.renameTo(newFile2));
}
}
5.获取功能
返回值 方法 功能描述
String getAbsolutePath() 获取绝对路径
String getPath() 获取相对路径
String getParent() 获取父目录
String getName() 获取名称
long getFreeSpace() 获取剩余可用空间
long getTotalSpace() 获取总大小
long length() 获取长度，字节数
long lastModified() 获取最后一次修改时间，毫秒值
String[] list() 获取指定目录下的所有文件或文件夹的名称数组
File[] listFiles() 获取指定目录下的所有文件或文件夹的File数组
代码示例
package cn.itcast_06;
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
* 获取功能：
* public String getAbsolutePath()：获取绝对路径
* public String getPath():获取相对路径
* public String getName():获取名称
* public long length():获取长度。字节数
* public long lastModified():获取最后一次的修改时间，毫秒值
*/
public class FileDemo {
public static void main(String[] args) {
// 创建文件对象
File file = new File("demo\\test.txt");
System.out.println("getAbsolutePath:" + file.getAbsolutePath());
System.out.println("getPath:" + file.getPath());
System.out.println("getName:" + file.getName());
System.out.println("length:" + file.length());
System.out.println("lastModified:" + file.lastModified());
// 1416471971031
Date d = new Date(1416471971031L);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String s = sdf.format(d);
System.out.println(s);
}
}
6.判断功能
方法 功能描述
isDirectory() 判断是否是目录
isFile() 判断是否是文件
exists() 判断是否是存在
canRead() 判断是否是可读
canWrite() 判断是否是可写
isHidden() 判断是否是隐藏
isAbsolute() 是否是绝对路径
示例代码
import java.io.File;
/*
* 判断功能:
* public boolean isDirectory():判断是否是目录
* public boolean isFile():判断是否是文件
* public boolean exists():判断是否存在
* public boolean canRead():判断是否可读
* public boolean canWrite():判断是否可写
* public boolean isHidden():判断是否隐藏
*/
public class FileDemo {
public static void main(String[] args) {
// 创建文件对象
File file = new File("a.txt");
System.out.println("isDirectory:" + file.isDirectory());// false
System.out.println("isFile:" + file.isFile());// true
System.out.println("exists:" + file.exists());// true
System.out.println("canRead:" + file.canRead());// true
System.out.println("canWrite:" + file.canWrite());// true
System.out.println("isHidden:" + file.isHidden());// false
}
}
编程要求
根据提示，在右侧编辑器补充代码，完成以下任务：
1.打印输出改file类对象是否可写
2.打印输出改file类对象的绝对路径
3.重命名file.txt为newfile.txt
4.删除newfile.txt文件
测试说明
无输入
开始你的任务吧，祝你成功！
package step1;import java.io.File;public class IOFileStream {public void run() {// ---------------------Begin------------------------// 获取file.txt文件（路径为：src/step1/file.txt）的File对象File file = new File("src/step1/file.txt");// 1. 打印输出该file类对象是否可写System.out.println(file.canWrite());// 2. 打印输出该file类对象的绝对路径System.out.println(file.getAbsolutePath());// 3. 重命名file.txt为newfile.txtFile newfile = new File("src/step1/newfile.txt");boolean renamed = file.renameTo(newfile);// 4. 删除newfile.txt文件boolean deleted = newfile.delete();// ---------------------End------------------------}
}第2关：IO流之字符流
任务描述
本关任务：
1.读取file.txt文件内容并打印输出
2.复制file.txt文件到新的文件（newfile.txt）中
相关知识
1.字符流
InputStream类和OutputStream类在读写文件时操作的都是字节，如果希望在程序中操作字符，使用这两个类就不太方便，为此JDK提供了字符流。同字节流一样，字符流也有两个抽象的顶级父类，分别是Reader和Writer。其中Reader是字符输入流，用于从某个源设备读取字符，Writer是字符输出流，用于向某个目标设备写入字符。Reader和Writer作为字符流的顶级父类，也有许多子类，接下来通过继承关系图来列出Reader和Writer的一些常用子类，如图所示。
2 转换流出现的原因及思想
由于字节流操作中文不是特别方便，所以，java就提供了转换流。字符流=字节流+编码表。
编码表：由字符及其对应的数值组成的一张表
常见编码表
计算机只能识别二进制数据，早期由来是电信号。为了方便应用计算机，让它可以识别各个国家的文字。就将各个国家的文字用数字来表示，并一一对应，形成一张表。
字符串中的编码问题
编码：把看得懂的变成看不懂的
解码：把看不懂的变成看得懂
package cn.itcast_01;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
/*
* String(byte[] bytes, String charsetName):通过指定的字符集解码字节数组
* byte[] getBytes(String charsetName):使用指定的字符集合把字符串编码为字节数组
*
* 编码:把看得懂的变成看不懂的
* String -- byte[]
*
* 解码:把看不懂的变成看得懂的
* byte[] -- String
*
* 举例：谍战片(发电报，接电报)
*
* 码表：小本子
* 字符 数值
*
* 要发送一段文字：
* 今天晚上在老地方见
*
* 发送端：今 -- 数值 -- 二进制 -- 发出去
* 接收端：接收 -- 二进制 -- 十进制 -- 数值 -- 字符 -- 今
*
* 今天晚上在老地方见
*
* 编码问题简单，只要编码解码的格式是一致的。
*/
public class StringDemo {
public static void main(String[] args) throws UnsupportedEncodingException {
String s = "你好";
// String -- byte[]
byte[] bys = s.getBytes(); // [-60, -29, -70, -61]
// byte[] bys = s.getBytes("GBK");// [-60, -29, -70, -61]
// byte[] bys = s.getBytes("UTF-8");// [-28, -67, -96, -27, -91, -67]
System.out.println(Arrays.toString(bys));
// byte[] -- String
String ss = new String(bys); // 你好
// String ss = new String(bys, "GBK"); // 你好
// String ss = new String(bys, "UTF-8"); // ???
System.out.println(ss);
}
}
3 转换流概述
IO流可分为字节流和字符流，有时字节流和字符流之间也需要进行转换。在JDK中提供了两个类可以将字节流转换为字符流，它们分别是InputStreamReader和OutputStreamWriter。
OutputStreamWriter是Writer的子类，它可以将一个字节输出流转换成字符输出流，方便直接写入字符，而InputStreamReader是Reader的子类，它可以将一个字节输入流转换成字符输入流，方便直接读取字符。通过转换流进行数据读写的过程如图所示。
OutputStreamWriter 字符输出流
InputStreamReader 字符输入流
OutputStreamWriter写数据
方法 功能描述
write(int c) 写入一个字符
write(char[] cbuf) 写入一个字符数组
write(char[] cbuf,int off,int len) 写入一个字符数组的一部分
write(String str) 写入一个字符串
write(String str,int off,int len) 写入一个字符串的一部分
字符流操作要注意的问题：
字符流数据没有直接进文件而是到缓冲区，所以要刷新缓冲区。
flush()和close()的区别：
A：close()关闭流对象，但是先刷新一次缓冲区。关闭之后，流对象不可以继续再使用了。
B：flush()仅仅刷新缓冲区,刷新之后，流对象还可以继续使用。
package cn.itcast_03;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
/*
* OutputStreamWriter的方法：
* public void write(int c):写一个字符
* public void write(char[] cbuf):写一个字符数组
* public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
* public void write(String str):写一个字符串
* public void write(String str,int off,int len):写一个字符串的一部分
*/
public class OutputStreamWriterDemo {
public static void main(String[] args) throws IOException {
// 创建对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
"osw2.txt"));
// 写数据
// public void write(int c):写一个字符
// osw.write('a');
// osw.write(97);
// 为什么数据没有进去呢?
// 原因是：字符 = 2字节
// 文件中数据存储的基本单位是字节。
// void flush()
// public void write(char[] cbuf):写一个字符数组
// char[] chs = {'a','b','c','d','e'};
// osw.write(chs);
// public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
// osw.write(chs,1,3);
// public void write(String str):写一个字符串
// osw.write("我爱林青霞");
// public void write(String str,int off,int len):写一个字符串的一部分
osw.write("我爱林青霞", 2, 3);
// 刷新缓冲区
osw.flush();
// osw.write("我爱林青霞", 2, 3);
// 释放资源
osw.close();
// java.io.IOException: Stream closed
// osw.write("我爱林青霞", 2, 3);
}
}
4 InputStreamReader读数据
public int read()：一次读一个字符
public int read(char[] cbuf)：一次读一个字符数组
package cn.itcast_03;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
/*
* InputStreamReader的方法：
* int read():一次读取一个字符
* int read(char[] chs):一次读取一个字符数组
*/
public class InputStreamReaderDemo {
public static void main(String[] args) throws IOException {
// 创建对象
InputStreamReader isr = new InputStreamReader(new FileInputStream(
"StringDemo.java"));
// 一次读取一个字符
// int ch = 0;
// while ((ch = isr.read()) != -1) {
// System.out.print((char) ch);
// }
// 一次读取一个字符数组
char[] chs = new char[1024];
int len = 0;
while ((len = isr.read(chs)) != -1) {
System.out.print(new String(chs, 0, len));
}
// 释放资源
isr.close();
}
}
5 字符流复制文本文件
package cn.itcast_04;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
/*
* 需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
*
* 数据源：
* a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader
* 目的地：
* b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter
*/
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
// 封装数据源
InputStreamReader isr = new InputStreamReader(new FileInputStream(
"a.txt"));
// 封装目的地
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
"b.txt"));
// 读写数据
// 方式1
// int ch = 0;
// while ((ch = isr.read()) != -1) {
// osw.write(ch);
// }
// 方式2
char[] chs = new char[1024];
int len = 0;
while ((len = isr.read(chs)) != -1) {
osw.write(chs, 0, len);
// osw.flush();
}
// 释放资源
osw.close();
isr.close();
}
}
编程要求
根据提示，在右侧编辑器补充代码，完成以下任务：
1.读取file.txt文件内容并打印输出
2.复制file.txt文件到新的文件（newfile.txt）中
测试说明
平台会对你编写的代码进行测试：
无输入
开始你的任务吧，祝你成功！
package step2;import java.io.*;public class IOCharStream {public void run() throws IOException {
// ---------------------Begin------------------------
// 1.读取file.txt文件内容并打印输出, 2.复制file.txt文件到新的文件（newfile.txt）中FileInputStream fileInputStream = new FileInputStream("src/step2/file.txt");InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("src/step2/newfile.txt"));int ch = 0;while ((ch = inputStreamReader.read() )!= -1){System.out.printf(String.valueOf((char) ch));outputStreamWriter.write(ch);}inputStreamReader.close();outputStreamWriter.close();fileInputStream.close();
// ---------------------End------------------------}}
第3关：IO流之字节流
任务描述
本关任务：
1.向file.txt中写入字符串“hello,world!”（不包括双引号）
相关知识
1. 流的概念
流(stream)的概念源于UNIX中管道(pipe)的概念。在UNIX中，管道是一条不间断的字节流，用来实现程序或进程间的通信，或读写外围设备、外部文件等。
一个流，必有源端和目的端，它们可以是计算机内存的某些区域，也可以是磁盘文件，甚至可以是Internet上的某个URL。
流的方向是重要的，根据流的方向，流可分为两类：输入流和输出流。用户可以从输入流中读取信息，但不能写它。相反，对输出流，只能往输入流写，而不能读它。
实际上，流的源端和目的端可简单地看成是字节的生产者和消费者，对输入流，可不必关心它的源端是什么，只要简单地从流中读数据，而对输出流，也可不知道它的目的端，只是简单地往流中写数据。
形象的比喻——水流 ，文件==程序 ，文件和程序之间连接一个管道，水流就在之间形成了,自然也就出现了方向：可以流进，也可以流出.便于理解，这么定义流： 流就是一个管道里面有流水，这个管道连接了文件和程序。
2. IO流概述
大多数应用程序都需要实现与设备之间的数据传输，例如键盘可以输入数据，显示器可以显示程序的运行结果等。在Java中，将这种通过不同输入输出设备（键盘，内存，显示器，网络等）之间的数据传输抽象的表述为“流”，程序允许通过流的方式与输入输出设备进行数据传输。Java中的“流”都位于Java.io包中，称之为IO（输入输出）流。 IO流：即InputOutput的缩写。
输入流和输出流相对于内存设备而言。将外设中的数据读取到内存中：输入。将内存的数写入到外设中：输出。
IO流的特点：
IO流用来处理设备间的数据传输。
Java对数据的操作是通过流的方式。
Java用于操作流的对象都在IO包中。
流按操作数据分为两种：字节流和字符流。
流按流向分为：输入流和输出流。
PS：流只能操作数据，而不能操作文件。
3. 流的三种分类方式
按流的方向分为：输入流和输出流
按流的数据单位不同分为：字节流和字符流
按流的功能不同分为:节点流和处理流
4 字节流写数据
字节输出流：抽象类OutputStream，实现类FileOutputStream
字节输出流操作步骤：
创建字节输出流对象
写数据
释放资源
字节流写数据的方式
方法 说明
write(int b) 一次写一个字节
write(byte[] b) 一次写一个字节数组
write(byte[] b,int off,int len) 一次写一个字节数组的一部分
flush() 刷新缓冲区
close() 释放资源
如何实现数据的换行?
为什么没有换行呢?因为只是写了字节数据，并没有写入换行符号。
如何实现呢?写入换行符号即可
PS：不同的系统针对不同的换行符号识别是不一样的?
windows：\r\n
linux：\n
Mac：\r
而一些常见的个高级记事本，是可以识别任意换行符号的。
如何实现数据的追加写入?
用构造方法带第二个参数是true的情况即可
package cn.itcast_01;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 需求：我要往一个文本文件中输入一句话："hello,io"
*
* 分析：
* A:这个操作最好是采用字符流来做，但是呢，字符流是在字节流之后才出现的，所以，今天我先讲解字节流如何操作。
* B:由于我是要往文件中写一句话，所以我们要采用字节输出流。
*/
public class FileOutputStreamDemo {
public static void main(String[] args) throws IOException {
// 创建字节输出流对象
// FileOutputStream(File file)
// File file = new File("fos.txt");
// FileOutputStream fos = new FileOutputStream(file);
// FileOutputStream(String name)
FileOutputStream fos = new FileOutputStream("fos.txt");
/*
* 创建字节输出流对象了做了几件事情：
* A:调用系统功能去创建文件
* B:创建fos对象
* C:把fos对象指向这个文件
*/
//写数据
fos.write("hello,IO".getBytes());
fos.write("java".getBytes());
//释放资源
//关闭此文件输出流并释放与此流有关的所有系统资源。
fos.close();
/*
* 为什么一定要close()呢?
* A:让流对象变成垃圾，这样就可以被垃圾回收器回收了
* B:通知系统去释放跟该文件相关的资源
*/
//java.io.IOException: Stream Closed
//fos.write("java".getBytes());
}
}
编程要求
根据提示，在右侧编辑器补充代码，完成以下任务：
1.向file.txt中写入字符串“hello,world!”（不包括双引号）
测试说明
平台会对你编写的代码进行测试：
无输入
开始你的任务吧，祝你成功！
package step3;import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;public class IOByteStream {public void run() throws IOException {// ---------------------Begin------------------------//文件保存路径必须为 src/step3/file.txt, 写入的文件内容为 hello,world!FileOutputStream fileOutputStream = new FileOutputStream("src/step3/file.txt");fileOutputStream.write("hello,world!".getBytes());fileOutputStream.close();// ---------------------End------------------------
}
}
第4关：Properties集合
任务描述
本关任务：学会Properties集合的使用，添加两个元素分别为：
fruit=apple，animal=cat，并将Properties保存到fileName中
相关知识
1.Properties集合
1.1Properties作为Map集合的使用【应用】
Properties介绍
是一个Map体系的集合类
Properties可以保存到流中或从流中加载
属性列表中的每个键及其对应的值都是一个字符串
Properties基本使用
public class PropertiesDemo01 {
public static void main(String[] args) {
//创建集合对象
// Properties<String,String> prop = new Properties<String,String>(); //错误
Properties prop = new Properties();
//存储元素
prop.put("itheima001", "林青霞");
prop.put("itheima002", "张曼玉");
prop.put("itheima003", "王祖贤");
//遍历集合
Set<Object> keySet = prop.keySet();
for (Object key : keySet) {
Object value = prop.get(key);
System.out.println(key + "," + value);
}
}
}
1.2Properties作为Map集合的特有方法【应用】
特有方法
方法名 说明
Object setProperty(String key, String value) 设置集合的键和值，都是String类型，底层调用 Hashtable方法 put
String getProperty(String key) 使用此属性列表中指定的键搜索属性
Set stringPropertyNames() 从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串
示例代码
public class PropertiesDemo02 {
public static void main(String[] args) {
//创建集合对象
Properties prop = new Properties();
//Object setProperty(String key, String value)：设置集合的键和值，都是String类型，底层调用Hashtable方法put
prop.setProperty("itheima001", "林青霞");
/*
Object setProperty(String key, String value) {
return put(key, value);
}
Object put(Object key, Object value) {
return map.put(key, value);
}
*/
prop.setProperty("itheima002", "张曼玉");
prop.setProperty("itheima003", "王祖贤");
//String getProperty(String key)：使用此属性列表中指定的键搜索属性
// System.out.println(prop.getProperty("itheima001"));
// System.out.println(prop.getProperty("itheima0011"));
// System.out.println(prop);
//Set<String> stringPropertyNames()：从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串
Set<String> names = prop.stringPropertyNames();
for (String key : names) {
// System.out.println(key);
String value = prop.getProperty(key);
System.out.println(key + "," + value);
}
}
}
1.3Properties和IO流相结合的方法【应用】
和IO流结合的方法
方法名 说明
void load(InputStream inStream) 从输入字节流读取属性列表（键和元素对）
void load(Reader reader) 从输入字符流读取属性列表（键和元素对）
void store(OutputStream out, String comments) 将此属性列表（键和元素对）写入此 Properties表中，以适合于使用 load(InputStream)方法的格式写入输出字节流
void store(Writer writer, String comments) 将此属性列表（键和元素对）写入此 Properties表中，以适合使用 load(Reader)方法的格式写入输出字符流
示例代码
public class PropertiesDemo03 {
public static void main(String[] args) throws IOException {
//把集合中的数据保存到文件
// myStore();
//把文件中的数据加载到集合
myLoad();
}
private static void myLoad() throws IOException {
Properties prop = new Properties();
//void load(Reader reader)：
FileReader fr = new FileReader("myOtherStream\\fw.txt");
prop.load(fr);
fr.close();
System.out.println(prop);
}
private static void myStore() throws IOException {
Properties prop = new Properties();
prop.setProperty("itheima001","林青霞");
prop.setProperty("itheima002","张曼玉");
prop.setProperty("itheima003","王祖贤");
//void store(Writer writer, String comments)：
FileWriter fw = new FileWriter("myOtherStream\\fw.txt");
prop.store(fw,null);
fw.close();
}
}
编程要求
根据提示，在右侧编辑器补充代码，学会Properties集合的使用，添加两个元素分别为：
fruit=apple，animal=cat，并将Properties保存到fileName中
测试说明
平台会对你编写的代码进行测试：
预期输出：
fruit,apple
animal,cat
开始你的任务吧，祝你成功！
package step4;import java.io.FileWriter;
import java.util.Properties;
import java.util.Set;public class PropertieExample {public void run() throws Exception {String fileName = "src/step4/fw.txt";// ---------------------Begin------------------------Properties properties = new Properties();properties.setProperty("fruit", "apple");properties.setProperty("animal", "cat");// 将Properties保存到文件中FileWriter fileWriter = new FileWriter(fileName);properties.store(fileWriter, "Properties Example");fileWriter.close();// ---------------------End------------------------}
}