File类
可以通过File类中的方法操作计算机中的文件和文件夹
/*
java.io.File类:
文件和目录路径名的抽象表示形式。
File类封装了计算机中的文件和文件夹,我们可以通过File类中的方法操作计算机中的文件和文件夹
可以使用FIle类中的方法创建文件|文件夹
可以使用FIle类中的方法删除文件|文件夹
可以使用FIle类中的方法获取文件|文件夹的路径
可以使用FIle类中的方法遍历文件夹
可以使用FIle类中的方法获取文件的大小(字节)
必须的记住3个英文单词
file:文件
directory:文件夹,目录
path:路径
File类是一个与系统无关的类,任何的操作系统都可以使用File中的功能
*/
File类的静态成员变量
public class Demo01File {
public static void main(String[] args) {
/*
File类的静态成员变量
static String pathSeparator 与系统有关的路径分隔符,为了方便,它被表示为一个字符串。
static char pathSeparatorChar与系统有关的路径分隔符。
static String separator 与系统有关的默认名称分隔符,为了方便,它被表示为一个字符串。
static char separatorChar 与系统有关的默认名称分隔符。
*/
String pathSeparator = File.pathSeparator;
System.out.println(pathSeparator);//路径分隔符 windows:分号(;) linux:冒号(:)
String separator = File.separator;
System.out.println(separator);//默认名称(目录)分隔符 windows:反斜杠(\) linux:正斜杠(/)
//工作中
String path = "d:\\a.txt";
System.out.println(path);//d:\a.txt
path = "d:"+File.separator+"a.txt";
System.out.println(path);//d:\a.txt
}
}
路径
/*
路径:找到计算机中文件和文件夹的路径
分类:
1.绝对路径:以盘符开始的路径
c:\\a.txt
d:\\aaa\\bbb\\ccc\\ddd
D:\\Work_idea\\EE128\\day14
2.相对路径:相当于当前项目的根目录而言,我们使用项目的根目录作为路径,可以省略书写
当前项目的根目录:D:\\Work_idea\\EE128
绝对路径:D:\\Work_idea\\EE128\\day10 D:\\Work_idea\\EE128\\a.txt
相对路径:可以省略项目的根目录 day10 a.txt
注意:
路径是不区分大小写的
在java程序中,也可以使用一个正斜杠(/)作为文件名称分隔符
如果要使用反斜杠(\)作为文件名称分隔符,需要写两个反斜杠(\\),一个反斜杠本身代表转义字符
D:\\Work_idea\\EE128\\day14
D:/Work_idea/EE128/day14
*/
File的构造方法(重点)
public class Demo02File {
public static void main(String[] args) {
//show02("d:","a.txt");//d:\a.txt
//show02("c:","a.txt");//c:\a.txt
show03();
}
/*
File类的构造方法:
File(File parent, String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
参数:把构造方法的参数分割为了两部分
File parent:父路径
String child:子路径
好处:
父路径和子路径可以分别使用不同的路径,组装为一个新的路径,使用起来更加灵活
父路径是File类型,可以使用File类中的方法对父路径进行一些操作,再和子路径组成一个新的File对象
*/
private static void show03() {
File parent = new File("d:");
File file = new File(parent,"a.txt");
System.out.println(file);//d:\a.txt
}
/*
File类的构造方法:
File(String parent, String child) 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
参数:把构造方法的参数分割为了两部分
String parent:父路径
String child:子路径
好处:
父路径和子路径可以分别使用不同的路径,组装为一个新的路径,使用起来更加灵活
*/
private static void show02(String parent, String child) {
File file = new File(parent,child);
System.out.println(file);
}
/*
File类的构造方法:
File(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
参数:
String pathname:创建文件|文件夹的路径
注意:
1.传递的路径可以是绝对路径,也可以是相对路径
2.传递的路径可以是以文件结尾的,也可以是以文件夹结尾
3.传递的路径可以是真实存在的,也可以是不存在的;构造方法仅仅是把字符串的路径,封装为File对象,不检查路径的真实情况
*/
private static void show01() {
File f1 = new File("c:\\a.txt");
System.out.println(f1);//c:\a.txt
File f2 = new File("d:\\aaa\\bbb\\ccc\\ddd");
System.out.println(f2);//d:\aaa\bbb\ccc\ddd
File f3 = new File("day14");
System.out.println(f3);//day14
}
}
File类的成员方法_获取功能的方法
/*
File类的成员方法_获取功能的方法
- public String getAbsolutePath() :返回此File的绝对路径名字符串。
- public String getPath() :将此File转换为路径名字符串。
- public String getName() :返回由此File表示的文件或目录的名称。
- public long length() :返回由此File表示的文件的长度。
*/
public class Demo03FileMethod {
public static void main(String[] args) {
show04();
}
/*
- public long length() :获取文件的大小,单位是字节
注意:
1.length方法只能获取文件的大小,不能获取文件夹的大小
2.length方法获取的文件如果不存在,那么返回0
*/
private static void show04() {
File f1 = new File("D:\\base\\20200112128\\day14\\daTest.java");
long l1 = f1.length();
System.out.println(l1);//6311 字节
File f2 = new File("c:\\afdsafa.txt");
System.out.println(f2.length());//0 字节
File f3 = new File("D:\\base\\20200112128\\day14");
System.out.println(f3.length());//4096 文件夹是没有大小概念的
File f4 = new File("D:\\base\\20200112128\\day14\\avi");
System.out.println(f4.length());//0 文件夹是没有大小概念的
}
/*
- public String getName() :获取构造方法中路径末尾的文件|文件夹的名称
*/
private static void show03() {
File f1 = new File("c:\\abc\\aaa\\a.txt");
System.out.println(f1.getName());//a.txt
File f2 = new File("c:\\abc\\aaa");
System.out.println(f2.getName());//aaa
File f3 = new File("day14\\abc\\b.jpg");
System.out.println(f3.getName());//b.jpg
}
/*
- public String getPath() :获取构造方法中传递的路径
File类重写了Object类中的toString方法
toString方法的源码:
public String toString() {
return getPath();
}
*/
private static void show02() {
File f1 = new File("c:\\aaa\\bbb\\ccc\\a.txt");
System.out.println(f1.getPath());//c:\aaa\bbb\ccc\a.txt
File f2 = new File("day14");
System.out.println(f2.getPath());//day14
System.out.println(f2.toString());//day14
}
/*
- public String getAbsolutePath() :获取构造方法中传递路径的绝对路径
- File getAbsoluteFile() 返回此抽象路径名的绝对路径名形式。
注意:
1.无论构造方法中传递的路径是相对的还是绝对的,返回的都是绝对路径
2.传递相对路径,会在路径的前边添加上项目的根目录(D:\\Work_idea\\EE128)
*/
private static void show01() {
File f1 = new File("c:\\aaa\\bbb\\ccc\\a.txt");
String a1 = f1.getAbsolutePath();
System.out.println(a1);//c:\aaa\bbb\ccc\a.txt
File f2 = new File("day14");
System.out.println(f2.getAbsolutePath());//D:\Wora\20201208128\day14
File a2 = f2.getAbsoluteFile();//返回的是文件类型,可以继续调用File中的方法
System.out.println(a2.exists());//true
}
}
文件夹的大小和文件的占用空间
File类的成员方法_判断功能的方法(重点)
.构造方法中的路径必须是存在的,才能判断是文件还是一个文件夹;否则没有意义,都会返回false
/*
File类的成员方法_判断功能的方法
- public boolean exists() :此File表示的文件或目录是否实际存在。
- public boolean isDirectory() :此File表示的是否为目录。
- public boolean isFile() :此File表示的是否为文件。
*/
public class Demo04FileMethod {
public static void main(String[] args) {
show02();
}
/*
- public boolean isFile():判断构造方法中传递的路径是一个以文件结尾的路径吗
是文件结尾:返回true
不是文件结尾:返回false
- public boolean isDirectory():判断构造方法中传递的路径是一个以文件夹结尾的路径吗
是文件夹结尾:返回true
不是文夹件结尾:返回false
注意:
1.构造方法中的路径必须是存在的,才能判断是文件还是一个文件夹;否则没有意义,都会返回false
2.计算机中只有文件和文件夹,所以两个方法互斥
*/
private static void show02() {
File f1 = new File("c:\\a.txt");//文件是不存在
//判断是文件还是文件夹之前,都会先判断路径是否存在
if(f1.exists()){
boolean b1 = f1.isFile();
System.out.println("b1:"+b1);//b1:false
boolean b2 = f1.isDirectory();
System.out.println("b2:"+b2);//b2:false
}
System.out.println("----------------------------");
File f2 = new File("day14");
if(f2.exists()){
boolean b1 = f2.isFile();
System.out.println("b1:"+b1);//b1:false
boolean b2 = f2.isDirectory();
System.out.println("b2:"+b2);//b2:true
}
System.out.println("----------------------------");
File f3 = new File("day14\\a.txt");
if(f3.exists()){
boolean b1 = f3.isFile();
System.out.println("b1:"+b1);//b1:true
boolean b2 = f3.isDirectory();
System.out.println("b2:"+b2);//b2:false
}
}
/*
- public boolean exists() :判断构造方法中的路径是否存在
存在:返回true
不存在:返回false
*/
private static void show01() {
File f1 = new File("c:\\a.txt");
System.out.println(f1.exists());//false
File f2 = new File("c:\\全球通史.txt");
System.out.println(f2.exists());//true
File f3 = new File("day14");//相对路径: D:\Work_idea\EE128\day14
System.out.println(f3.exists());//true
}
}
File类的成员方法_创建和删除功能(重点)
/*
File类的成员方法_创建删除功能的方法
- public boolean createNewFile() :当且仅当具有该名称的文件尚不存在时,创建一个新的空文件。
- public boolean delete() :删除由此File表示的文件或目录。
- public boolean mkdir() :创建由此File表示的目录。
- public boolean mkdirs() :创建由此File表示的目录,包括任何必需但不存在的父目录。
*/
public class Demo05FileMethod {
public static void main(String[] args) throws IOException {
show03();
}
/*
- public boolean delete() :删除构造方法中指定的文件或者文件夹
返回值:boolean
构造方法中路径存在,删除问价|文件夹,返回true
构造方法中路径不存在或者文件夹中有内容,不会删除,返回false
注意:
此删除方法不走回收站,直接在硬盘删除,需要谨慎
*/
private static void show03() {
File f1 = new File("day14\\a.txt");
System.out.println(f1.delete());
File f2 = new File("day14\\a");
System.out.println(f2.delete());
File f3 = new File("day14\\aaa");
System.out.println(f3.delete());//false 文件夹中有内容,不会删除
}
/*
- public boolean mkdir() :只能创建单级文件夹
- public boolean mkdirs():既能创建单级文件夹,又能创建多级文件夹
返回值:boolean
文件夹不存在,创建成功,返回true
文件夹存在,不会创建,返回false;构造方法中传递路径不存在,返回false
注意:
1.创建文件夹的路径和名称需要在构造方法中给出
2.此方法只能创建文件夹,不能创建文件
*/
private static void show02() {
File f1 = new File("day14\\a");
boolean b1 = f1.mkdir();
System.out.println("b1:"+b1);
File f2 = new File("day14\\aaa\\bbb\\ccc\\ddd\\eee\\fff");//多级文件夹
//boolean b2 = f2.mkdir();//b2:false 不能创建多级文件夹的
boolean b2 = f2.mkdirs();
System.out.println("b2:"+b2);
File f3 = new File("w:\\aaa");
System.out.println(f3.mkdir());//false 路径不存在'
File f4 = new File("day14\\c.txt");
System.out.println(f4.mkdir());//创建的是什么:文件夹名字叫c.txt
}
/*
- public boolean createNewFile() :当且仅当具有该名称的文件尚不存在时,创建一个新的空文件。
作用:用于创建一个新的空白文件
返回值:boolean
文件不存在,创建成功,返回true
文件存在,不会创建,返回false(不会覆盖)
注意:
1.此方法只能创建文件,不能创建文件夹
2.创建文件的路径和文件的名称在构造方法中给出
3.构造方法中写的路径必须是存在的,否则会抛出异常
4.有些操作系统,c盘是没有权限创建文件的,会抛出拒绝访问的异常
*/
private static void show01() throws IOException {
//File f1 = new File("e:\\aaaaaa.txt");//IOException: 系统找不到指定的路径。
//File f1 = new File("d:\\aaaa\\aaaaaa.txt");//IOException: 系统找不到指定的路径。
File f1 = new File("d:\\aaaaaa.txt");
boolean b1 = f1.createNewFile();
System.out.println("b1:"+b1);//b1:true
File f2 = new File("day14\\b.txt");
boolean b2 = f2.createNewFile();
System.out.println("b2:"+b2);
File f3 = new File("day14\\新建文件夹");
boolean b3 = f3.createNewFile();//创建的是什么:创建的就是一个文件,文件的名称叫"新建文件夹"
System.out.println("b3:"+b3);
}
}
File类的成员方法_目录遍历的方法(重点)
/*
File类的成员方法_目录遍历的方法
- public String[] list() :返回一个String数组,表示该File目录中的所有子文件或目录。
遍历目录(文件夹),获取目录中的每一个文件|文件夹的名称,把多个名称存储到一个String类型的数组中返回
- public File[] listFiles() :返回一个File数组,表示该File目录中的所有的子文件或目录。
遍历目录(文件夹),获取目录中每一个文件|文件夹,把文件|文件夹封装为File对象,多个File对象存储到一个File类型的数组中返回
注意:
1.遍历目录的路径,在构造方法中给出
2.遍历目录的路径必须是存在的,否则会抛出空指针异常
3.这两个方法只能遍历目录,不能遍历文件夹;如果要遍历文件,也会抛出空指针异常
*/
public class Demo06Method {
public static void main(String[] args) {
show02();
}
/*
- public File[] listFiles() :
遍历目录(文件夹),获取目录中每一个文件|文件夹,把文件|文件夹封装为File对象,多个File对象存储到一个File类型的数组中返回
*/
private static void show02() {
File file = new File("D:\\base\\20200112128\\day14");
//File file = new File("c:");
//File file = new File("D:\\base\\20200112128\\day14\\a.txt");//NullPointerException
//File file = new File("w:\\aaa");//NullPointerException
File[] files = file.listFiles();
for (File f : files) {
System.out.println(f);//调用的toString方法
}
}
/*
- public String[] list() :
遍历目录(文件夹),获取目录中的每一个文件|文件夹的名称,把多个名称存储到一个String类型的数组中返回
*/
private static void show01() {
File file = new File("D:\\base\\20200112128\\day14");
String[] arr = file.list();
for (String fileName : arr) {
System.out.println(fileName);
}
}
}
递归
递归概述
递归的注意事项:
1.递归必须有结束条件,否则会抛出内存异常的错误
2.递归有结束的条件,但是递归的次数不能太多,否则也会抛出内存溢出的错误
3.构造方法禁止递归
什么时候使用递归:
当我们频繁的调用某一个方法,方法的主体不变,每次调用的参数改变,就可以使用递归
/*
递归:方法自己调用自己
递归分类:
1.直接递归:
public void a(){
a();
}
2.间接递归:
public void a(){
b();
}
public void b(){
a();
}
递归的注意事项:
1.递归必须有结束条件,否则会抛出内存异常的错误
2.递归有结束的条件,但是递归的次数不能太多,否则也会抛出内存溢出的错误
3.构造方法禁止递归
什么时候使用递归:
当我们频繁的调用某一个方法,方法的主体不变,每次调用的参数改变,就可以使用递归
*/
public class Demo01Recursion {
public static void main(String[] args) {
//a();
b(1);
}
/*
3.构造方法禁止递归
构造方法是创建对象使用的,递归掉用自己,在内存会一直创建无数个对象
*/
public Demo01Recursion() {
//Demo01Recursion();
}
/*
2.递归有结束的条件,但是递归的次数不能太多,否则也会抛出内存溢出的错误
11402,11415
Exception in thread "main" java.lang.StackOverflowError
*/
private static void b(int i) {//1,2,3,4,5....
System.out.println(i);
if(i==20000){
return;//结束方法
}
b(++i);//递归调用自己,每次把变量i的值加1
}
/*
1.递归必须有结束条件,否则会抛出内存异常的错误
Exception in thread "main" java.lang.StackOverflowError
*/
private static void a() {
System.out.println("a方法!");
a();
}
}
练习:使用递归计算1-n的和
/*
练习:使用递归计算1-n的和
递归就是方法自己调用自己,需要定义一个方法,自己调用自己求和
*/
public class Demo02Recursion {
public static void main(String[] args) {
int s = sum(3);
System.out.println("s:"+s);
}
/*
定义一个计算1-n和的方法
1-n的和就是n-1的和
n+(n-1)+(n-2)+(n-3)+...+1
已知:
n:10,100,1000...
1
未知:
n-1
递归的目的:获取下一个被加的数字n-1
递归结束的条件:当获取n-1==1的时候,结束获取
*/
public static int sum(int n){//10,9,8,7,6,...1
//递归结束的条件:当获取n-1==1的时候,结束获取
if(n==1){
return 1;
}
//递归的目的:获取下一个被加的数字n-1
return n+sum(n-1);
}
}
练习:使用递归求阶乘
/*
练习:递归求阶乘
n的阶乘:n! = n * (n-1) *...* 3 * 2 * 1
5! = 5*4*3*2*1
*/
public class Demo03Recursion {
public static void main(String[] args) {
int jieCheng = jc(5);
System.out.println(jieCheng);//120
}
/*
定义一个计算阶乘的方法
已知:
n:5,10,100
1
未知:
n-1
递归的目的:获取下一个被乘的数字n-1
递归结束的条件:获取n-1==1的时候结束
*/
public static int jc(int n){
//递归结束的条件:获取n-1==1的时候结束
if(n==1){
return 1;
}
//递归的目的:获取下一个被乘的数字n-1
return n*jc(n-1);
}
}
练习:使用递归遍历文件夹和文件夹的子文件夹
/*
练习:使用递归遍历文件夹和文件夹中的子文件夹
d:\\aaa
d:\\aaa\\aaa.java
d:\\aaa\\aaa.txt
d:\\aaa\\a
d:\\aaa\\a\\a.java
d:\\aaa\\a\\a.jpg
d:\\aaa\\b
d:\\aaa\\b\\B.JAVA
d:\\aaa\\b\\b.avi
*/
public class Demo04Recursion {
public static void main(String[] args) {
File file = new File("d:\\aaa");
getAllFile(file);
}
/*
定义一个方法,参数传递要遍历的文件夹
方法的内部对文件夹进行遍历
*/
public static void getAllFile(File dir){
System.out.println(dir);//打印要遍历的文件夹
File[] files = dir.listFiles();
for (File f : files) {
//判断遍历得到的f,是否为一个文件夹
if(f.isDirectory()){
//f是一个文件夹,继续遍历这个文件夹
//而我们发现getAllFile方法,就是一个传递文件夹,遍历文件夹的方法
//调用getAllFile方法,传递要遍历的文件夹即可(a,b)
getAllFile(f);//方法自己调用自己==>递归
}else{
//f就是一个文件,打印==>toString方法
System.out.println(f);
}
}
}
}
练习:文件搜索
/*
练习:文件搜索
使用递归遍历文件夹和文件夹中的子文件夹
只打印以.java结尾的文件
d:\\aaa
d:\\aaa\\aaa.java
d:\\aaa\\aaa.txt
d:\\aaa\\a
d:\\aaa\\a\\a.java
d:\\aaa\\a\\a.jpg
d:\\aaa\\b
d:\\aaa\\b\\B.JAVA
d:\\aaa\\b\\b.avi
*/
public class Demo05Recursion {
public static void main(String[] args) {
File file = new File("d:\\aaa");
getAllFile(file);
}
/*
定义一个方法,参数传递要遍历的文件夹
方法的内部对文件夹进行遍历
*/
public static void getAllFile(File dir){
File[] files = dir.listFiles();
for (File f : files) {
//判断遍历得到的f,是否为一个文件夹
if(f.isDirectory()){
//f是一个文件夹,继续遍历这个文件夹
//而我们发现getAllFile方法,就是一个传递文件夹,遍历文件夹的方法
//调用getAllFile方法,传递要遍历的文件夹即可(a,b)
getAllFile(f);//方法自己调用自己==>递归
}else{
/*
需求:只打印以.java结尾的文件
解决:
判断f是否是一个以.java结尾的文件,是则打印
实现步骤:
1.把f对象(File对象)转换为String
a==>f.toString() "d:\aaa\aaa.java"
b==>f.getPath() "d:\aaa\aaa.java"
c==>f.getName() "aaa.java"
2.使用String类中的方法endsWith判断字符串是否以.java结尾
3.是.java结尾则打印
*/
/*String name = f.getName();//B.JAVA
String s = name.toLowerCase();//b.java
boolean b = s.endsWith(".java");
if(b){
System.out.println(f);
}*/
if(f.getName().toLowerCase().endsWith(".java")){
System.out.println(f);
}
}
}
}
}