File类、递归

一、File 类的使用

• java.io.File类：文件和文件目录路径的抽象表示形式，与平台无关。
• File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。 如果需要访问文件内容本身，则需要使用输入/输出流。
• 想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。
• File对象可以作为参数传递给流的构造器。

1.1 常用构造器

 1.1.1 绝对路径 vs 相对路径

• public File(String pathname)    以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。

        绝对路径：是一个固定的路径, 从盘符开始。

        相对路径：是相对于某个位置开始。

• public File(String parent,String child)    以parent为父路径，child为子路径创建File对象。
• public File(File parent,String child)    根据一个父File对象和子文件路径创建File对象。

package com.hp.test3;

import java.io.File;

public class FileTest01 {
    public static void main(String[] args) {
        //File对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径
        //这个路径可以是存在的，也允许是不存在的

        /**
         * public File(string pathname)    根据文件路径创建文件对象
         * public File(string parent,string child)    根据父路径名字符串和子路径名字符串创建文件对象
         * public File(File parent,String child)  根据父路径对应文件对象和子路径名字符串创建文件对象
         *
         * "C:\Users\chenge\Desktop\work\a.txt"
         * \:转义字符
         * \\:分隔符
         * window：\
         *
         */

        //1.根据字符串路径创建File对象
        String str = "C:\\Users\\chenge\\Desktop\\work\\a.txt";
        File f1 = new File(str);
        System.out.println(f1);

        //2.父路径:C:\Users\chenge\Desktop\work\
        //子路径:a.txt

        String s1 = "C:\\Users\\chenge\\Desktop\\work";
        String s2 = "a.txt";
        File f2 = new File(s1,s2);
        System.out.println(f2);

        //3.把一个File对象和一个String字符串进行拼接
        File f3 = new File("C:\\Users\\chenge\\Desktop\\work");
        String s3 = "a.txt";
        File f4 = new File(f3,s3);
        System.out.println(f4);

    }
}

运行结果：  

1.2 路径分隔符

• 路径中的每级目录之间用一个路径分隔符隔开。
• 路径分隔符和系统有关：
•         windows和DOS系统默认使用"\"来表示。
•         UNIX和URL使用"/"来表示。
• Java程序支持跨平台运行，因此路径分隔符要慎用。
• 为了解决这个隐患，File类提供了一个常量：public static final String separator。根据操作系统，动态的提供分隔符。
• 举例：

File f3 = new File("C:\\Users\\chenge\\Desktop\\work");

1.3 常用方法

package com.hp.test3;

import java.io.File;

public class FileTest03 {
    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: 这个方法无法获取文件夹的大小
        // 如果我们要获取一个文件夹的大小，需要把这个文件夹里面所有的文件大小都累加在一起。
        File f1 = new File("C:\\Users\\chenge\\Desktop\\work\\a.txt");
        long l1 = f1.length();
        System.out.println(l1);//6

        File f2 = new File("C:\\Users\\chenge\\Desktop\\work\\bbb");
        long l2 = f2.length();
        System.out.println(l2);//0
        System.out.println("==========================");

        //2.getAbsolutePath  返回文件的绝对路径
        File f3 = new File("C:\\Users\\chenge\\Desktop\\work\\a.txt");
        String path1 = f3.getAbsolutePath();
        System.out.println(path1);//C:\Users\chenge\Desktop\work\a.txt

        File f4 = new File("Day11-28\\a.txt");
        String path2 = f4.getAbsolutePath();
        System.out.println(path2);//D:\Software\Software IDEA\Demo\a.txt
        System.out.println("==============================");

        //3.getPath  返回定义文件时使用的路径
        File f5 = new File("C:\\Users\\chenge\\Desktop\\work\\a.txt");
        String path3 = f5.getPath();
        System.out.println(path3);//C:\Users\chenge\Desktop\work\a.txt

        File f6 = new File("Day11-28\\a.txt");
        String path4 = f6.getPath();
        System.out.println(path4);//Day11-28\a.txt
        System.out.println("=========================");

        //4.getName 获取名字
        //细节1:
        //a.txt:
        //  a 文件名
        //  txt 后缀名、扩展名
        //细节2:
        //文件夹: 返回的就是文件夹的名字
        File f7 = new File( "C:\\Users\\chenge\\Desktop\\work\\a.txt");
        String name1 = f7.getName();
        System.out.println(name1);//a.txt

        File f8 = new File( "C:\\Users\\chenge\\Desktop\\work\\bbb");
        String name2 = f8.getName();
        System.out.println(name2);//bbb
        System.out.println("==============================");

        //5.lastModified 返回文件的最后修改时间(时间毫秒值)
        File f9 = new File("C:\\Users\\chenge\\Desktop\\work\\a.txt");
        long l3 = f9.lastModified();
        System.out.println(l3);

    }
}

运行结果： 

1.4

 

package com.hp.test3;

import java.io.File;

public class FileTest02 {
    public static void main(String[] args) {
        /**
         * 返回布尔类型
         * public boolean isDirectory()判断此路径名表示的File是否为文件夹
         *  public boolean isFile()判断此路径名表示的File是否为文件
         *   public boolean exists()判断此路径名表示的File是否存在
         */


        //1.对一个文件的路径进行判断
        File f1 = new File("C:\\Users\\chenge\\Desktop\\work\\a.txt");
        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("C:\\Users\\chenge\\Desktop\\work\\bbb");
        System.out.println(f2.isDirectory());//true
        System.out.println(f2.isFile());//false
        System.out.println(f2.exists());//true

        System.out.println("----------------------");

        //1.对一个不存在的路径进行判断
        File f3 = new File("C:\\Users\\chenge\\Desktop\\work\\b.txt");
        System.out.println(f3.isDirectory());//false
        System.out.println(f3.isFile());//false
        System.out.println(f3.exists());//false
    }
}

