File
File概述
File可以表示文件的路径也可以表示文件夹的路径
如果我们需要将一个游戏文件保存在本地，我们需要用File确定保存文件的位置和用IO进行传输
路径
File类构造方法
File表示文件，创建出一个对象则表示创建出了一个文件，而输出文件则输出路径名，则路径名是文件的字符串表示
package com;
import java.io.File;
public class FileDimo1 {
public static void main(String[] args) {
/*
public File(String pathname) 根据文件路径创建文件对象
public File(String parent,String child) 根据父类路径名字符串和子类路径名字符串创建文件对象
public File(File parent,String child) 根据父路径对应的文件对象和子路径名字符串创建文件对象
C:\Users\alienware\Desktop\a.txt
*/
//1.根据字符串表示的路径创建文件对象
String str = " C:\\Users\\alienware\\Desktop\\a.txt";
File f1 = new File(str);
System.out.println(f1.toString());// C:\Users\alienware\Desktop\a.txt
//2.根据父类路径字符串和子类路径字符串创建文件对象
//父级路径：C:\Users\alienware\Desktop
//子级路径：a.txt（完整文件名）
String parent = "C:\\Users\\alienware\\Desktop";
String child = "a.txt";
File f2 = new File(parent,child);
System.out.println(f2);//C:\Users\alienware\Desktop\a.txt
//这里也可以用父级路径名和子级路径名进行拼接（这种方式不提倡使用）
//1.java中\为文件分隔符有特殊含义需要用\\转义
//2.如果我们的代码用在别的平台 如Linux使用\\链接java底层将不会将文件分隔符转化为别的平台的分隔符
File f3 = new File("C:\\Users\\alienware\\Desktop"+"\\"+"a.txt");
System.out.println(f3);
//3.把一个File表示的路径和一个字符串表示的路径进行拼接
File parent2 = new File("C:\\Users\\alienware\\Desktop");
String child2 = "a.txt";
File f4 = new File(parent2,child);
System.out.println(f4);//C:\Users\alienware\Desktop\a.txt
}
}
绝对路径是带盘符的。相对路径是不带盘符的，默认到当前项目下去找
File中常见成员方法
判断获取
package com;
import java.io.File;
public class FileDimo1 {
public static void main(String[] args) {
//判断的方法
/*
public boolean isDirectory() 判断此路径名表示的File是否为文件夹
public boolean isFile() 判断此路径名表示的File是否为文件
public boolean exists() 判断此路径名表示的File是否存在
*/
//1.对一个文件的路径进行判断
File f1 = new File("D:\\QQLicense.rtf");
System.out.println(f1.isDirectory());//false
System.out.println(f1.isFile());//true
System.out.println(f1.exists());//true
System.out.println("----------------------------------------------------");
//2.对一个文件夹的路径进行判断
File f2 = new File("D:\\WeChat");
System.out.println(f2.isDirectory());//true
System.out.println(f2.isFile());//false
System.out.println(f2.exists());//true
System.out.println("-----------------------------------------");
//3.对一个不存在的路径进行判断
File f3 = new File("D:\\abcd");
System.out.println(f3.isDirectory());//false
System.out.println(f3.isFile());//false
System.out.println(f3.exists());//false
}
}
相对路径可以理解为在当前编译器项目中的路径，决定路径则是在整个电脑中的路径
定义File文件可以使用相对路径也可以使用绝对路径
package com;
import java.io.File;
public class FileDimo1 {
public static void main(String[] args) {
/*
获取方法：
public long length() 返回文件的大小(字节数量)
public String getAbsolutePath() 获取文件的绝对路径
public String getPath() 返回定义文件时使用的路径
public String getName() 返回文件的名称，带后缀
public long lastModified() 返回文件的最后修改时间（时间毫秒值）
*/
//1.length
/*
细节1：这个方法只能获取文件的大小（字节数量）
如果要得到M或者G 需要不断除以1024
细节2：这个方法无法获取文件夹的大小（文件夹调用该方法可能返回0或4096这和系统有关）
//如果要获取一个文件夹的大小，需要这个文件夹里面的所有文件的大小累加在一起
*/
File f1 = new File("D:\\QQLicense.rtf");//删除复制时的无关字符
final long len1 = f1.length();
System.out.println(len1);//253626
//当我们的File表示是文件夹时
File f2 = new File("D:\\Notepad++");
final long len2 = f2.length();
System.out.println(len2);//4096(这个答案并不正确)
System.out.println("-------------------------------------------------");
//2.返回文件的绝对路径getAbsolutePath()
File f3 = new File("D:\\Notepad++");//我们以绝对路径创建的对象
System.out.println(f3.getAbsoluteFile());//D:\Notepad++ 返回绝对路径
File f4 = new File("small\\aa.txt");//以相对路径定义
System.out.println(f4.getAbsoluteFile());//D:\ideaprojects\small\small\aa.txt(依然返回的是绝对路径)
//3.getPath() 返回定义文件时使用的路径（定义时写什么将会返回什么）
System.out.println("---------------------------------------------------------------");
File f5 = new File("D:\\Notepad++");//用绝对路径
System.out.println(f5.getPath());////D:\Notepad++
File f6 = new File("small\\aa.txt");//使用相对路径
System.out.println(f6.getPath());//small\aa.txt
System.out.println("----------------------------------------------------------------------");
//4.返回文件的名称getName
//细节：当是文件调用时 将会返回文件名+拓展名
//当是文件夹调用时，将会返回文件夹名
File f7 = new File("D:\\QQLicense.rtf");//文件
System.out.println(f7.getName());//QQLicense.rtf
File f8 = new File("D:\\Notepad++");//文件夹
System.out.println(f8.getName());//Notepad++
System.out.println("-----------------------------------------------------------");
//5.lastModified返回文件的最后修改时间
File f9 = new File("D:\\QQLicense.rtf");
final long time = f9.lastModified();
System.out.println(time);//1664518111254
}
}
创建和删除
package com;
import java.io.File;
import java.io.IOException;
public class FileDimo1 {
public static void main(String[] args) throws IOException {
/*
public boolean createNewFile() 创建一个新的空的文件
public boolean mkdir() 创建单级文件夹
public boolean mkdirs() 创建多级文件夹
public booean delete() 删除文件.空文件夹
*/
//1.createNewFile创建一个新的文件
/*
细节1：如果当前路径下创建的文件不存在则创建成功 方法返回true
如果当前路径下表示的文件存在则创建失败，方法返回false
细节2：如果父类路径是不存在的 方法将会抛出IOEXception
细节3：createNewFile方法创建的一定是文件 如果路径中的文件不含拓展名则创建的是不含拓展名的文件（和相同名称的文件不同）
*/
/*File f1 = new File("C:\\Data\\AAA");//定义一个文件
final boolean b = f1.createNewFile();//该处可能抛出异常
System.out.println(b);//第一次创建成功将返回true 再次创建将返回false*/
System.out.println("----------------------------------------------------------");
//2.mkdir make Directory 创建单级文件夹
/*
细节1：windows当中的路径是唯一的，如果当前的路径已经存在，则创建失败，返回false
细节2：mkdir方法只能创建单级文件夹，无法创建多级文件夹
*/
/* File f2 = new File("C:\\Data\\AAA");
final boolean c = f2.mkdir();
System.out.println(c);//此时AAA.txt和创建出来的文件夹路径相同
File f3 = new File("C:\\Data\\AAA\\AAA\\BBB");
final boolean d = f3.mkdir();//false
System.out.println(d);*/
System.out.println("-----------------------------------------------------------------");
//3.mkdirs
//细节：既可以创建单级文件夹又可以创建多级文件夹
/* File f5 = new File("C:\\Data\\bbb\\AAA\\BBB");//创建多级文件夹
System.out.println(f5.mkdirs());//true
File f6 = new File("C://Data\\ddd");//创建单级文件夹
System.out.println(f6.mkdirs());//true*/
//4.delete() 删除文件 文件夹
}
}
删除
package com;
import java.io.File;
public class FileDemo2 {
public static void main(String[] args) {
//public boolean delete() 删除文件 文件夹
/*
细节：如果删除的文件 则直接删除 不走回收站
如果删除的是文件夹:
如果是文件夹里面是空的 则直接删除 不走回收站
如果文件夹里面有内容 则无法删除
*/
//删除文件
File f1 = new File("C:\\Data\\AAA.txt");
System.out.println(f1.delete());//删除成功
//删除空文件夹
File f2 = new File("C:\\Data\\ddd");
System.out.println(f2.delete());//true
//删除有内容的文件夹
File f3 = new File("C::\\Data\\bbb");
System.out.println(f3.delete());//false 删除失败
}
}
获取并遍历
获取当前路径下的所有内容并放到一个数组中
package com;
import java.io.File;
public class FileDemo2 {
public static void main(String[] args) {
//public File[] listFiles() 获取当前路径下所有的内容
//1.创建File对象
File f = new File("C:\\Data\\bbb");
//2.调用listFilses方法 获取当前路径下所有的内容并放在数组中
File[] files = f.listFiles();
for (File file : files) {
System.out.println(file);
}
//如果当前路径下是文件则当前路径下没有内容 数组内容为空 增强for循环将会出现空指针异常
}
}
重点掌握：listFile方法的注意事项
重点掌握listFile其他的了解即可
package com;
import java.io.File;
import java.io.FilenameFilter;
import java.util.Arrays;
public class FileDemo2 {
public static void main(String[] args) {
/*
public static File[] listRoots() 列出可用的文件系统根
public String [] list() 获取当前该路径下的所有内容
public String [] list(FilenameFilter filter) 利用文件名过滤器获取当前该路径下的所有内容
（掌握）public File[] listFiles() 获取当前该路径下的所有内容
public File[] listFiles(FileFilter filter)利用文件名过滤器获取当前该路径下的所有内容
public File[] listFiles(FilenameFilter filter)利用文件名过滤器获取当前该路径下的所有内容
*/
//1.listRoots 获取系统中所有的盘符
// final File[] arr = File.listRoots();
//System.out.println(Arrays.toString(arr));//[C:\, D:\]
//2.list 获取当前该路径下所有内容（仅仅能获取名字，无法获取具体路径）
/* File f1 = new File("C:\\Data\\bbb");
final String[] arr2 = f1.list();
System.out.println(Arrays.toString(arr2));//[AAA, addd.txt, cwd]*/
//3.list(FilenameFilter filter)利用文件名过滤器获取当前该路径下所有内容
//需求：获取C：\\Data\\bbb文件夹里面所有的txt文件
/*
accept方法的形参，以此表示bbb文件夹中每一个文件或文件夹的路径
list的参数为一个函数式接口
参数一：父级路径
参数二：子级路径
返回值：如果返回值为true,就表示当前路径保留
如果返回值为false,则表示当前路径舍弃不要
*/
File f3 = new File("C:\\Data\\bbb");
String[]arr3 = f3.list(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {//分别表示父级路径和子级路径
File src = new File(dir,name);
if(src.isFile()&&name.endsWith("txt"))
return true;else {
return false;
}
}
});
System.out.println(Arrays.toString(arr3));//[addd.txt]
}
}
package com;
import java.io.File;
import java.util.Arrays;
public class FIleDemo3 {
public static void main(String[] args) {
/*
掌握）public File[] listFiles() 获取当前该路径下的所有内容
public File[] listFiles(FileFilter filter)利用文件名过滤器获取当前该路径下的所有内容
public File[] listFiles(FilenameFilter filter)利用文件名过滤器获取当前该路径下的所有内容
*/
//用listFiles获取txt文件
File f1 = new File("C:\\Data\\bbb");
final File[] arr = f1.listFiles();//获取当前路径下所有的内容
for (File file : arr) {
final String name = file.getName();//获取每一个文件或文件夹名
if(file.isFile()&&name.endsWith("txt")){
System.out.println(file);//C:\Data\bbb\addd.txt
}
}
}
}
后面的2个方法的参数都是函数式接口，并这2个方法实现过滤出txt文件和前面的一样
综合练习
练习1（创建文件）
package com;
import java.io.File;
import java.io.IOException;
public class FilePractice {
public static void main(String[] args) throws IOException {
/*
练习1：在C:\Data\bbb下中创建一个a.txt文件（bbb文件夹已经存在只需要创建文件）
练习1：在模块下的bbb文件夹中创建一个a.txt文件（模块下同时没有文件夹和文件都需要创建）
*/
//练习1
//创建文件的路径
/* File f = new File("C:\\Data\\bbb\\a.txt");
//在电脑中创建文件
boolean b = f.createNewFile();//此处要抛出异常
System.out.println(b);//true*/
//练习2
//我们需要先创建文件夹再创建文件
//定义文件夹的路径
File f2 = new File("small\\bbb");
final boolean b = f2.mkdirs();//创建文件夹
System.out.println(b);
//创建文件(可以使用子父级拼接也可以不使用)
//定义文件路径
File f3 = new File(f2, "a.txt");
//创建文件
final boolean c = f3.createNewFile();
System.out.println(c);
}
}
练习2(单个文件查找文件)
package com;
import java.io.File;
import java.io.IOException;
public class FilePractice {
public static void main(String[] args) throws IOException {
//定义一个方法找某一个文件夹中，是否有以avi结尾的电影（暂时不需要考虑子文件夹）
File f = new File("C:\\Data\\bbb");
final boolean b = havaAvi(f);
System.out.println(b);
}
//判断一个文件夹中是否有以avi结尾的电影
public static boolean havaAvi(File file){
final File[] files = file.listFiles();//得到该文件夹下所有的内容并放在数组中
for (File file1 : files) {//file1表示该文件夹里面每一个文件和文件夹的路径
final String name = file1.getName();//得到文件名或文件夹名
if(name.endsWith("avi")&&file1.isFile()){
return true;
}
}
return false;
}
}
练习3（遍历硬盘查找文件）
在所有的盘符中进行查找，难点在于各个文件夹包含的内容不统一，以至于代码无法统一编写
使用递归来解决
当引用数据类型指向null时，然后又使用该引用调用其堆空间的内容时，将会出现空指针异常
数组也是引用数据类型，可以用类来理解，int [] a ={}和int [] a = null意义不同，前者的有地址但是堆空间没有内容，后者则完全没有地址，用null调用堆空间内容将会出现空指针异常
package com;
import java.io.File;
import java.io.IOException;
public class FilePractice {
public static void main(String[] args) {
//找到电脑中所有以avi结尾的电影(需要考虑子文件夹)
//递归思想：把大问题拆分，拆到一个文件夹中不包含其他文件夹为止
/*
套路：
1.进入文件夹
2.遍历数组
3.判断
4.判断
*/
findAvi();
}
//该方法用于电脑上所有的盘符
public static void findAvi(){
final File[] files = File.listRoots();//获取电脑上所有的盘符
//遍历盘符
for (File file : files) {
findAvi(file);
}
}
//仅仅遍历c盘
public static void findAvi(File src){//假设传入c盘
//1.进入文件夹
File[] files = src.listFiles();//获取C盘下每一个文件或文件夹
//2.遍历数组
/*
细节：listFiles()方法当文件夹有访问权限时将会返回空
*/
if(files!=null){
for (File file : files) {//数组名指向空然后使用数组名调用堆空间内容将会出现空指针异常
//3.判断如果是文件执行具体业务逻辑
if(file.isFile()){
String name = file.getName();//获取文件名
if(name.endsWith("avi")){
System.out.println(file);
}
}else {//如果不是文件则进行递归继续向下查找
findAvi(file);
}
}
}
}
}
练习4
package com;
import java.io.File;
import java.io.IOException;
public class FilePractice {
public static void main(String[] args) {
/*
删除一个多级文件夹（文件夹里面有内容）
delete方法只能删除文件或者空文件夹
1.先删除文件夹里面的内容
2.然后删除自己
*/
File file = new File("C:\\Data");
remove(file);
}
/*
作用：删除bbb文件夹
参数：要删除的文件夹
*/
public static void remove(File file){
final File[] files = file.listFiles();//得到文件夹里面所有内容
if(files!=null){
for (File file1 : files) {
if(file1.isFile()){
file1.delete();
}else {
remove(file1);
}
}
file.delete();
}
}
}
练习5(统计文件夹的大小)
package com;
import java.io.File;
import java.io.IOException;
public class FilePractice {
public static void main(String[] args) {
//统计一个文件夹的总大小
File file = new File("C:\\Data");
System.out.println(getLen(file));
}
/*
文件夹总大小：文件夹里面所有文件的总大小
形参表示要统计的文件夹
*/
public static long getLen(File src){
//1.进入文件夹
long len = 0;//用于统计总大小（单位字节）
final File[] files = src.listFiles();
//2.遍历数组
for (File file : files) {
if(file.isFile()){
final long length = file.length();//获取文件的大小
len = len + length;
/*
对于len= len+length的细节：
len为一个函数里面的局部变量
当递归再次调用函数的时候 递归函数的len和没有递归的len不是同一个len
所有返回的len仅仅是src文件夹里面的文件总大小
*/
}else {
//如果是文件夹则进行递归处理
//修改前：getLen(file)
len = len + getLen(file);//修改后
//如果递归把文件夹文件总和返回并和以前的总和一个累加
}
}
return len;
}
}
练习6（统计各种文件夹的数量）（有点难度要使用Map集合）
package com;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class FilePractice {
public static void main(String[] args) {
//统计一个文件夹中每种文件的个数并打印(考虑子文件夹)
/*
打印格式如下：
txt:3个
doc:4个
jpg:6个
用到知识：File 递归 Map（用于统计）(键文件，值：数量)
计数器思想的弊端：不知道文件夹中有多少种文件 则不知道需要设置多少个计数器变量
*/
File file = new File("C:\\Data");
final HashMap<String, Integer> count = getCount(file);
System.out.println(count);
}
/*
作用：统计一个文件夹中每种文件的个数
参数：要统计的文件夹
返回值：
用来统计的map集合
键：文件名 值：次数
要考虑到的文件名：
a.txt
a.a.txt
aaa（这种文件名不需要统计）
*/
public static HashMap<String,Integer> getCount(File file){
//1.定义集合用于统计
HashMap<String,Integer> hm = new HashMap<>();
//2.进入Data文件夹
final File[] files = file.listFiles();//得到文件中所有的内容
//3.变量数组
for (File file1 : files) {
if(file1.isFile()){
//当为文件时
final String name = file1.getName();//得到文件名
final String[] arr = name.split("\\.");//按照点进行分割
if(arr.length>=2){//数组长度大于等于2则需要统计
String endName = arr[arr.length-1];//得到最大索引上的元素即后缀名
if(hm.containsKey(endName)){
//如果该文件已经被统计
Integer count = hm.get(endName);//得到该文件出现的次数
count++;
hm.put(endName,count);
}else {
//该文件没有被统计过
hm.put(endName,1);
}
}
}else{
//当为文件夹时进行递归处理
//sonMap里面是子文件夹中每一种文件的个数
HashMap<String, Integer> sonMap = getCount(file1);
//将sonMap中的数量同步到hm中
//1.遍历sonMap集合把里面的值累加到hm中
final Set<Map.Entry<String, Integer>> entries = sonMap.entrySet();//放在set中
for (Map.Entry<String, Integer> entry : entries) {
final String key = entry.getKey();
final Integer value = entry.getValue();
if(hm.containsKey(key)){
//hm中存在该键
Integer count = hm.get(key);//得到hm中该键的值
count = count +value;//将该键的值累加
hm.put(key,count);//将hm中这对键和值更新
}else {
//hm中不存在该键
hm.put(key,value);//不存在直接放入
}
}
}
}
return hm;
}
}
