目录
1.流的概念
概念：内存与存储设备之间传输数据的通道
IO流：
- I表示intput，把硬盘文件中的数据读入到内存的过程，称之输入，负责读。
- O表示output，把内存中的数据写出到硬盘文件的过程，称之输出，负责写。
2.流的分类
- 按数据流向[重点]：
- 输入流:将<存储设备>中的内容读入到<内存>中，
- 输出流:将<内存>中的内容写入到<存储设备>中。
- 按单位:
- 字节流:以字节为单位，可以读写所有数据，包括音视频图片等
- 字符流:以字符为单位，只能读写文本数据，java文件，txt文件等
- 按功能:
- 节点流:具有实际传输数据的读写功能。
- 过滤流:在节点流的基础之，上增强功能。
- InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
- OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。
3.字节流
1.字节流的父类
- 字节流的父类(抽象类):
- InputStream: 是所有字节输入流的超类，可以读取任何类型文件
- public int read() {}
- public int read (byte[] b) {}
- public int read(byte[] b, int off, int len) {}
- OutputStream: 是所有字节输出流的超类，可以写入任何类型文件
- public void write(int n) {}
- public void write(byte[] b) {}
- public void write(byte[] b, int off, int len) {}
2.文件字节流
- FileInputStream:文件字节输入流
- public int read() 每次读取一个字节返回，如果达到文件的尾部，返回-1(性能较慢,读取中文字符无法避免乱码问题)
- public int read(byte[] b) //从流中读取多个字节，将读到内容存入b数组，返回实际读到的字节数;如果达到文件的尾部，则返回-1。(性能较快,读取中文字符无法避免乱码问题)
- FileOutputStream: 文件字节输出流
- public void write(inta)
- public void write(byte[] b) //一次写多个字节，将b数组中所有字节，写入输出流。
- 字节流可以复制任何文件
- 读取的默认为Ascall编码
- 写入文件最好用flush()刷新一下
- 写完文件必须close()关闭流(释放资源，在关闭之前会默认调用flush),一旦关闭，就不能再向文件写数据
1.ASCALL码对照表
ASCALL码对照表：
美国信息互换标准代码（ASCⅡ）是基于拉丁字母的一套电脑编码系统。它主要用于显示现代英语和其他西欧语言。它是现今最通用的单字节编码系统。
2.文件字节输入流
package java_se.java_jinjie.IO.demo3.demo1;
import java.io.FileInputStream;
/**
* 演示FileInputStream使用
* 文件字节输入流
*/
public class Demo1 {
public static void main(String[] args) throws Exception {
//1.创建FileInputStream
FileInputStream fis = new FileInputStream("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\ddd.txt");
//2.读取文件
//2.1单个字节读取
// int date=0;
// while ((date=fis.read())!=-1){
// System.out.println((char) date);//默认为ascall编码(ascii码)，转换为字符流(char)
// }
//2.2一次读取多个字节
byte [] buf =new byte[3];
int count=0;
while ((count=fis.read(buf))!=-1){
System.out.println(new String(buf,0,count));
}
//3.关闭
fis.close();
System.out.println("执行完毕");
}
}
3.文件字节输出流
package java_se.java_jinjie.IO.demo3.demo1;
import java.io.FileOutputStream;
//演示FileInputStream使用
//文件字节输出流
public class Demo2 {
public static void main(String[] args) throws Exception {
//1.创建文件字节输出流对象
FileOutputStream fos = new FileOutputStream("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\bbb.txt",true);//append追加，不再为覆盖，而改为添加
//2.写入文件
// fos.write(97);//97对应的ascii码
// fos.write('b');
// fos.write('c');
String str="helloWorld";
fos.write(str.getBytes());
//3.关闭
fos.close();
System.out.println("执行完毕");
}
}
4.文件字节流来实现文件的复制
package java_se.java_jinjie.IO.demo3.demo1;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
//使用文件字节流来实现文件的复制
public class Demo3 {
public static void main(String[] args) throws IOException {
//1.创建流
//1.1文件字节输入流
FileInputStream fis = new FileInputStream("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\001.jpg");
//1.2文件字节输出流
FileOutputStream fos = new FileOutputStream("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\002.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("复制完毕");
}
}
3.字节缓冲流
- 缓冲流: BufferedInputStream/ Buffered0utputStream
- 提高I0效率，减少访问磁盘的次数;
- 数据存储在缓冲区中，flush是将缓存区的内容写入文件中，也可以直接close。
- 字节缓冲流自身有一个缓冲区大小为8192，也可以自己创建
1.BufferedInputStream
package java_se.java_jinjie.IO.demo3.demo1;
//使用字节缓冲流读取数据
//BufferedInputStream
import java.io.BufferedInputStream;
import java.io.FileInputStream;
public class Demo4 {
public static void main(String[] args) throws Exception {
//1.创建BufferedInputStream
FileInputStream fis = new FileInputStream("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\aaa.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
//2.读取
// //BufferedInputStream自身有一个缓冲区为8192
// int date=0;
// while ((date=bis.read())!=-1){
// System.out.print((char)date);
// }
//自己创建缓冲区
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();
}
}
2.Buffered0utputStream
package java_se.java_jinjie.IO.demo3.demo1;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
//使用字节缓冲流写入数据
//BufferedOutputStream
public class Demo5 {
public static void main(String[] args) throws Exception {
//1.创建字节输出缓冲流
FileOutputStream fos = new FileOutputStream("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\buffer.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
//2.写入文件
for (int i = 0; i < 10; i++) {
bos.write("helloWord\r\n".getBytes());//默认有一个8k的缓冲区，如果没有8k的内容就会先写入缓冲区
// bos.flush();//刷新到硬盘，解决写入缓冲区未写入文件
}
//3.关闭 close(内部调用flush方法)
bos.close();
}
}
4.对象流
- 对象流: ObjectOutputStream/0b jectInputStream
- 增强了缓冲区功能
- 增强了读写8种基本数据类型和字符串功能
- 增强了读写对象的功能:
- read0bject()从流中读取一个对象
- write0bject (0bject obj) 向流中写入一个对象
使用流传输对象的过程称为序列化、反序列化。
序列化注意事项：
1.序列化类必须要实现Serializable接口
2.序列化类中对象的属性也要求实现Serializable接口
3.//serialVersionUID 序列化版本号ID:保证序列化的类和反序列化的类是同一个类
4.使用transient(瞬间的)修饰属性，这个属性不能序列化
5.静态属性不能序列化
6.序列化多个独享，可与借助集合实现
1.序列化
package java_se.java_jinjie.IO.demo3.demo1;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
//使用ObjectOutputStream实现对象的序列化
public class Demo6 {
public static void main(String[] args) throws IOException {
//1.创建对象流
FileOutputStream fos=new FileOutputStream("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\stu.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
//2.序列化(写入操作)
Student zhangsan = new Student("张三", 3);
Student lisi = new Student("李四", 4);
//第一种一个一个添加
// oos.writeObject(zhangsan);
// oos.writeObject(lisi);
//第二种用集合添加
ArrayList<Student> list = new ArrayList<>();
list.add(zhangsan);
list.add(lisi);
oos.writeObject(list);
//3.关闭
oos.close();
System.out.println("序列化完毕");
}
}
/*
package java_se.java_jinjie.IO.demo3.demo1;
import java.io.Serializable;
//序列化的类必须要实现Serializable接口
public class Student implements Serializable {
//serialVersionUID 序列化版本号ID
private static final long serialVersionUID=100L;
private String name;
private transient int age;
public static String country="中国";
public Student(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 "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
*/2.反序列化
package java_se.java_jinjie.IO.demo3.demo1;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;
//使用objectInputStream实现反序列化(读取重构成对象)
//注意事项
//1.序列化类必须要实现Serializable接口
//2.序列化类中对象的属性也要求实现Serializable接口
//3.//serialVersionUID 序列化版本号ID:保证序列化的类和反序列化的类是同一个类
//4.使用transient(瞬间的)修饰属性，这个属性不能序列化
//5.静态属性不能序列化
//6.序列化多个独享，可与借助集合实现
public class Demo7 {
public static void main(String[] args) throws Exception {
//1.创建对象流
FileInputStream fis = new FileInputStream("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\stu.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
//2.读取文件(反序列化)//第一种，一个一个添加
// Student student = (Student)ois.readObject();
// Student student2 = (Student)ois.readObject();
ArrayList<Student> list= (ArrayList<Student>)ois.readObject();
//3.关闭
ois.close();
System.out.println("执行完毕");
// System.out.println(student.toString());
// System.out.println(student2.toString());
System.out.println(list.toString());
}
}
/*
package java_se.java_jinjie.IO.demo3.demo1;
import java.io.Serializable;
//序列化的类必须要实现Serializable接口
public class Student implements Serializable {
//serialVersionUID 序列化版本号ID
private static final long serialVersionUID=100L;
private String name;
private transient int age;
public static String country="中国";
public Student(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 "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
*/4.字符编码方式
ISO- 8859- 1收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。 1byte
UTF-8针对Unicode码表的可变长度字符编码 可能是1byte、2byte或3byte
GB2312简体中文 1byte或2byte
GBK(GB2312升级而来)简体中文、扩充 1byte或2byte
BIG5台湾，繁体中文当编码方式和解码方式不一致时，会出现乱码
5.字符流
1.字符流的父类
- 字符流的父类(抽象类):
- Reader: 字符输入流
- public int read() {}
- public int rcad(char[] c) {}
- public int read(char[] b, int off, int len) {}
- Writer:字符输出流
- public void write(int n) {}
- public void write(String str) {}
- public void write(char[] c) {}
2.文件字符流
- FileReader:
- public int read(char[] c) //从流中读取多个字符，将读到内容存入c数组，返回实际读到的字符数;如果达到文件的尾部，则返回-1。
- FileWriter:
- public void write(String str) //一次写多个字符，将b数组中所有字符，写入输出流。
- 字符流只能复制文本文件，不能复制图片或其他二进制文件
- 字符可以读取中文
1.FileReader
package java_se.java_jinjie.IO.demo3.demo2;
import java.io.FileReader;
import java.io.IOException;
//使用FileReader读取文件
public class Demo2 {
public static void main(String[] args) throws IOException {
//1.创建FileReader文件字符输入流
FileReader fr = new FileReader("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\hello.txt");
//2.读取
//2.1单个读取
// int date=0;
// while ((date=fr.read())!=-1){//读取一个字符
// System.out.print((char) date);
// }
//2.2
char[] buf =new char[4];//[]里的内容为一次读取的内容为多少个
int count=0;
while ((count=fr.read(buf))!=-1){
System.out.println(new String(buf,0,count));
}
//3.关闭
fr.close();
}
}
2.FileWriter
package java_se.java_jinjie.IO.demo3.demo2;
import java.io.FileWriter;
import java.io.IOException;
//使用FileWriter
public class Demo3 {
public static void main(String[] args) throws IOException {
//1.创建FileWriter对象
FileWriter fw = new FileWriter("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\write.txt");
//2.写入
for (int i = 0; i < 10; i++) {
fw.write("java是最好的语言\r");
fw.flush();
}
//3.关闭
fw.close();
System.out.println("执行完毕");
}
}
3.字符流复制文件
package java_se.java_jinjie.IO.demo3.demo2;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
//使用FileReader和FileWriter赋值文本文件,不能赋值图片或二进制文件
public class Demo4 {
public static void main(String[] args) throws IOException {
//1.创建FileReader和FileWriter
FileReader fr = new FileReader("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\write.txt");
FileWriter fw = new FileWriter("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\write2.txt");
//2.读写
int date=0;
while ((date=fr.read())!=-1){
fw.write(date);
}
//3.关闭
fr.close();
fw.close();
System.out.println("执行完毕");
}
}
3.字符缓冲流
- 缓冲流: BufferedReader/BufferedWriter
- 高效读写
- 支持输入换行符。newLine
- 可一次写一行、读一行。
1.BufferedReader(读取问题)
package java_se.java_jinjie.IO.demo3.demo2;
import java.io.BufferedReader;
import java.io.FileReader;
//使用字符缓冲流来读取文件BufferedReader
public class Demo5 {
public static void main(String[] args) throws Exception {
//1.创建字符缓冲流
FileReader fr = new FileReader("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\write.txt");
BufferedReader br = new BufferedReader(fr);
//2.读取
// char[] buf=new char[5];
// int count=0;
// while ((count= br.read(buf))!=-1){
// System.out.print(new String(buf,0,count));
// }
String line= null;
while ((line=br.readLine())!=null){
System.out.println(line);
}
//3.关闭
br.close();
}
}
2.BufferedWriter
package java_se.java_jinjie.IO.demo3.demo2;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
//演示bufferedWriter的使用
public class Demo6 {
public static void main(String[] args) throws IOException {
//1.创建bufferedWriter对象
FileWriter fw = new FileWriter("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\buffer.txt");
BufferedWriter bw = new BufferedWriter(fw);
//2.写入
for (int i = 0; i < 10; i++) {
bw.write("好好学习天天向上");//内容里面加\r\n或使用newLine换行
bw.newLine();//写入一个换行符 windows \r\n,linux \n
bw.flush();
}
//3.关闭
bw.close();
System.out.println("执行完毕");
}
}
4.打印流
- 作用：打印流可以实现方便、高效的打印数据到文件中去
- PrintWriter字符输出流
- PrintStream字节输出流
封装了print() / println()方法，支持写入后换行
支持数据原样打印
PrintStream和PrintWriter的区别：
- PrintStream继承自字节输出流OutputStream，支持写字节数据的方法。
- PrintWriter继承自字符输出流Writer，支持写字符数据出去。
package java_se.java_jinjie.IO.demo3.demo2;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
//演示PrintWriter的使用
public class Demo7 {
public static void main(String[] args) throws FileNotFoundException {
//1.创建打印流
PrintWriter pw = new PrintWriter("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\print.txt");
//2.打印
pw.println(97);
pw.println(true);
pw.println(3.14);
pw.println('a');
//3.关闭
pw.close();
System.out.println("打印完毕");
}
}
5.转换流
- 桥转换流(转换流): InputStreamReader/OutputStreamWriter
- 可将字节流转换为字符流。InputStreamReader
- 可将字符流转换为字节流。OutputStreamWriter
- 可设置字符的编码方式。
1.InputStreamReader（读取问题？）
package java_se.java_jinjie.IO.demo3.demo2;
import java.io.FileInputStream;
import java.io.InputStreamReader;
//使用InputStreamReader读取文件,指定使用的编码
public class Demo8 {
public static void main(String[] args) throws Exception {
//1.创建InputStreamReader对象
FileInputStream fis = new FileInputStream("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\write.txt");
InputStreamReader isr = new InputStreamReader(fis, "utf-8");
//2.读取文件
int date =0;
while ((date=isr.read())!=-1){
System.out.print((char)date);//读取问题
}
//关闭
isr.close();
}
}
2.OutputStreamWriter
package java_se.java_jinjie.IO.demo3.demo2;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
//使用OutputStreamWriter写入文件，使用指定的编码
public class Demo9 {
public static void main(String[] args) throws Exception {
//1.创建OutputStreamWriter
FileOutputStream fos = new FileOutputStream("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\info.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos, "GBK");
//2.写入
for (int i = 0; i < 10; i++) {
osw.write("我爱白净，我爱故乡\r\n");
osw.flush();
}
//3.关闭
osw.close();
System.out.println("执行成功");
}
}
6.File类
- 概念:
- 代表物理盘符中的一个文件或者文件夹。
- File类的对象代表操作系统的文件（文件、文件夹），File类在java.io.File包下。
- 描述目录文件和路径的对象。
1.文件夹 Directory : 存储文件的容器,防止文件重名而设置,文件归类,文件夹本身不存储任何数据, 计算专业数据称为 目录。
2.文件 File : 存储数据的,同一个目录中的文件名不能相同。
3.路径 Path : 一个目录或者文件在磁盘中的位置。
c:\jdk8\jar 是目录的路径,是个文件夹的路径
c:\jdk8\bin\javac.exe 是文件
相对路径和绝对路径
相对路径：必须有参照物。不带盘符，默认直接到当前工程下的目录寻找文件。
绝对路径：在磁盘中的路径具有唯一性
注意：
- lFile对象可以定位文件和文件夹。
- File封装的对象仅仅是一个路径名，这个路径可以是存在的，也可以是不存在的
File类方法 方法名称 说明 createNewFile() 是否创建新文件的布尔类型 File() 根据文件路径名创建文件对象 mkdir() 创建一个新目录 单级目录 mkdirs() 创建 多级目录 delete() 删除文件或空目录，不会进入回收站，直接从磁盘中删除了 exists() 判断File对象所对象所代表的对象是否存在 getAbsolutePath() 获取文件的绝对路径 getName() 获取文件或文件夹名称 getParent() 获取文件/目录所在的目录 getParentFile() 获取父路径 getPath() 获取File构造方法中的路径(完整的路径转成String返回) isDirectory() 是否是目录 isFile() 是否是文件 isDirectory() 是否是文件夹 isHidden() 是否是隐藏文件 isAbsolutr() 是否是绝对路径 length() 获得文件的长度 listFiles() 列出目录中的所有内容 renameTo() 修改文件名为 lastModified() 查询最后修改时间(默认为从1990年开始的毫秒值)调用new date方法获取时间 canWrite() 是否可写 list() 获取当前目录下所有的以及文件对象到一个字符串数组中返回 listFiles() 获取当前目录下所有的以及文件对象到一个文件对象数组中返回，遍历当前文件夹（重点）
1.File类使用(分隔符、文件、文件夹)
package java_se.java_jinjie.IO.Demo6;
import java.io.File;
import java.util.Date;
//file类的使用
//1.分隔符
//2.文件操作
//3.文件夹操作
public class Demo1 {
public static void main(String[] args) throws Exception {
// separator();
// fileOpe();
directoryOpe();
}
//1.分隔符
public static void separator(){
System.out.println("路径分隔符"+File.pathSeparator);
System.out.println("名称分隔符"+File.separatorChar);
}
//2.文件操作
public static void fileOpe() throws Exception {
//1.创建文件
File file = new File("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\file.txt");
//System.out.println(file.toString());
if (!file.exists()){//判断file所代表的的对象是否存在
boolean b = file.createNewFile();
System.out.println("创建结果:"+b);
}
//2.删除文件
//2.1直接删除
// System.out.println("删除结果:"+file.delete());
//2.2使用jvm退出时删除
// file.deleteOnExit();
// Thread.sleep(5000);
//3.获取文件信息
System.out.println("获取文件的绝对路径:"+file.getAbsolutePath());
System.out.println("获取路径:"+file.getPath());//获取的是你写入的，写入相对路径获取相对，写入绝对路径，写入绝对路径
System.out.println("获取文件名称"+file.getName());
System.out.println("获取父目录"+file.getParent());
System.out.println("获取文件长度:"+file.getParent());
System.out.println("文件创建时间"+new Date(file.lastModified()));
//4.判断
System.out.println("是否可写:"+file.canWrite());
System.out.println("是否是文件"+file.isFile());
System.out.println("是否是隐藏文件"+file.isHidden());
}
//3.文件夹操作
public static void directoryOpe() throws InterruptedException {
//1.创建文件夹
File dir = new File("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\aaa\\bbb\\ccc");
System.out.println(dir.toString());
if (!dir.exists()){
// dir.mkdir();//只能创建单机目录
System.out.println(dir.mkdirs());//创建多级目录
}
//2.删除文件夹
//2.1直接删除
System.out.println("删除结果"+dir.delete());//只删除最里层目录(必须是空目录)
//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()));
//4.判断
System.out.println("是否是文件夹:"+dir.isDirectory());
System.out.println("是否是隐藏文件夹"+dir.isHidden());
//5.遍历文件夹
File dir2 = new File("H:\\java全栈\\JavaSE\\java进阶\\3.io详解");
String[] files = dir2.list();
for (String s: files){
System.out.println(s);
}
}
}
2.FileFilter接口
- public interface FileFilter
- boolean accept (File pathname)
- 当调用File类中的listFiles()方法时，支持传入FileFilter接口接口实现类，对获取文件进行过滤，只有满足条件的文件的才可出现在listFiles()的返回值中。
package java_se.java_jinjie.IO.Demo6;
import java.io.File;
import java.io.FileFilter;
import java.util.Date;
//file类的使用
public class Demo1 {
public static void main(String[] args) throws Exception {
directoryOpe();
}
public static void directoryOpe() throws InterruptedException {
//遍历文件夹
File dir2 = new File("D:\\桌面\\备忘\\408证件照");
String[] files = dir2.list();
for (String s: files){
System.out.println(s);
}
System.out.println("----FileFilter接口的使用----");
File[] files1 = dir2.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
if (pathname.getName().endsWith("jpg")) {
return true;
}
return false;
}
});
for (File file:files1){
System.out.println(file.getName());
}
}
}
3.递归遍历和递归删除
listFiles方法注意事项:
- 当文件不存在时或者代表文件时，返回null。
- 当文件对象代表一个空文件夹时，返回一个长度为0的数组。
- 当文件对象是一个有内容的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回。
- 当文件对象是一个有隐藏文件的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏文件。
- 当没有权限访问该文件夹时，返回null。
package java_se.java_jinjie.IO.Demo6;
import java.io.File;
//案例1：递归遍历文件夹
//案例2：递归删除文件夹
public class ListDemo {
public static void main(String[] args) {
//listDir(new File("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\myfiles"));
deleteDir(new File("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\myfiles"));
}
//案例1：递归遍历文件夹
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){
if (file.isDirectory()){
listDir(file);//递归
}else {
System.out.println(file.getAbsolutePath());
}
}
}
}
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());
}
}
4.Properties
- Properties:属性集合
- 特点
- 存储属性名和属性值
- 属性名和属性值都是字符串类型
- 没有泛型
- 和流有关
package java_se.java_jinjie.IO.Demo6;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
//演示Properties集合的使用
public class Demo2 {
public static void main(String[] args) throws IOException {
//1.创建一个集合
Properties properties = new Properties();
//2.添加数据
properties.setProperty("username", "zhangsan");
properties.setProperty("age","20");
System.out.println(properties);
//3.删除
properties.remove("username");
//4.遍历
//4.1----keySet----
//4.2----entrySet----
//4.3----stringPropertyName()----
Set<String> propertyNames = properties.stringPropertyNames();
for (String pro:propertyNames){
System.out.println(pro+"=="+properties.getProperty(pro));
}
//5.和流有关的方法
//------list方法-----
// PrintWriter pw = new PrintWriter("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\print.txt");
// properties.list(pw);
// pw.close();
//-----store方法 保存-----
FileOutputStream fos = new FileOutputStream("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\store.properties");
properties.store(fos,"注释");
fos.close();
//-----load方法 加载-----
Properties properties1 = new Properties();
FileInputStream fis = new FileInputStream("H:\\java全栈\\JavaSE\\java进阶\\3.io详解\\store.properties");
properties1.load(fis);
fis.close();
System.out.println(properties1.toString());
}
}
7.Files工具类
- Files. exists()：检测文件路径是否存在。
- Files. createFile()：创建文件。
- Files. createDirectory()：创建文件夹。
- Files. delete()：删除一个文件或目录。
- Files. copy()：复制文件。
- Files. move()：移动文件。
- Files. size()：查看文件个数。
- Files. read()：读取文件。
- Files. write()：写入文件。
645
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
