标签：复习 递归 System 文件夹 File println public out

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);
                }
            }
        }
    }
}

标签：复习,递归,System,文件夹,File,println,public,out
来源： https://blog.csdn.net/m0_48811221/article/details/119301939

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。