2021.2.10 Java IO流
Java IO框架
一.流
1.基础概念
内存与存储设备之间传输数据的通道
数据借助流 传输
二.流的分类
1.按方向分类
输入流：将<存储设备>中的内容读入到<内存>中
输出流：将<内存>中的内容写入到<存储设备>中
文件------(输入流)------->程序------(输出流)------->文件
2.按单位分类
字节流：以字节为单位，可以读写所有数据
字符流：以字符为单位，只能读写文本数据
3.按功能分类
节点流：具有实际传输数据的读写功能---------->（如：底层流）
过滤流：在节点流的基础之上增强功能---------->（如：缓冲流）
三.字节流
-
字节流的父类（抽象类）
-
因为父类是抽象类，所以实现时，需要通过其子类
1.字节输入流：InputStream（父类）
此抽象类是表示输入字节流的所有类的超类
- 1）其子类：文件字节输入流：FileInputStream
//FileInputStream文件字节输入流的使用
public class demo01 {
//由于可能出现找不到该路径下面的文件，所以需要抛出这个异常
public static void main(String[] args) throws Exception {
//1.创建FileInputStream文件字节输入流，并指定文件路径
FileInputStream fis=new FileInputStream("D:\\test01.txt");
//2.读取文件read()
/*System.out.println("一个字节读：");
//fis.read();----->返回的是int类型的数据
int date=0;
while( (date=fis.read())!=-1){
System.out.print((char)date);
}
System.out.println();*/
System.out.println("一次性读多个字节：");
byte buf[]=new byte[5];//创建一个缓冲区
int count=0;
while((count =fis.read(buf))!=-1){
//read(byte[] buf)从流中读取多个字节，存放人buf数组
// --->返回实际读到的字节数，如果达到尾部则返回-1
System.out.println(new String(buf,0,count));
}
//3.关闭
fis.close();
System.out.println("读取完毕！！！");
}
}
/*
结果：将D:\\test01.txt文件中的数据，存到缓冲区buf[]，然后在程序中打印出来。（读取文件）
*/
- 2）字节缓冲输入流BufferedInputStream
- 是对 节点流或底层流的增强
//字节缓冲输入流BufferedInputStream的使用---读文件
public class demo04 {
public static void main(String[] args) throws Exception {
//1.创建流
FileInputStream fis=new FileInputStream("D:\\test01.txt");
BufferedInputStream bis=new BufferedInputStream(fis);
//是对上面的底层流/节点流的增强
//2.进行读操作
int date=0;
while((date=bis.read())!=-1){
System.out.print((char)date);
}
//字节缓冲输入流BufferedInputStream自己有一个缓冲数组可以读入数据
//相对于利用文件输入缓冲流FileInputStream效率要高很多
//3.关闭
bis.close();//关闭字节缓冲输入流，里面自动关闭字节输入流
}
}
/*
结果：读取D:\\test01.txt文件中的数据，然后在程序中打印出来。
*/
2.字节输出流：OutputStream（父类）
此抽象类是表示输出字节流的- 所有类的超类。输出流接受输出字节并将这些字节发送到某个接收器。
- 1）其子类：文件字节输出流FileOutStream
//文件字节输出流FileOutStream的使用
public class demo02 {
//由于可能出现找不到该路径下面的文件，所以需要抛出这个异常
public static void main(String[] args) throws Exception{
//1.创建文件字节输出流FileOutStream对象，并指定文件路径
// FileOutputStream fos=new FileOutputStream("D:\\test02.txt");
//这种构造方法，当每次执行程序时，都会像文件中写入数据，将前面的覆盖
FileOutputStream fos=new FileOutputStream("D:\\test02.txt",true);
//---可以不会覆盖，继续写入数据
//2.写入文件
fos.write(97);
fos.write(98);
fos.write(99);//这里的99是int类型，写入文件后转换为它Ascll码所对应的字符
fos.write('d');//char型数据可以自己转换为int型
fos.write('e');//
String s="fghijkl";
fos.write(s.getBytes());//写入文件中的是数组，String是类，要转换先
//3.关闭
fos.close();
System.out.println("执行完毕");
}
}
/*
结果：在D盘中创建了一个test02.txt文件，并写入写入字符abcdefghijkl，再执行一次，就再写入一次。
*/
2）字节缓冲输出流：BufferedOutputStream
//字节缓冲（输出）流BufferedOutputStream的使用---写入文件
public class demo05 {
public static void main(String[] args) throws Exception {
//1.创建流
FileOutputStream fos=new FileOutputStream("D:\\test03.txt");
BufferedOutputStream bos=new BufferedOutputStream(fos);
//是对上面的底层流/节点流的增强
//2.进行写操作
for(int i=0;i<9;i++){
bos.write(new String("heeeheeheh!\n").getBytes());
//写入了字节缓冲（输出）流BufferedOutputStream的缓冲区
bos.flush();//刷新到硬盘，否则没有写入到文件中
}
//相对于利用文件输入缓冲流FileOutputStream效率要高很多
//3.关闭（内部调用课flush方法）
bos.close();//关闭字节缓冲输出流，里面自动关闭字节输出流
}
}
/*
结果：在D盘中创建了一个test03.txt文件，并写入字符heeeheeheh!十次，每写一次换一行
*/
3.字节输入输出流的综合使用
- 1）使用文件字节流进行文件的复制
//使用文件字节流进行文件的复制
public class demo03 {
public static void main(String[] args) throws Exception{
//1.创建流
//1.1创建字节输入流
FileInputStream fis=new FileInputStream("D:\\1.jpg");
//1.2创建字节输出流
FileOutputStream fos=new FileOutputStream("D:\\2.jpg");
//2.边读边写
byte[] buf=new byte[1024];
int count=0;
while ((count=fis.read(buf))!=-1){
fos.write(buf,0,count);
}
//3.关闭
fis.close();
fos.close();
System.out.println("复制完成");
}
}
/*
结果：在D盘中复制了一个和1.jpg一样的图片2.jpg
*/
4.对象流ObjectInputStream/ObjectOutputStream
-
对象流ObjectInputStream/ObjectOutputStream也是InputStream/OutputStream的子类
-
增强缓冲区功能
-
增强了读写8种基本数据类型和字符串功能
-
增强了读写对象的功能
-
readObject()--------从流中读取一个对象（从流中读取一个对象，也就是从文件中读取一个对象，称为反序列化）
writeObject()------- --向流中写入一个对象（将内存中的对象写入流中，也就是写入文件中，称为序列化）
- 使用流传输对象的过程称为序列化、反序列化
public class demo07 {
//使用ObjectInputStream实现对象的反序列化
public static void main(String[] args)throws Exception {
//1.创建对象流
FileInputStream fis=new FileInputStream("D:\\test04.txt");
ObjectInputStream ois=new ObjectInputStream(fis);
//2.创建对象并读对象（反序列化）
Object s2=ois.readObject();//读的对象类型是Object类型
//对象被读一次就没有了，不能再进行反序列化读操作
//Object s2=ois.readObject();//读的对象类型是Object类型
//3.关闭
ois.close();
System.out.println("反序列化完毕");
System.out.println(s2);
}
}
/*结果：
程序中（内存中）打印：
反序列化完毕
Student{name='lyj', age=20}
（将test04.txt文件中的对象读入程序（内存）中）
*/
//使用ObjectOutputStream实现对象的序列化
//要求：序列化的类必须要实现Serializable接口
public class demo06 {
public static void main(String[] args)throws Exception {
//1.创建对象流
FileOutputStream fos=new FileOutputStream("D:\\test04.txt");
ObjectOutputStream oos=new ObjectOutputStream(fos);
//2.创建对象并写入对象（序列化）
Student s1=new Student("lyj",20);
System.out.println(s1);
oos.writeObject(s1);
//3.关闭
oos.close();
System.out.println("序列化完毕");
//4.对于要写入的对象的那个类---序列化，需要实现一个接口Serializable
}
}
/*结果：
在（存储设备）D盘中创建出一个文件test04.txt，并将创建的对象s1写入该文件中
在程序中（内存中）打印序列化完毕
*/
public class Student implements Serializable {
//实现这个Serializable接口，标志着这个类可以序列化
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
-
对象流需要注意的事项：
-
- 1）序列化类必须要实现Serializable接口
- 2）序列化类中的对象属性要求也要实现Serializable接口（比如：如果序列化类Student中 的某一属性的类型 是自己创建的新类Teacher ，要想实现序列化，这个新类也需要实现Serializable接口）
- 3）可以利用序列化版本号ID，保证序列化的类和反序列化的类是同一类
一般先执行序列化的程序，再执行反序列化的程序，这个版本号就可以一致了
- 4）对于不想序列化的属性可以使用transient（瞬间的）修饰属性
- 5）静态属性不能序列化
- 6）序列化多个对象可以借助集合来实现
//使用ObjectOutputStream实现对象的序列化（加强）
public class demo08 {
public static void main(String[] args)throws Exception {
//1.创建对象流
FileOutputStream fos=new FileOutputStream("D:\\test05.txt");
ObjectOutputStream oos=new ObjectOutputStream(fos);
//2.创建多个对象并利用集合，写入对象（序列化）
//不用集合的话就要写多遍writeObject()
Teacher t1=new Teacher("aaa",36,1001);
System.out.println(t1);
Teacher t2=new Teacher("bbb",43,1002);
System.out.println(t2);
ArrayList<Teacher> list=new ArrayList<>();
list.add(t1);
list.add(t2);
for(Teacher teacher:list){
System.out.println(teacher.toString());
}
//由于id是静态变量，所以它的值只有一个，会被后面的取代
oos.writeObject(list);
//3.关闭
oos.close();
System.out.println("序列化完毕");
//4.对于要写入的对象的那个类---序列化，需要实现一个接口Serializable
}
}
/*结果：
在内存中（程序中）打印出：
Teacher{name=aaa, age=36, id=1001}
Teacher{name=bbb, age=43, id=1002}
Teacher{name=aaa, age=36, id=1002}
Teacher{name=bbb, age=43, id=1002}
序列化完毕
在存储设备（文件）在D盘中创建出一个文件test05.txt，并将创建的对象list写入该文件中
*/
//使用ObjectInputStream实现对象的反序列化（加强）
public class demo09 {
public static void main(String[] args)throws Exception {
//1.创建对象流
FileInputStream fis=new FileInputStream("D:\\test05.txt");
ObjectInputStream ois=new ObjectInputStream(fis);
//2.创建多个对象并利用集合，读取对象（反序列化）
//不用集合的话就要写多遍readObject()
ArrayList<Teacher> t3=(ArrayList<Teacher>) ois.readObject();//读的对象类型是Object类型
//对象被读一次就没有了，不能再进行反序列化读操作
// ArrayList<Teacher> t3=(ArrayList<Teacher>) ois.readObject();//读的对象类型是Object类型
//3.关闭
for(Teacher teacher:t3){
System.out.println(teacher.toString());
}
ois.close();
System.out.println("反序列化完毕");
}
}
/*结果：
在内存中（程序中）打印出：
Teacher{name=aaa, age=0, id=0}
Teacher{name=bbb, age=0, id=0}
反序列化完毕
（将test05.txt文件中的对象读入程序（内存）中）
*/
public class Teacher implements Serializable {
//实现这个Serializable接口，标志着这个类可以序列化
private static final long serialVersionUID=100L;
//serialVersionUID序列化版本号，保证序列化的类和反序列化的类是同一类
private String name;
private transient int age;
private static int id;
//对于不想序列化的属性可以使用transient（瞬间的）修饰属性
//静态属性不能序列化
public Teacher(String name, int age,int id) {
this.name = name;
this.age = age;
Teacher.id=id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public static int getId() {
return id;
}
public static void setId(int id) {
Teacher.id = id;
}
@Override
public String toString() {
return "Teacher{" +
"name=" + name +
", age=" + age +
", id=" +id+
'}';
}
}
四.编码方式
1.字符编码
-
1个字节表示一个字符
-
（又称万国码，国际上使用）1、2、3字节表示一个字符
-
1、2字节表示一个字符
-
1、2字节表示一个字符
-
（没讲）
五.字符流
1.字符流的父类Reader、Writer（抽象类）
2.文件字符输入流FileReader
//文件字符输入流FileReader的使用
public class demo10 {
//由于可能出现找不到该路径下面的文件，所以需要抛出这个异常
public static void main(String[] args) throws Exception {
//1.创建FileReader文件字节输入流，并指定文件路径
FileReader fr = new FileReader("D:\\test11.txt");
//2.读取文件read()
/* System.out.println("一个字符一个字符读：");
//fr.read();----->返回的是一个字符
int date=0;
while( (date=fr.read())!=-1){
System.out.print((char)date);
}*/
System.out.println("一次性读多个字符：");
char buf[] = new char[5];//创建一个缓冲区
int count = 0;
while ((count = fr.read(buf)) != -1) {
//read(char[] c)从流中读取多个字符，将读到内容存放人c数组
// --->返回实际读到的字符数，如果达到尾部则返回-1
System.out.println(new String(buf, 0, count));
}
//3.关闭
fr.close();
}
}
/*结果：从存储设备中（D盘的test11.txt文件）的数据读出（按照字符的形式），打印到内存中（程序中）
*/
3.文件字符输出流FileWriter
//文件字符输出流FileWriter的使用
public class demo11 {
//由于可能出现找不到该路径下面的文件，所以需要抛出这个异常
public static void main(String[] args) throws Exception{
//1.创建文件字符输出流FileOutStream对象，并指定文件路径
FileWriter fw=new FileWriter("D:\\test12.txt");
//这种构造方法，当每次执行程序时，都会像文件中写入数据，将前面的覆盖
// FileWriter fw=new FileWriter("D:\\test12.txt",true);
//---可以不会覆盖，继续写入数据
//2.写入文件write(int n)
fw.write(97);
fw.write(98);
fw.write(99);//这里的99是int类型，写入文件后转换为它Ascll码所对应的字符
fw.write('d');//char型数据可以自己转换为int型，然后根据上面方法执行转换
fw.write('e');//
String s="fghijkl";
char c[]={'m','n','o',97,98,'哈','哈'};
fw.write(s);//写入文件中可以是数组，也可以是String类，与文件输出字节流不同
fw.write(c);
//3.关闭
fw.close();
System.out.println("执行完毕");
}
}
/*结果：
内存（程序）在D盘中创建了一个文件test11.txt，并向存储设备（文件）中写入
abcdefghijklmnoab哈哈
*/
注意：文件输出字符流与文件输入字节流的write方法区别在于：前者的write方法可以写入String字符串类型，也可以写入数组，但是后者只能写入数组
4.字符输入输出流的综合使用
-
1）使用文件字符流进行文件的复制
-
使用FileReader和FileWriter复制文本文件时，不能复制图片或者不能复制二进制文件（因为图片是二进制数据，它是没有字符的，所以当把文件读到 内存程序中 它无法转换为字符数据，也就是没法解析故形成乱码，将其再写入复制文件时，就是乱码了）
-
public class demo12 { public static void main(String[] args)throws Exception { //1.创建文件字符输入流FileReader FileReader fr1=new FileReader("D:\\test12.txt"); //2.创建文件字符输出流FileWriter FileWriter fw1=new FileWriter("D:\\test14.txt"); //3.复制文件---边读边写 int count=0; while((count=fr1.read())!=-1){ fw1.write(count); } //4.关闭 fr1.close(); fw1.close(); System.out.println("复制完成"); } } /* 结果：在D盘中复制了一个和test12.txt数据一样的文件test14.txt */ -
字节流可以复制任何文件
5.字符缓冲流BufferedReader/BufferedWriter
-
分别为Reader的子类和Writer的子类
-
高效读写
-
支持输入换行符
-
可一次写一行、读一行
字符缓冲流的创建都是需要先创建一个底层流
//字符缓冲输入流BufferedReader的使用---读文件
public class demo13 {
public static void main(String[] args) throws Exception {
//1.创建流
FileReader fr=new FileReader("D:\\test01.txt");
BufferedReader br=new BufferedReader(fr);
//是对上面的底层流/节点流的增强
//2.进行读操作---利用自身的缓冲数组
/*int date=0;
while((date=br.read())!=-1){
System.out.print((char)date);
}*/
//字节缓冲输入流BufferedReader自己有一个缓冲数组可以读入数据
//相对于利用文件输入缓冲流FileReader效率要高很多
//3.一行一行读取readLine(String)
String line=null;
while((line=br.readLine())!=null){
System.out.println(line);
}
//readLine()=null代表读到最后
//4.关闭
br.close();//关闭字节缓冲输入流，里面自动关闭字节输入流
}
}
/*
结果：读取D:\\test01.txt文件中的数据，然后在程序中打印出来。
*/
//字符缓冲（输出）流BufferedWriter的使用---写入文件
public class demo14 {
public static void main(String[] args) throws Exception {
//1.创建流
FileWriter fw=new FileWriter("D:\\test15.txt");
BufferedWriter bw=new BufferedWriter(fw);
//是对上面的底层流/节点流的增强
//2.进行写操作
for(int i=0;i<9;i++){
bw.write(new String("加油加油！"));
//写入了字符缓冲（输出）流BufferedReaderd，这里的写入可以是字符串String类型
//也可以转换成数组.toCharArray()
bw.newLine();//打印换行符
//换行操作也可以可以"加油加油！\n"
bw.flush();//如果数据有先写入缓冲区，就需要刷新到硬盘，否则没有写入到文件中
//此处可以不用
}
//相对于利用文件输入缓冲流FileWriter效率要高很多
//3.关闭（内部调用课flush方法）
bw.close();//关闭字节缓冲输出流，里面自动关闭字节输出流
System.out.println("执行完毕");
}
}
/*
结果：在D盘中创建了一个test15.txt文件，并写入字符“加油加油！”十次，每写一次换一行
*/
6.文本输出流PrintWriter
- 是Writer的子类
//PrintWriter的使用
public class demo15 {
public static void main(String[] args) throws Exception {
//1.创建打印流
PrintWriter prw=new PrintWriter("D:\\print.txt");
//2.打印
prw.append('c');//将指定字符打印到此处创建的writer中
prw.append(" heihei\n");//添加指定字符串
prw.println(97);
prw.println("a");
prw.println(3.14);
prw.println('b');
//不像write()方法会将int 类型的数据转变为Asca码表的字符 写入文件中
//打印什么，写入文件的就是什么
//3.关闭
prw.close();
}
}
/*结果：
内存（程序）在D盘中创建了一个文件print.txt，并向存储设备（文件）中写入
c heihei
97
a
3.14
b
*/
7.转换流InputStreamReader/OutputStreamWriter
-
内存中的字符和硬盘中的字节相互转换
-
InputStreamReader可以将字节流转换为字符流（存储文件是二进制的，读入内存程序中，可以将字节流转为字符流）
/使用InputStreamReader读取文件，并使用指定的编码
public class demo16 {
public static void main(String[] args) throws Exception {
//1.创建字节流和字符流
FileInputStream fis=new FileInputStream("D:\\test15.txt");
InputStreamReader isr=new InputStreamReader(fis,"utf-8");
//编码方式---看文件编码方式
//ANSI的编码方式是----“gbk”
//2.读取文件
int date=0;
while((date=isr.read())!=-1){
System.out.println((char)date);
}
//3.关闭
isr.close();
}
}
- OutputStreamWriter可以将字符流转换为字节流（将内存程序中的字符，写入存储文件中，将字符流转为字节流）
//使用OutputStreamWriter写文件，并使用指定的编码
public class demo17 {
public static void main(String[] args) throws Exception {
//1.创建字节流和字符流
FileOutputStream fos=new FileOutputStream("D:\\test16.txt");
OutputStreamWriter osw=new OutputStreamWriter(fos,"utf-8");
//编码方式---看文件你想要的编码方式
//ANSI的编码方式是----“gbk”
//2.写文件
for(int i=0;i<10;i++){
osw.write("fuck冲冲冲冲！\n");
}
//3.关闭
osw.close();
}
}
- 它们都可以设置字符的编码方式
六.File类
1.File类的基本概念和方法
2.File基本方法的使用
/*
* File类的使用
* 1）分隔符
* 2）文件操作
*/
public class Demo01 {
public static void main(String[] args) throws Exception {
//1.分隔符
System.out.println("路径分隔符:"+ File.pathSeparator);
System.out.println("名称分隔符:"+ File.separator);
//2.文件操作
// 1)创建文件
File file=new File("D:\\ajava\\file.txt");
//只是创建了file这个对象，在硬盘里面不一定有
if(!file.exists()) {
//如果文件在硬盘中不存在
boolean b = file.createNewFile();
//在硬盘里创建一个文件，返回内存是boolean类型
System.out.println("创建文件：" + b);
}
// 2.1) 删除文件
//System.out.println("删除文件："+file.delete());
//在硬盘里删除一个文件，返回内存是boolean类型
// 2.2) 使用jvm删除文件
//file.deleteOnExit();
//Thread.sleep(5000);
//程序结束之后才删除
// 3) 获取文件信息
System.out.println("获取文件的绝对路径："+file.getAbsolutePath());
System.out.println("获取文件路径："+file.getPath());
System.out.println("获取父目录："+file.getParent());
System.out.println("获取文件长度："+file.length());
System.out.println("获取文件创建时间"+new Date(file.lastModified()));
// 4)判断文件
System.out.println("是否可写："+file.canWrite());
System.out.println("是否是文件："+file.isFile());
System.out.println("是否隐藏："+file.isHidden());
}
}
/*
路径分隔符:;
名称分隔符:\
创建文件：true
获取文件的绝对路径：D:\ajava\file.txt
获取文件路径：D:\ajava\file.txt
获取父目录：D:\ajava
获取文件长度：0
获取文件创建时间Wed Feb 10 01:55:39 CST 2021
是否可写：true
是否是文件：true
是否隐藏：false
*/
注意：可以通过鼠标右键--->属性改变文件的一些信息
/*
* File类的使用
* 3)文件夹操作
* */
public class Demo02 {
public static void main(String[] args) throws Exception {
//3.文件夹操作
// 1)创建文件夹
File dir=new File("D:\\ajava\\aaa\\bbb");
//只是创建了dir这个对象，在硬盘里面不一定有
if(!dir.exists()) {
//如果文件夹在硬盘中不存在
// boolean b = dir.mkdir();----->只能创建单级目录
boolean b = dir.mkdirs();//----->可以创建多级目录
//在硬盘里创建一个文件夹，返回内存是boolean类型
System.out.println("创建文件夹：" + b);
}
//（只能删除空目录，目录里面没有文件，而且只删除最后一个目录，这里是删除bbb）
// 2.1) 直接删除文件夹
//System.out.println("删除文件："+dir.delete());
//在硬盘里删除一个文件，返回内存是boolean类型
// 2.2) 使用jvm删除文件
//dir.deleteOnExit();
//Thread.sleep(5000);
//程序结束之后才删除
// 3)获取文件夹信息
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());
// 4)判断文件夹
//文件夹没有可不可写的操作，只有文件夹里面的文件能不能写，能不能读
System.out.println("是否是文件："+dir.isFile());
System.out.println("是否是文件夹："+dir.isDirectory());
System.out.println("是否隐藏："+dir.isHidden());
System.out.println("==========================================");
// 5)遍历文件夹
File dir2=new File("D:\\ajava");
String[] files=dir2.list();
for(String s:files){
System.out.println(s);
}
}
}
/*
结果：
获取文件的绝对路径：D:\ajava\aaa\bbb
获取文件路径：D:\ajava\aaa\bbb
获取最底层文件夹名称：bbb
获取最底层文件夹的父目录：D:\ajava\aaa
获取文件创建时间2021-2-10 2:20:33
是否是文件：false
是否是文件夹：true
是否隐藏：false
==========================================
D:\ajava下面的文件有：
1.jpg
2.jpg
aaa
file.txt
print.txt
test01.txt
test02.txt
test03.txt
test04.txt
test05.txt
test11.txt
test12.txt
test13.txt
test14.txt
test15(1).txt
test15.txt
test16.txt
*/
注意：对于文件夹的删除：
只能删除空目录，目录里面没有文件，而且只删除最后一个目录，这里是删除bbb
3.FileFilter接口
- 用在遍历文件夹的时候！！！！！！！
public static void main(String[] args) throws Exception {
System.out.print("使用listFiles()遍历");
System.out.println("D:\\ajava下面的文件有：");
//匿名内部类
File[] files1=dir2.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
if (pathname.getName().endsWith("jpg")) {
return true;
}
return false;
}
//返回文件名后缀为jpg的文件
});
for(File file:files1){
System.out.println(file.getName());
}
}
/*
结果：
使用listFiles()遍历D:\ajava下面的文件有：
1.jpg
2.jpg
*/
4.递归遍历、删除文件夹
//递归遍历、删除文件夹
public class Demo03 {
public static void main(String[] args) {
listDir(new File("D:\\ajava\\adirectory"));
//deleteDir(new File("D:\\ajava\\adirectory"));
//调用文件夹递归遍历方法
}
//案例1----递归遍历文件夹
public static void listDir(File dir){
File[] files=dir.listFiles();
//将该文件夹下面的所有文件放入一个数组
System.out.println(dir.getPath());
if(files!=null&&files.length>0){
for(File file:files){
if(file.isDirectory()){
//若该文件为文件夹，则调用文件夹递归遍历方法
listDir(file);
}
//如果该文件不为文件夹，则将文件打印
else{
System.out.println(file.getPath());
}
}
}
}
//案例2-----递归删除文件夹
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.getPath()+"删除："+file.delete());
}
}
}
//文件夹删除
System.out.println(dir.getPath()+"删除："+dir.delete());
}
}
/*
文件夹递归遍历：
D:\ajava\adirectory
D:\ajava\adirectory\directory1
D:\ajava\adirectory\directory1\file3.txt
D:\ajava\adirectory\directory1\file4.ppt
D:\ajava\adirectory\directory2
D:\ajava\adirectory\directory2\file5.rtf
D:\ajava\adirectory\file1.doc
D:\ajava\adirectory\file2.xls
文件夹递归删除：
D:\ajava\adirectory\directory1\file3.txt删除：true
D:\ajava\adirectory\directory1\file4.ppt删除：true
D:\ajava\adirectory\directory1删除：true
D:\ajava\adirectory\directory2\file5.rtf删除：true
D:\ajava\adirectory\directory2删除：true
D:\ajava\adirectory\file1.doc删除：true
D:\ajava\adirectory\file2.xls删除：true
D:\ajava\adirectory删除：true
*/
补充：Properties属性集合
1.Properties属性集合的特点
- Properties类表示了一个持久的属性集，它可以保存在流中或者从流中加载
2.Properties集合的使用
- 继承了Hashtable<Object,Object>
/*
* Properties集合的使用
* */
public class Demo04 {
public static void main(String[] args) throws Exception{
//1.创建集合
Properties properties=new Properties();
//2.添加数据setProperty(String key,String value)
properties.setProperty("aaa","100");
properties.setProperty("bbb","200");
properties.setProperty("bbb","300");
properties.setProperty("ccc","400");
properties.setProperty("ddd","500");
System.out.println(properties.toString());
//和HashMap添加数据的准则是一样的,只允许有一个key对应一个value
// key相同后面value会替换前面的value
//3.遍历元素
//3.1运用KeySet()方法，得到一个Set集合存储key值
// 通过用get()方法得到该key的value值
//3.2运用entrySet()方法，得到一个Set集合存储key和value值
// 通过getkey()方法是得到key，getvalue()方法是得到value
//3.3运用stringPropertyNames()方法遍历
//得到的和3.1一样也是key值
Set<String> key=properties.stringPropertyNames();
for (String s:key){
System.out.println(s+"="+properties.getProperty(s));
}
//4.和流有关的方法
//4.1 list(PrintStream或PrintWriter)----将属性列表写入到输出流（从内存写数据---->存储文件）
PrintWriter pw=new PrintWriter("D:\\ajava\\writer.txt");
properties.list(pw);
pw.close();
//4.2 store(OutputStream或Writer,String)-----用适合load()方法加载的的格式，将属性列表写入到输出流
FileWriter fw=new FileWriter("D:\\ajava\\store.properties");
properties.store(fw,"write to you");
//----->后面的String可以理解为注释
fw.close();
//4.3 load(InputStream)或Reader)-----读取输入流中的属性列表（读存储文件的数据--->内存）
Properties properties1=new Properties();
FileReader fr=new FileReader("D:\\ajava\\store.properties");
properties1.load(fr);
fr.close();
System.out.println(properties1.toString());
}
}
/*
结果：
{bbb=300, aaa=100, ddd=500, ccc=400}
bbb=300
aaa=100
ddd=500
ccc=400
创建文件D:\\ajava\\writer.txt，并在里面写入属性列表的数据
创建文件D:\\ajava\\store.properties，并在里面写入String（注释的值）和属性列表数据，用适合load()方法加载的的格式
{bbb=300, aaa=100, ddd=500, ccc=400}
*/