运行结果： 

 

package com.hp.test3;

import java.io.File;
import java.io.IOException;

public class FileTest04 {
    public static void main(String[] args) throws IOException {
        /**
         * public boolean createNewFile()  创建一个新的空的文件
         * public boolean mkdir()  创建单级文件夹
         * public boolean mkdirs()  创建多级文件夹
         * public boolean delete()  删除文件、空文件夹
         *
         */

        //1.createNewFile 创建一个新的空的文件
        //细节1: 如果当前路径表示的文件是不存在的，则创建成功，方法返回true
        //      如果当前路径表示的文件是存在的，则创建失败，方法返回false
        //细节2: 如果父级路径是不存在的，那么方法会有异常IOException
        //细节3:createNewFile方法创建的一定是文件，如果路径中不包含后缀名，则创建一个没有后缀的文件
        File f1 = new File("C:\\Users\\chenge\\Desktop\\work\\b.txt");
        boolean b1 = f1.createNewFile();
        System.out.println(b1);

        //2.mkdir  创建单级文件夹 make Directory，文件夹(目录)
        //细节1: windows当中路径是唯一的，如果当前路径已经存在，则创建失败，返回false
        // 细节2: mkdir方法只能创建单级文件夹，无法创建多级文件夹。
        File f2 = new File("C:\\Users\\chenge\\Desktop\\work\\ddd");
        boolean b2 = f2.mkdir();
        System.out.println(b2);

        //3.mkdirs   创建多级文件夹
        //细节: 既可以创建单级的，又可以创建多级的文件夹
        File f3 = new File("C:\\Users\\chenge\\Desktop\\work\\ccc\\aaa\\cg");
        boolean b3 = f3.mkdirs();
        System.out.println(b3);


    }
}

package com.hp.test3;

import java.io.File;

public class FileTest05 {
    public static void main(String[] args) {
        //delete 删除文件、空文件夹
        //细节:
        //如果删除的是文件，则直接删除，不走回收站。
        // 如果删除的是空文件夹，则直接删除，不走回收站
        // 如果删除的是有内容的文件夹，则删除失败

        File f1 = new File("C:\\Users\\chenge\\Desktop\\work\\c.txt");
        boolean d = f1.delete();
        System.out.println(d);

    }
}

我们只用掌握这些方法是怎么用的就行。

1.4 目录的遍历

• public string[] ist() : 返回一个String数组，表示该File目录中的所有子文件或目录
• public File[] listFiles() : 返回一个File数组，表示该File目录中的所有的子文件或目录

package com.hp;

import java.io.File;
import java.util.Arrays;

public class FileTest01 {
    public static void main(String[] args) {
        File f1=new File( "C:\\Users\\chenge\\Desktop\\work");
        String[] list = f1.list(); //获取文件夹中所有的 子目录 或 文件 的名字数组
        System.out.println(Arrays.toString(list));

        File[] files = f1.listFiles(); 获取文件夹中所有的 子目录 或 文件 的FiLe对象数组
        System.out.println(Arrays.toString(files));

        for (int i = 0; i < files.length; i++) {
            File temp = files[i];
            if (temp.isDirectory()) {
                File[] files1 = temp.listFiles();
                System.out.println(Arrays.toString(files1));
            }
        }
    }
}

运行结果：

这种方法只能获取少量的多级文件夹，如果多级文件夹套的多了我们就要使用递归了。

1.5 递归

递归，在数学与计算机科学中，是指在方法的定义中使用方法自身。也就是说，递归算法是一种直接或者间接调用自身方法的算法。简言之：在定义自身的同时又出现自身的直接或间接调用。

注意：递归必须要有一个退出的条件!

 递归算法解决问题的特点：
1）递归就是方法里调用自身。
2）在使用递增归策略时，必须有一个明确的递归结束条件，称为递归出口。
3）递归算法解题通常显得很简洁，但递归算法解题的运行效率较低。所以一般不提倡用递归算法设计程序。
4）在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等，所以一般不提倡用递归算法设计程序。

在做递归算法的时候，一定要把握住出口，也就是做递归算法必须要有一个明确的递归结束条件。这一点是非常重要的。

其实这个出口是非常好理解的，就是一个条件，当满足了这个条件的时候我们就不再递归了。

package com.hp;

public class DiGui {

    public static void main(String[] args) {

        //递归----复杂算法
        System.out.println("-----1------");
        System.out.println("-----2------");
        int count= 0;
        fun(count);
        System.out.println("-----3------");
        System.out.println("-----4------");
    }

    //方法中自己调用自己叫做递归  递(有条件的递)  归(某个时刻不在调用自己，进行方法返回)
    public static void  fun(int count){
        count++;
        System.out.println("-----1.1------");
        System.out.println("-----2.2------");
        if (count<3){
            fun(count);
        }
        System.out.println("-----3.3------");
        System.out.println("-----4.4------");
    }
}

运行结果：

    递归实现打印输出1-n 

先虚构方法可以完成什么事，把核心业务写出来，在分析后续的规律

package com.hp;

public class DiGuiTest {
    public static void main(String[] args) {
        print(10);

        int he = sam(2);
        System.out.println(he);
    }
    /**
     * 递归实现打印输出1-n   先虚构方法可以完成什么事，把核心业务写出来，在分析后续的规律
     */
    public static void print(int n){
        System.out.println(n);//n
        if (n>0){
            print(n-1);//1 - (n-1)
        }
    }
    public  static  int  sam(int n){
        int sum=0;
        sum=sum+n;//累加n
        if (n>0){
            sum=sum+sam(n-1);//累加1-(n-1)
        }
    return sum;
    }

}

运行结果：