【黑马java基础】IO流

File

数据想长久保存起来。

文件是非常重要的存储方式，在计算机硬盘中

File是java.io.包下的类， File类的对象，用于代表当前操作系统的文件（可以是文件、或文件夹）。

注意：File类只能对文件本身进行操作，不能读写文件里面存储的数据。

那么什么可以读取文件中存储的数据呢？IO流

用于读写数据的（可以读写文件，或网络中的数据…）

file代表文本

IO流读写数据

创建对象

创建File类的对象

构造器	说明
public File(String pathname)	根据文件路径创建文件对象
public File(String parent, String child)	根据父路径和子路径名字创建文件对象
public File(File parent, String child)	根据父路径对应文件对象和子路径名字创建文件对象

需要注意的是：
    - 路径中"\"要写成"\\"， 路径中"/"可以直接用
    - File对象既可以代表文件、也可以代表文件夹。
    - File封装的对象仅仅是一个路径名，这个路径可以是存在的，也允许是不存在的。

public class FileTest1 {
   
   
    public static void main(String[] args) {
   
   
        // 1、创建一个File对象，指代某个具体的文件。
        // 路径分隔符
        // File f1 = new File("D:/resource/ab.txt");
        // File f1 = new File("D:\\resource\\ab.txt");
        File f1 = new File("D:" + File.separator +"resource" + File.separator + "ab.txt");
        System.out.println(f1.length()); // 文件大小

        File f2 = new File("D:/resource");
        System.out.println(f2.length());

        // 注意：File对象可以指代一个不存在的文件路径
        File f3 = new File("D:/resource/aaaa.txt");
        System.out.println(f3.length());   //0
        System.out.println(f3.exists()); // false

        // 我现在要定位的文件是在模块中，应该怎么定位呢？
        // 绝对路径：带盘符的
        // File f4 = new File("D:\\code\\javasepromax\\file-io-app\\src\\itheima.txt");
        // 相对路径（重点）：不带盘符，默认是直接去工程下寻找文件的。
        File f4 = new File("file-io-app\\src\\itheima.txt");
        System.out.println(f4.length());
    }
}

常用方法1：判断文件类型、获取文件信息

File提供的判断文件类型、获取文件信息功能

方法名称	说明
public boolean exists()	判断当前文件对象，对应的文件路径是否存在，存在返回true
public boolean isFile()	判断当前文件对象指代的是否是文件，是文件返回true，反之。
public boolean isDirectory()	判断当前文件对象指代的是否是文件夹，是文件夹返回true，反之。
public String getName()	获取文件的名称（包含后缀）
public long length()	获取文件的大小，返回字节个数
public long lastModified()	获取文件的最后修改时间。
public String getPath()	获取创建文件对象时，使用的路径
public String getAbsolutePath()	获取绝对路径

public class FileTest2 {
   
   
    public static void main(String[] args) throws UnsupportedEncodingException {
   
   
        // 1.创建文件对象，指代某个文件
        File f1 = new File("D:/resource/ab.txt");
        //File f1 = new File("D:/resource/");

        // 2、public boolean exists()：判断当前文件对象，对应的文件路径是否存在，存在返回true.
        System.out.println(f1.exists());

        // 3、public boolean isFile() : 判断当前文件对象指代的是否是文件，是文件返回true，反之。
        System.out.println(f1.isFile());

        // 4、public boolean isDirectory()  : 判断当前文件对象指代的是否是文件夹，是文件夹返回true，反之。
        System.out.println(f1.isDirectory());

        // 5.public String getName()：获取文件的名称（包含后缀）
        System.out.println(f1.getName());

        // 6.public long length()：获取文件的大小，返回字节个数
        System.out.println(f1.length());

        // 7.public long lastModified()：获取文件的最后修改时间。
        long time = f1.lastModified();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        System.out.println(sdf.format(time));

        // 8.public String getPath()：获取创建文件对象时，使用的路径
        File f2 = new File("D:\\resource\\ab.txt");
        File f3 = new File("file-io-app\\src\\itheima.txt");
        System.out.println(f2.getPath());
        System.out.println(f3.getPath());

        // 9.public String getAbsolutePath()：获取绝对路径
        System.out.println(f2.getAbsolutePath());
        System.out.println(f3.getAbsolutePath());
    }
}

常用方法2：创建文件、删除文件

• File类创建文件的功能

方法名称	说明
public boolean createNewFile()	创建一个新的空的文件
public boolean mkdir()	只能创建一级文件夹
public boolean mkdirs()	可以创建多级文件夹

• File类删除文件的功能

方法名称	说明
public boolean delete()	删除文件、空文件夹

注意：delete方法默认只能删除文件和空文件夹，删除后的文件不会进入回收站。

public class FileTest3 {
   
   
    public static void main(String[] args) throws Exception {
   
   
        // 1、public boolean createNewFile()：创建一个新文件（文件内容为空），创建成功返回true,反之。
        File f1 = new File("D:/resource/itheima2.txt");
        System.out.println(f1.createNewFile());

        // 2、public boolean mkdir()：用于创建文件夹，注意：只能创建一级文件夹
        File f2 = new File("D:/resource/aaa");
        File f22 = new File("D:/resource/aaa/bbb/ccc"); //false，因为这是三级文件夹了
        System.out.println(f2.mkdir());

        // 3、public boolean mkdirs()：用于创建文件夹，注意：可以创建多级文件夹
        File f3 = new File("D:/resource/bbb/ccc/ddd/eee/fff/ggg");
        System.out.println(f3.mkdirs());

        // 3、public boolean delete()：删除文件，或者空文件，注意：不能删除非空文件夹。
        System.out.println(f1.delete());  //true
        System.out.println(f2.delete());  //true
        File f4 = new File("D:/resource");
        System.out.println(f4.delete());  //false
    }
}

