一、流的概念
二、流的分类
- 按方向【重点】:
- 输入流:将<存储设备>中的内容读入到<内存>中。
- 输出流:将<内存>中的内容写入到<存储设备>中。
- 按单位:
- 字节流:以字节为单位,可以读写所有数据。
- 字符流:以字符为单位,只能读写文本数据。
- 按功能:
- 节点流:具有实际传输数据的读写功能。
- 过滤流:在节点流的基础之上增强功能。
三、字节流
字节流的父类
文件字节流
- FileInputStream:
- public int read(byte[] b):从流中读取多个字节,将读到的内容存入b数组,返回实际读到的字节数;如果达到文件的尾部,则返回-1。
- FileOutputStream:
- public void write(byte[] b):一次写多个字节,将b数组中所有字节,写入输入流。
FileInputStream的使用-代码实现:
package JavaTest;
/**
* FileInputStream的使用
* 文件字节输入流
*/
import java.io.FileInputStream;
public class Demo {
public static void main(String[] args) throws Exception{
//1 创建FileInputStream,并指定文件路径
FileInputStream fis=new FileInputStream("E:\\aaa.txt");
//2 读取文件
// fis.read();
//2.1 单个字节读取
// int data=0;
// while ((data=fis.read())!=-1){//如果达到文件的尾部,则返回-1。
// System.out.print((char)data);//返回值为int类型,所以强制类型转换一下
// }
//2.2 一次读取多个字节
//用循环来读取文件内容
byte[] buf=new byte[3];//3:缓冲区大小,即一下最多可以读取的数量
int count=0;
while ((count=fis.read(buf))!=-1){
System.out.println(new String(buf,0,count));
}
// abc
// def
// g
// 分开读取,一次3个直至读完
// byte[] buf=new byte[3];
// int count1=fis.read(buf);
// System.out.println(new String(buf));//String():java.lang下的
// System.out.println(count1);//count1:实际读取的字节个数
//
// int count2=fis.read(buf);
// System.out.println(new String(buf));
// System.out.println(count2);
//
// int count3=fis.read(buf);
//gef,读取了一个g。gef:可以认为覆盖赋值,由于count2数组没有清空,读的一个g只覆盖了第一个
System.out.println(new String(buf));
// //解决:
// //buf:目标数组的值 0:从length=0开始读取 count:到count(本文=3)的时候停止读取
// System.out.println(new String(buf,0,count3));//g
// System.out.println(count3);
//3 关闭
fis.close();
System.out.println();
System.out.println("执行完毕");
}
}
FileOutputStream的使用-代码实现:
package JavaTest;
import java.io.FileOutputStream;
/**
* FileOutputStream的使用
* 文件字节输出流
*/
public class Demo {
public static void main(String[] args) throws Exception{
//1 创建文件字节输出流对象
//加过true后,再写入内容就不会覆盖原有内容了,而是接着原有内容写
FileOutputStream fos=new FileOutputStream("E:\\aaa.txt",true);
//2 写入文件
// fos.write(97);
// fos.write('b');
// fos.write('c');//输出abc,写入成功,但是覆盖了原有内容
String string="HA";
//加过true:helloworldhelloworldHA
fos.write(string.getBytes());//输出helloworld,写入成功,但是覆盖了原有内容
//3 关闭
fos.close();
System.out.println("执行完毕");//
}
}
案例:复制aaa.txt,并改名为bbb.txt
package JavaTest;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class Demo {
public static void main(String[] args) throws Exception{
//1 创建流
//1.1 文件字节输出流
FileInputStream fis=new FileInputStream("E:\\aaa.txt");//这个文件是存在的
//2.2 文件字节输出流
FileOutputStream fos=new FileOutputStream("E:\\bbb.txt");//这个文件是不存在的
//2 一边读,一边写
byte[] buf=new byte[1024];
int count=0;
while ((count=fis.read(buf))!=-1){//只要不等于-1,就说明没有读取完
fos.write(buf,0,count);
}
//3 关闭
fis.close();
fos.close();
System.out.println("复制完毕");
}
}
字节缓冲流
- 缓冲流:BufferedInputStream/BufferedOutputStream
- 提高IO效率,减少访问磁盘的次数;
- 数据存储在缓存区中,flush是将缓存区中的内容写入文件中,也可以直接close。
BufferedInputStream的使用-代码实现:
package JavaTest;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
/**
* 使用字节缓冲流读取
* BufferedInputStream
* 自带缓冲区
*/
public class Demo {
public static void main(String[] args) throws Exception{
//1 创建BufferedInputStream
FileInputStream fis=new FileInputStream("E:\\aaa.txt");//从硬盘中读取数据
//目的:为了增强FileInputStream的功能
BufferedInputStream bis=new BufferedInputStream(fis);//内置有缓存区
//2 读取
int data=0;
//在调用read之前,已经有一部分的数据已经存入bis的缓存区(默认大小:8k)了,下次再读取的时候
//缓存区里面已经有了,就不用再去硬盘中读取了
// while ((data=bis.read())!=-1){
// System.out.print((char)data);
// }
//自己创建一个缓存区
byte[] buf=new byte[1024];
int count=0;
while ((count=bis.read(buf))!=-1){
System.out.println(new String(buf,0,count));
}
//3 关闭
bis.close();
}
}
BufferedOutputStream的使用-代码实现:
package JavaTest;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
/**
* 使用字节缓冲流写入文件
* BufferedOutputStream
*/
public class Demo {
public static void main(String[] args) throws Exception{
//1 创建字节输出缓存流
FileOutputStream fos=new FileOutputStream("E:\\aaabuffer.txt");
BufferedOutputStream bos=new BufferedOutputStream(fos);
//2 写入文件
for (int i=0;i<10;i++){
bos.write("hello\r\n".getBytes());//先写入缓存区,\r\n:换行,默认大小;8k
bos.flush();//写一次,刷新一次到硬盘
}
//3 关闭(内部调用flush方法)
bos.close();//不用flush的话,在循环外关闭,内容一次性写入文件
}
}
对象流
- 对象流:ObjectOutputStream/ObjectInputStream
- 增强缓冲区功能
- 增强了读写8种基本数据类型和字符串功能
- 增强了读写对象的功能:
- readObject():从流中读取一个对象
- writeObject(Object obj):向流中写入一个对象
- 使用流传输对象的过程称为序列化、反序列化。(从内存中的对象写入文件中的过程称之为序列化,反之为反序列化)
序列化-代码实现:
package JavaTest;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
/**
* 使用ObjectOutputStream实现对象的序列化:写入操作
* 要求:
* 1. 序列化的类,必须要是实现Serializable接口(标记性接口,里面没有什么方法)。
* 2. 序列化类中对象属性,也要求实现Serializable接口。
* 3. serialVersionUID,序列化版本号ID,保证序列化的类和反序列化的类是同一个类。
* 4. 使用transient(瞬间的、瞬时的)修饰属性,这个属性就不能序列化了(不能保存了)。
* 5. 静态属性不能被序列化的。
* 6. 序列化多个对象,可以借助集合来实现
*/
public class Demo {
public static void main(String[] args) throws Exception{
//1 创建对象流,使用对象流之前必须要有一个节点流/底层流
FileOutputStream fos=new FileOutputStream("E:\\aaastu.bin");//节点流/底层流
ObjectOutputStream oos=new ObjectOutputStream(fos);
//2 序列话(写入操作)
Demo2 zhangsan=new Demo2("张三",20);
//Demo2 lisi=new Demo2("李四",22);序列化多个对象:一个一个序列化
//ArraysList<Demo2> list=new ArraysList<>();序列化多个对象:创建一个数组/集合来存储需要序列化的对象
oos.writeObject(zhangsan);
//oos.writeObject(lisi);
//oos.writeObject(list);序列化一个数组/集合
//3 关闭
oos.close();
System.out.println("序列化完毕");
}
}
反序列化-代码实现:
EOFException:点此进入
这个异常不是必须声明的,也就是说它虽然是异常,但其实是正常运行结束的标志。
EOF表示读到了文件尾 ( String str = dis.readUTF(); ,客户端已经断开,后面已经没有内容可以读了),发送结束自然连接也就断开了。
package JavaTest;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
/**
* 使用ObjectInputStream实现对象的反序列化:读取重构对象
*
*/
public class Demo {
public static void main(String[] args) throws Exception{
//1 创建对象流,使用对象流之前必须要有一个节点流/底层流
FileInputStream fis=new FileInputStream("E:\\aaastu.bin");
ObjectInputStream ois=new ObjectInputStream(fis);
//2 读取文件(反序列化)
Demo2 s=(Demo2)ois.readObject();
// Demo2 s2=(Demo2)ois.readObject();//EOFException:详细看上文连接,要想不报错,就再序列化一个
//ArrayList<Demo2> list=(ArrayList<Demo2>)ois.readObject();
//3 关闭
ois.close();
System.out.println("反序列化完毕");
System.out.println(s.toString());
// 反序列化完毕
// Demo2{name='张三', age=20}
}
}
序列化、反序列化都用到的Dome2类:
package JavaTest;
import java.io.Serializable;
/***
* Student类
*/
public class Demo2 implements Serializable {
// private static final long serialVersionUID = 100L;序列号的ID改为100了,就不能反序列化了,与序列化时默认生成的ID不同,系统认定为不是同一个类。解决:1.把100改成和默认生成的ID相同的。2.在ID=100的基础上再序列化一遍,之后再反序列化。
private String name;
// private transient int age;
private int age;
//public static String country="中国";静态属性:也是不能被序列化的,不能被存到硬盘中的
public Demo2(String name, int age) {
this.name = name;
this.age = age;
}
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;
}
@Override
public String toString() {
return "Demo2{" +
"name='" + name + '\'' + ", age=" + age + '}';
}
}
四、编码方式
字符编码
- ISO-8859-1 收录除ASCII外,还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。
- UTF-8 针对Unicode码表的可变长度字符编码
- GB2312 简体中文
- GBK 简体中文、扩充
- BIG5 台湾 繁体中文
- 当编码方式和解码方式不一致时,会出现乱码。
五、字符流
小案例:使用字节流读取汉字
package JavaTest;
import java.io.FileInputStream;
public class Demo {
public static void main(String[] args) throws Exception{
//1 创建FileInputStream对象
FileInputStream fis=new FileInputStream("E:\\aaa.txt");//内容:哈喽哈喽
//2 使用字节流读取
int data=0;
while ((data=fis.read())!=-1){
//文本内容,UTF-8形式存储,12个字节4个汉字,而它在读取的时候是一个字节一个字节的读取的,是把汉字拆开读取的,
// 把一个字节换成一个字符,汉字是一个字符三个字节,拆开后肯定不能转换成汉字,所以乱码
System.out.print((char) data);//哈喽哈喽
}
//3 关闭
fis.close();
}
}
字符流的父类(抽象类)
文件字符流
- FileReader:
public int read(char[] c):从流中读取多个字符,将读到内容存入c数组,返回实际读到的字符数;如果达到文件的尾部,则返回-1。 - FileWriter:
public void write(String str):一次写多个字符,将b数组中所有字符,写入输出流。
使用FileReader读取文件-代码实现:
package JavaTest;
import java.io.FileReader;
/**
* 使用FileReader读取文件
*/
public class Demo {
public static void main(String[] args) throws Exception{
//1 创建FileReader 文件字符输入流
FileReader fr=new FileReader("E:\\aaa.txt");
//2 读取
//2.1 单个读取
// int data=0;
// while ((data=fr.read())!=-1){//读取一个字符:一次读三个字节,一共读四次
// System.out.print((char) data);//哈喽哈喽
// }
//2.2 创建一个缓存区读取,中英文都可以读取
// char[] buf=new char[1024];//哈喽哈喽
char[] buf=new char[2];
// 哈喽
// 哈喽
int count=0;
while ((count=fr.read(buf))!=-1){
System.out.println(new String(buf,0,count));
}
//3 关闭
fr.close();
}
}
使用FileWriter写入文件-代码实现:
package JavaTest;
import java.io.FileWriter;
/**
* 使用FileWriter写入文件
*/
public class Demo {
public static void main(String[] args) throws Exception{
//1 创建FileWriter对象
FileWriter fw=new FileWriter("E:\\aaafilewriter.txt");
//2 写入
for (int i = 0; i < 10; i++) {
fw.write("java是世界上最好的语言\n");
fw.flush();
}
//3 关闭
System.out.println("执行完毕");
}
}
字符流:只能复制文本文件,不能复制图片或二进制文件(即可运行的文件)(复制过来的打不开)。
字节流:可以复制任意文件。
案例:使用FileReader和FileWriter复制文本文件。
package JavaTest;
import java.io.FileReader;
import java.io.FileWriter;
/**
* 复制文件
*/
public class Demo {
public static void main(String[] args) throws Exception{
//1 创建FileWriter、FileReader对象
FileReader fr=new FileReader("E:\\aaafilewriter.txt");
FileWriter fw=new FileWriter("E:\\aaafilewriter2.txt");
//2 写入
int data=0;
while ((data=fr.read())!=-1){
fw.write(data);
fw.flush();
}
//3 关闭
fr.close();
fw.close();
System.out.println("复制完毕");
}
}
字符缓冲流
- 缓冲流:BufferedReader/BufferedWriter
- 高效读写。
- 支持输入换行符。
- 可一次写一行、读一行。
BufferedReader读取文件-代码实现:
package JavaTest;
import java.io.BufferedReader;
import java.io.FileReader;
/**
* 使用字符缓冲流读取文件
* BufferedReader
*/
public class Demo {
public static void main(String[] args) throws Exception{
//1 创建缓冲流
FileReader fr=new FileReader("E:\\aaafilewriter.txt");
BufferedReader br=new BufferedReader(fr);
//2 读取
//2.1 第一种方式:创建缓存区
// char[] buf=new char[1024];
// int count=0;
// while ((count=br.read())!=-1){
// System.out.print((char) count);
// }
//2.2 第二种方式,一行一行的读取
String line=null;
while ((line=br.readLine())!=null){//不等于空,说明没有读取完
System.out.println(line);
}
//3 关闭
br.close();
}
}
BufferedWriter的使用-代码实现:
package JavaTest;
import java.io.BufferedWriter;
import java.io.FileWriter;
/**
* BufferedWriter的使用
*/
public class Demo {
public static void main(String[] args) throws Exception{
//1 创建BufferedWriter对象
FileWriter fw=new FileWriter("E:\\aaabuffer.txt");
BufferedWriter bw=new BufferedWriter(fw);
//2 写入
for (int i = 0; i <10 ; i++) {
bw.write("BufferedWriter的使用");
bw.newLine();//写入一个换行符。windows:\r\n,Linxu:\n
bw.flush();
}
//3 关闭
bw.close();
System.out.println("执行完毕");
}
}
打印流
- PrintWrite:
- 封装了print()/println()方法,支持写入后换行。
- 支持数据原样打印。
PrintWriter的使用-代码实现:
package JavaTest;
import java.io.PrintWriter;
/**
* PrintWriter的使用
*/
public class Demo {
public static void main(String[] args) throws Exception{
//1 创建打印流
PrintWriter pw=new PrintWriter("E:\\aaaprint.txt");
//2 打印
pw.println(97);
pw.println('a');
pw.println(true);
pw.println(3.1415926);
//3 关闭
pw.close();
System.out.println("执行完毕");
}
}
转换流
- 桥转换流:InputStreamReader/OutputStreamWriter
- 可将字节流转换为字符流。
- 可设置字符的编码方式。
使用InputStreamReader读取文件-代码实现:
package JavaTest;
import java.io.FileInputStream;
import java.io.InputStreamReader;
/**
* 使用InputStreamReader读取文件,可以指定使用的编码
*/
public class Demo {
public static void main(String[] args) throws Exception{
//1 创建InputStreamReader对象
FileInputStream fis=new FileInputStream("E:\\aaafilewriter.txt");
InputStreamReader isr=new InputStreamReader(fis,"utf-8");//文件编码ANSI对应gbk编码
//2 读取文件
int data=0;
while ((data=isr.read())!=-1){
System.out.print((char) data);
}
//3 关闭
isr.close();
}
}
使用OutputStreamWriter写入文件-代码实现:
package JavaTest;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
/**
* 使用OutputStreamWriter写入文件,可以指定使用的编码
*/
public class Demo {
public static void main(String[] args) throws Exception{
//1 创建OutputStreamWriter
FileOutputStream fos=new FileOutputStream("E:\\aaainfo.txt");
OutputStreamWriter osw=new OutputStreamWriter(fos,"utf-8");
//2 写入
for (int i = 0; i < 10; i++) {
osw.write("使用OutputStreamWriter写入文件");
osw.flush();
}
//3 关闭
osw.close();
System.out.println("执行完毕");
}
}
六、File类
- 概念:代表物理盘符中的一个文件或者文件夹。
- 方法:
文件操作-代码实现:
package JavaTest;
import java.io.File;
import java.util.Date;
/**
* File类的使用
* (1)分隔符
* (2)文件操作
* (3)文件夹操作
*/
public class Demo {
public static void main(String[] args) throws Exception{
// separator();
fileOpe();
}
//1 分隔符
public static void separator(){
System.out.println("路径分隔符"+File.pathSeparator);
System.out.println("名称分隔符"+File.separator);
}
//2 文件操作
public static void fileOpe() throws Exception{
//创建文件
File file=new File("E:\\aaafile.txt");//创建了文件对象,不写盘符,则创建到项目路径下
// System.out.println(file.toString());打印文件路径
if (!file.exists()){//文件存在返回true,文件不存在时,创建文件
boolean b=file.createNewFile();//创建文件,抛出异常、接收异常
System.out.println("创建结果:"+b);//true,再次运行:false
}
//删除文件
//1.直接删除
// System.out.println("删除结果:"+file.delete());//删除结果:true
//2.使用jvm退出时删除
// file.deleteOnExit();
// Thread.sleep(5000);//休眠5s
//获取文件信息
System.out.println("获取文件的绝对路径:"+file.getAbsolutePath());
System.out.println("获取路径:"+file.getPath());
System.out.println("获取文件名称:"+file.getName());
System.out.println("获取父目录:"+file.getParent());
System.out.println("获取文件长度:"+file.length());
System.out.println("获取文件的最后修改时间:"+new Date(file.lastModified()).toLocaleString());
//判断
System.out.println("是否可写:"+file.canWrite());
System.out.println("是否是文件:"+file.isFile());
System.out.println("是否隐藏:"+file.isHidden());
// 获取文件的绝对路径:E:\aaafile.txt
// 获取路径:E:\aaafile.txt
// 获取文件名称:aaafile.txt
// 获取父目录:E:\
// 获取文件长度:11
// 获取文件的最后修改时间:2022-11-14 18:04:37
// 是否可写:true
// 是否是文件:true
// 是否隐藏:false
}
}
文件夹操作-代码实现:
package JavaTest;
import java.io.File;
import java.util.Date;
/**
* File类的使用
* (1)分隔符
* (2)文件操作
* (3)文件夹操作
*/
public class Demo {
public static void main(String[] args) throws Exception{
directoryOpe();
}
//3 文件夹操作
public static void directoryOpe() throws Exception{
//创建文件夹
File dir=new File("E:\\aaa\\bbb\\ccc");
System.out.println(dir.toString());
if (!dir.exists()){
// dir.mkdir();//只能创建单级目录
System.out.println("创建结果:"+dir.mkdirs());//创建多级目录
}
//删除文件夹
//1.直接删除(只能删除空目录)
// System.out.println("删除结果:"+dir.delete());
//2.使用jvm删除
// dir.deleteOnExit();//只删除实例化时输入路径的最后一级文件夹
// Thread.sleep(5000);
//获取文件夹信息
System.out.println("获取绝对路径:"+dir.getAbsolutePath());
System.out.println("获取路径:"+dir.getPath());
System.out.println("获取文件夹名称:"+dir.getName());
System.out.println("获取父目录:"+dir.getParent());
System.out.println("获取创建时间:"+new Date(dir.lastModified()).toLocaleString());
//判断
System.out.println("是否是文件夹:"+dir.isDirectory());
System.out.println("是否是隐藏:"+dir.isHidden());
//遍历文件夹
File dir2=new File("E:\\aaa\\bbb\\ccc");
File[] files=dir2.listFiles();//返回file数组
System.out.println("----------------");
for (File file:files){
System.out.println(file);//输出文件绝对路径
}
String[] strings=dir2.list();//返回字符串数组
System.out.println("================");
for (String string:strings){
System.out.println(string);//返回文件名
}
}
}
FileFilter接口(文件过滤器接口)
- public interface FileFilter
- boolean accept(File pathname)
- 当调用File类中的listFiles()方法时,支持传入FileFilter接口 接口实现类,对获取文件进行过滤,只有满足条件的文件的才可出现在listFiles()的返回值中。
FileFilter接口的使用-代码实现:
package JavaTest;
import java.io.File;
import java.io.FileFilter;
public class Demo {
public static void main(String[] args) throws Exception{
directoryOpe();
}
public static void directoryOpe() throws Exception{
//创建文件夹
File dir=new File("E:\\aaa\\bbb\\ccc");
System.out.println(dir.toString());
if (!dir.exists()){
System.out.println("创建结果:"+dir.mkdirs());//创建多级目录
}
//对文件夹内容进行过滤
File dir2=new File("E:\\aaa\\bbb\\ccc");
System.out.println("---------FileFilter接口的使用---------");
File[] files1=dir2.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
if (pathname.getName().endsWith(".bin")){//endsWith:后缀
return true;//true:满足要求返回
}return false;
}
});
for (File file:files1){
System.out.println(file.getName());
}
}
}
输出:
E:\aaa\bbb\ccc
---------FileFilter接口的使用---------
aaastu.bin
案例:递归遍历文件夹和递归删除文件夹
package JavaTest;
import java.io.File;
/**
* 案例一:递归遍历文件夹
* 案例二:递归删除文件夹
*/
public class Demo {
public static void main(String[] args){
// listDir(new File("E:\\aaa"));
deleteDir(new File("E:\\aaa"));
}
// 案例一:递归遍历文件夹
public static void listDir(File dir){
File[] files=dir.listFiles();//得到这个文件夹里面的所有文件
System.out.println(dir.getAbsolutePath());
if (files!=null&&files.length>0){
for (File file:files){//for (数据类型 用来接收遍历后的变量名:目标数组)
if (file.isDirectory()){
listDir(file);//递归:file是文件夹,则从头开始继续判断是否为空。。直至不是文件夹
}
else {
System.out.println(file.getAbsolutePath());//File不是文件夹,则输出内含文件的绝对地址
}
// E:\aaa
// E:\aaa\bbb
// E:\aaa\bbb\ccc
// E:\aaa\bbb\ccc\aaa.txt
// E:\aaa\bbb\ccc\aaabuffer.txt
// E:\aaa\bbb\ccc\aaafile.txt
// E:\aaa\bbb\ccc\aaafilewriter.txt
// E:\aaa\bbb2
// E:\aaa\bbb2\aaafilewriter2.txt
// E:\aaa\bbb2\aaainfo.txt
// E:\aaa\bbb2\aaaprint.txt
// E:\aaa\bbb2\aaastu.bin
// E:\aaa\bbb2\bbb.txt
}
}
}
// 案例二:递归删除文件夹
public static void deleteDir(File dir){
File[] files=dir.listFiles();
if (files!=null&&files.length>0){
for (File file:files){
if (file.isDirectory()){
deleteDir(file);//递归
}
else {
//删除文件
System.out.println(file.getAbsolutePath()+"删除:"+file.delete());
}
}
}
//删除文件夹
System.out.println(dir.getAbsolutePath()+"删除:"+dir.delete());
System.out.println("删除完毕");
// E:\aaa\bbb\ccc删除:true
// 删除完毕
// E:\aaa\bbb删除:true
// 删除完毕
// E:\aaa\bbb2删除:true
// 删除完毕
// E:\aaa删除:true
// 删除完毕
}
}
补充:Properties集合
- Properties:属性集合。继承HashTable
- 特点:
- 存储属性名和属性值。
- 属性名和属性值都是字符串类型。
- 没有泛型。
- 和流有关。
Properties集合的使用-代码实现
package JavaTest;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.Set;
/**
* Properties集合的使用
*/
public class Demo {
public static void main(String[] args) throws Exception{
//1 创建集合
Properties properties=new Properties();
//2 添加元素
properties.setProperty("name","zhangsan");
properties.setProperty("age","20");
System.out.println(properties.toString());
//3 遍历
//3.1 keySet
//3.2 entrySet
//3.3 stringPropertyNames()
Set<String> pronames=properties.stringPropertyNames();
for (String string:pronames){
//{age=20, name=zhangsan}
//age---20
//name---zhangsan
System.out.println(string+"---"+properties.getProperty(string));
}
//4 和流有关的方法
//------------list方法-------------
// PrintWriter pw=new PrintWriter("E:\\print.txt");
// properties.list(pw);
// pw.close();
//------------store方法-保存--------
// FileOutputStream fos=new FileOutputStream("E:\\aaastore.properties");//该文件不允许出现中文
// properties.store(fos,"注释");
// fos.close();
//------------load方法-加载---------
Properties properties1=new Properties();
FileInputStream fis=new FileInputStream("E:\\\\aaastore.properties");
properties1.load(fis);
fis.close();
System.out.println(properties1.toString());
//{age=20, name=zhangsan}
//age---20
//name---zhangsan
//{age=20, name=zhangsan}
}
}
总结
- 流的概念:
- 内存与存储设备之间传输数据的通道。
- 流的分类:
- 按流向:输入流、输出流;按处理单位:字节流、字符流;按功能:节点流、过滤流;
- 序列化、反序列化:
- 将对象通过流写入到文件,或将对象通过流读取到内存,必须实现Serializable接口。
- File对象:
- 代表物理盘符中的一个文件或者文件夹。