File类
File类表示文件或者
创建File对象
创建File对象时，需要指定一个路径。这个路径可以存在，也可以不存在，可以是文件路径也可是文件夹路径。
文件夹的路径。
File f1=new File("C:\\a.txt");
System.out.println(f1);
//根据父路径和子路径创建File对象
File f2=new File("C:\\aaa","a.txt");
System.out.println(f2);
//创建一个父路径的对象
File dir=new File("C:\\aaa");
//再根据父路径和子路径创建File对象
File f3=new File(dir,"a.txt");
System.out.println(f3);
相对路径和绝对路径
绝对路径：从盘符开始的路径
"C:\\a.txt"
相对路径： 相对于项目的根目录，下面的路径
//假设项目的根路径是 C:\\IdeaProjects\javase
绝对路径 "C:\\IdeaProjects\javase\myModule\a.txt"
相对路径："myModule\a.txt"
注意：只有在项目的文件下的文件，才可以写相对路径。
File类的常用方法
创建和删除方法
public boolean mkdir()
创建文件夹，只能创建单极文件夹。
public boolean mkdirs()
创建多级文件夹(推荐)
public boolean createNewFile()
创建文件，文件的父路径一定要存在。
public void delete()
删除文件或者文件夹（必须是空的文件夹才能删除）
判断功能
public boolean exists()
判断File对象的路径是否存在
public boolean isDirectory()
判断File对象的路径是否为文件夹路径
public boolean isFile()
判断File对象的路径是否为文件路径
获取功能
public String getName()
获取文件或者文件夹的名称（如：a.txt）
public String getParent()
获取文件或者文件夹的父目录，返回字符串
public File getParentFile()
获取文件或者文件夹的父目录，返回File对象
public String getPath()
获取File对象封装的路径
public String getAbsolutePath()
获取绝对路径, 返回值是String类型
public File getAbsoluteFile()
获取绝对路径，返回值File对象
public long length()
获取文件的大小，单位(字节)
不能获取文件夹的长度
遍历文件夹的方法
public File[] listFiles()
获取当前目录下所有文件和文件夹，把获取到文件和文件夹以File对象的方式存在File数组中。
注意：
1.返回值是null的几种情况
File对象的目录路径不存在
File对象的路径为文件路径
File对象的文件没有权限访问
2.File对象的目录存在，但是目录中没有东西(空的文件夹)
返回值是一个File[],但是数组中没有元素
File操作文件夹练习
遍历文件夹中所有的子文件和子目录
public class Demo2 {
public static void main(String[] args) {
File f=new File("C:\\Users\\Desktop\\a");
printDirectory(f);
}
//方法：遍历一个文件夹中的所有子文件和子文件夹
public static void printDirectory(File dir){
System.out.println(dir); //打印文件夹
//判断dir是文件夹吗？
if(dir.isDirectory()){
//获取文件夹下的子文件和子文件夹，存在File数组中
File[] files = dir.listFiles();
if(files!=null){
for (File file : files) {
//判断file是文件吗？是文件，直接打印
if(file.isFile()){
System.out.println(file);
}else {
//判断file是文件夹吗？ 如果是文件夹，继续遍历文件夹
printDirectory(file);
}
}
}
}
}
}
删除一个文件夹
删除文件夹的思路
1.使用listFiles()获取文件夹的子目录和子文件
2.删除子目录和子文件
子目录(不能直接删除、递归删除)
子文件(可以直接删除)
3.最后在删除空的文件夹
public class Demo3 {
public static void main(String[] args) {
File file=new File("C:\\Users");
deleteDir(file);
}
//方法： 删除文件夹
public static void deleteDir(File dir){
if(dir.isDirectory()){
//遍历文件夹中的内容
File[] files = dir.listFiles();
if(files!=null){
for (File file : files) {
if(file.isFile()){
//是文件，直接删除
file.delete();
}else{
//是文件夹，递归调用
deleteDir(file);
}
}
}
//删除空的文件夹
dir.delete();
}
}
}
统计一个文件夹中每一种文件出现的次数
//统计一个文件夹中每一种文件出现的次数
//参数1 HashMap: 键：文件后缀名，值：每一种文件对应的次数
//参数2 File: 需要统计的文件夹
public static void getCount(HashMap<String,Integer> map,File dir){
//如果是文件夹，才进行下面的操作
if(dir.isDirectory()){
File[] files=dir.listFiles();
if(files!=null){
for(File file:files){
//如果file是文件，统计每一种文件出现多少次，文件-次数对应关系，存储到map集合中
if(file.isFile()){
//获取文件的后缀名 如： a.txt --> txt
String fileEndname=file.getName().split("\\.")[1];
//判断map集合中是否存在键
if(map.containsKey(fileEndname)){
//包含这个键，先获取键对应的值，再加1，再存回去
Integer count=map.get(fileEndname);
map.put(fileEndname,count+1);
}else{
//不包含键，第一次存
map.put(fileEndname,1);
}
}else{
getCount(map,file);
}
}
}
}
}
求文件夹的大小
public class Demo7 {
public static void main(String[] args) {
long length = getLength(new File("C:\\Users"));
System.out.println(length);
}
//获取文件夹的大小
//参数：File dir 文件夹
//返回值： long 文件夹的大小
public static long getLength(File dir) {
long length = 0;
//1.判断dir是否为文件夹
if (dir.isDirectory()) {
//2.是文件夹就进行遍历
File[] files = dir.listFiles();
if (files != null) {
for (File file : files) {
//file可能是文件，也可能是文件夹
if (file.isFile()) {
//求文件的大小，和length累加
length += file.length();
} else if (file.isDirectory()) {
//求文件夹的大小，和length累加
length += getLength(file);
}
}
}
}
return length;
}
}
IO流
内存：临时存储数据，程序运行时的一些数据都是在内存中的。
程序运行结束之后，内存中的数据就被释放掉了。
硬盘：永久存储数据，程序结束之后数据还在。
IO流的分类
按照流向分类
输入流： 读数据
输出流： 写数据
按照读写的数据类型分类
字节流：读写任意类型的文件（图片、视频、文字、游戏...）
字节输入流：InputStream，用来读取字节数据
- FileInputStream：读取文件中的字节
- BufferedInputStream: 对已有的InputStream进行包装，提高读取的效率
字节输出流：OutputStream，用来写字节数据
- FileOutputStream： 写入文件中的字节
- BufferedOutputStream：对已有的OutputStream进行包装，提高写入的效率
学习IO流的步骤
1.创建流对象(搭桥)
2.读写数据(过桥)
3.释放资源(过河拆桥)
字节流写数据
//创建输出流对象(搭桥)，需要关联一个文件
//如果文件不存在，会自动创建一个
//如果文件存在，会把原来的文件覆盖掉
FileOutputStream fos=new FileOutputStream("myModule11\\a.txt");
//写数据(过桥)
fos.write("helloworld".getBytes());
fos.write("\r\n".getBytes()); //写一个换行
fos.write("你好世界".getBytes());
//写单个字节
fos.write(97); //97对应字符'a'
//写多个字节
byte[] bs={97,98,99,100,101}; //'a','b','c','d','e'
fos.write(bs);
//字节数组的一部分
fos.write(bs,0,3);
//释放资源(过河拆桥)
fos.close();
字节流读数据
//1.创建输入流对象
FileInputStream fis=new FileInputStream("myModule11\\a.txt");
//2.读取数据： 一次读多个字节
byte[] bs = new byte[1024];
int len; //记录每次读取的字节个数
while ((len=fis.read(bs))!=-1){
//把读取到的有效字节个数，转换为字符串
String str=new String(bs,0,len);
System.out.println(str);
}
//3.释放资源
fis.close();
字节流复制文件
把a.txt文件中的内容，复制到b.txt文件中
文件复制的思路：
使用输入流，读取源文件(a.txt)
使用输出流，写入目标文件(b.txt)
//使用输入流，读取源文件(a.txt)
FileInputStream fis=new FileInputStream("myModule11\\2.jpg");
//使用输出流，写入目标文件(b.txt)
FileOutputStream fos=new FileOutputStream("myModule11\\3.jpg");
//一遍读，一遍写
byte[] bs=new byte[1024];
int len; //每次读取的有效个数
while ((len=fis.read(bs))!=-1){
//把读取到有效字节，写入目标文件中
fos.write(bs,0,len);
}
//释放资源
fos.close();
fis.close();
字节缓冲流复制文件
BufferedInputStream和BufferedOutputStream用来对已有的InputStream和OutPutStream进行包装，从而提高读写效率。
//记录开始时间
long start = System.currentTimeMillis();
//读取a.exe文件
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\a.exe"));
//写入b.exe文件
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\\c.exe"));
byte[] bs=new byte[1024];
int len; //读取的有效字节个数
while ((len=bis.read(bs))!=-1){
bos.write(bs,0,len);
}
//释放资源
bos.close();
bis.close();
//记录结束时间
long end = System.currentTimeMillis();
System.out.println(end-start);
IO流异常处理
FileOutputStream fos = null;
try {
//1. 创建FileOutputStream流对象（搭桥）
fos = new FileOutputStream("day11\\a.txt");
//2. 写数据(过桥)
fos.write("hello".getBytes());
} catch (IOException e) {
e.printStackTrace();
} finally {
//不管异常是否发生，finally里面的代码一定会执行(释放资源的代码)
//3. 关流
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
206
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