常用方法3：遍历文件夹

File类提供的遍历文件夹的功能

方法名称	说明
public String[] list()	获取当前目录下所有的"一级文件名称"到一个字符串数组中去返回。
public File[] listFiles()	获取当前目录下所有的"一级文件对象"到一个文件对象数组中去返回（重点）

使用listFiles方法时的注意事项：

• 当主调是文件，或者路径不存在时，返回null
• 当主调是空文件夹时，返回一个长度为0的数组
• 当主调是一个有内容的文件夹时，将里面所有一级文件和文件夹的路径放在File数组中返回
• 当主调是一个文件夹，且里面有隐藏文件时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏文件
• 当主调是一个文件夹，但是没有权限访问该文件夹时，返回null

/**
 * 目标：掌握File提供的遍历文件夹的方法。
 */
public class FileTest4 {
   
   
    public static void main(String[] args) {
   
   
        // 1、public String[] list()：获取当前目录下所有的"一级文件名称"到一个字符串数组中去返回。
        File f1 = new File("D:\\course\\待研发内容");
        String[] names = f1.list();
        for (String name : names) {
   
   
            System.out.println(name);
        }

        // 2、public File[] listFiles():（重点）获取当前目录下所有的"一级文件对象"到一个文件对象数组中去返回（重点）
        File[] files = f1.listFiles();
        for (File file : files) {
   
   
            System.out.println(file.getAbsolutePath());
        }

        File f = new File("D:/resource/aaa");
        File[] files1 = f.listFiles();
        System.out.println(Arrays.toString(files1));
    }
}

前置：方法递归

认识递归的形式

什么是方法递归？

• 递归是一种算法，在程序设计语言中广泛应用。
• 从形式上说：方法调用自身的形式称为方法递归（ recursion）。

递归的形式

• 直接递归：方法自己调用自己。
• 间接递归：方法调用其他方法，其他方法又回调方法自己。

使用方法递归时需要注意的问题：

递归如果没有控制好终止，会出现递归死循环，导致栈内存溢出错误。

/**
 * 目标：认识一下递归的形式。
 */
public class RecursionTest1 {
   
   
    public static void main(String[] args) {
   
   
        test1();
    }

    // 直接方法递归
    public static void test1(){
   
   
        System.out.println("----test1---");
        test1(); // 直接方法递归
    }

    // 间接方法递归
    public static void test2(){
   
   
        System.out.println("---test2---");
        test3();
    }

    public static void test3(){
   
   
        test2(); // 间接递归
    }
}

如果直接执行上面的代码，会进入死循环，最终导致栈内存溢出

应用、执行流程、算法思想

案例需求：计算n的阶乘，比如5的阶乘 = 1 * 2 * 3 * 4 * 5 ； 6 的阶乘 = 1 * 2 * 3 * 4 * 5 * 6

分析需求用递归该怎么做

假设f(n)表示n的阶乘，那么我们可以推导出下面的式子
	f(5) = 1+2+3+4+5
    f(5) = f(4)+5
    f(4) = f(3)+4
    f(3) = f(2)+3
    f(2) = f(1)+2
    f(1) = 1
总结规律：
	除了f(1) = 1; 出口
	其他的f(n) = f(n-1)+n

我们可以把f(n)当做一个方法，那么方法的写法如下

/**
 * 目标：掌握递归的应用，执行流程和算法思想。
 */
public class RecursionTest2 {
   
   
    public static void main(String[] args) {
   
   
        System.out.println("5的阶乘是：" + f(5));
    }

    //求n个数的阶乘
    public static int f(int n){
   
   
        // 终结点
        if(n == 1){
   
   
            return 1;
        }else {
   
   
            return f(n - 1) * n;
        }
    }
}

这个代码的执行流程，我们用内存图的形式来分析一下，该案例中递归调用的特点是：一层一层调用，再一层一层往回返。

啤酒问题

其他应用：文件搜索

案例需求：在D:\\判断下搜索QQ.exe这个文件，然后直接输出。

1.先调用文件夹的listFiles方法，获取文件夹的一级内容，得到一个数组
2.然后再遍历数组，获取数组中的File对象
3.因为File对象可能是文件也可能是文件夹，所以接下来就需要判断
  判断File对象如果是文件，就获取文件名，如果文件名是`QQ.exe`则打印，否则不打印
  判断File对象如果是文件夹，就递归执行1,2,3步骤
所以：把1，2，3步骤写成方法，递归调用即可。

代码如下：

/**
 * 目标：掌握文件搜索的实现。
 */
public class RecursionTest3 {
   
   
    public static void main(String[] args) throws Exception {
   
   
          searchFile(new File("D:/") , "QQ.exe");
    }

    /**
     * 去目录下搜索某个文件
     * @param dir  目录
     * @param fileName 要搜索的文件名称
     */
    public static void searchFile(File dir, String fileName) throws Exception {
   
   
        // 1、把非法的情况都拦截住
        if(dir == null || !dir.exists() || dir.isFile()){
   
   
            return; // 代表无法搜索
        }

        // 2、dir不是null,存在，一定是目录对象。
        // 获取当前目录下的全部一级文件对象。
        File[] files = dir.listFiles();

        // 3、判断当前目录下是否存在一级文件对象，以及是否可以拿到一级文件对象。
        if(files != null && files.length > 0){
   
   
            // 4、遍历全部一级文件对象。
            for (File f : files) {
   
   
                // 5、判断文件是否是文件,还是文件夹
                if(f.isFile()){
   
   
                    // 是文件，判断这个文件名是否是我们要找的
                    if(f.getName().contains(fileName)){
   
   
                        System.out.println("找到了：" + f.getAbsolutePath<