JavaSE进阶09：Stream流、File类

系列文章目录

JavaSE进阶01：继承、修饰符
JavaSE进阶02：多态、抽象类、接口
JavaSE进阶03：内部类、Lambda表达式
JavaSE进阶04：API中常用工具类
JavaSE进阶05：包装类、递归、数组的高级操作、异常
JavaSE进阶06：Collection集合、迭代器、List、ArrayList、LinkedList
JavaSE进阶07：泛型、Set集合、TreeSet、二叉树、红黑树
JavaSE进阶08：HashSet、Map集合、HashMap、TreeMap、可变参数、不可变集合
JavaSE进阶09：Stream流、File类
JavaSE进阶10：IO流、字节流、字节缓冲流
JavaSE进阶11：字符流、字符缓冲流、转换流、对象操作流、Properties集合
JavaSE进阶12：多线程、线程同步、线程池
JavaSE进阶13：网络编程入门、UDP通信程序、TCP通信程序、日志、枚举
JavaSE进阶14：类加载器、反射
JavaSE进阶15：XML、注解、单元测试
JavaSE进阶扩充：JDK8 HashMap底层分析（了解）
JavaSE进阶扩充：JDK8 ArrayList线程安全问题和源码分析、集合常见面试题
Java进阶作业

---

---

1.Stream流

1.1Stream流概述【理解】

• Stream流的好处

  • 直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：获取流、过滤姓张、过滤长度为3、逐一打印
  • Stream流把真正的函数式编程风格引入到Java中
  • 代码简洁

• Stream流的思想
  

• Stream流的三类方法

  • 获取Stream流
    • 创建一条流水线,并把数据放到流水线上准备进行操作
  • 中间方法
    • 流水线上的操作
    • 一次操作完毕之后,还可以继续进行其他操作
  • 终结方法
    • 一个Stream流只能有一个终结方法
    • 是流水线上的最后一个操作

• 案例需求

  按照下面的要求完成集合的创建和遍历

  • 创建一个集合，存储多个字符串元素
  • 把集合中所有以"张"开头的元素存储到一个新的集合
  • 把"张"开头的集合中的长度为3的元素存储到一个新的集合
  • 遍历上一步得到的集合

• 原始方式示例代码

import java.util.*;
public class MyStream1 {
    public static void main(String[] args) {
        //集合的批量添加
        ArrayList<String> list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"));
        //list.add()

        //遍历list1把以张开头的元素添加到list2中。
        ArrayList<String> list2 = new ArrayList<>();
        for (String s : list1) {
            if(s.startsWith("张")){
                list2.add(s);
            }
        }
        //遍历list2集合，把其中长度为3的元素，再添加到list3中。
        ArrayList<String> list3 = new ArrayList<>();
        for (String s : list2) {
            if(s.length() == 3){
                list3.add(s);
            }
        }
        for (String s : list3) {
            System.out.println(s);
        }
    }
}
/*
张三丰
张无忌
张翠山
 */

• 使用Stream流示例代码

package Stream;

import java.util.ArrayList;
import java.util.List;

public class StreamDemo {
    public static void main(String[] args) {
        //集合的批量添加
        ArrayList<String> list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"));

        //Stream流
        list1.stream().filter(s->s.startsWith("张"))
                .filter(s->s.length() == 3)
                .forEach(s-> System.out.println(s));
    }
}
/*
张三丰
张无忌
张翠山
 */

1.2Stream流的常见生成方式【应用】

• 生成Stream流的方式

  • Collection体系单列集合

    使用默认方法stream()生成流。
    集合对象.stream();

  • Map体系双列集合

    把Map转成Set集合，间接的生成流。
    集合对象.keySet().steam(); 所有键放入流
    集合对象.values().stream(); 所有值放入流
    集合对象.entrySet().stream(); 所有键值对放入流

  • 数组

    通过Arrays中的静态方法stream生成流。
    Arrays.stream(数组名);

  • 同种数据类型的多个数据

    通过Stream接口的静态方法of(T… values)生成流
    Stream.of(数据1,数据2,数据3…);

package Stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.stream.Stream;

public class MyStream1 {
    public static void main(String[] args) {
        method1();//单列集合
        method2();//双列集合
        method3();//数组
        method4();//同种数据类型的多个数据

    }

    private static void method4() {
        System.out.println("--------同种数据类型的多个数据放入流----------");
        Stream.of(1.1,2.2,3.3,4.4).forEach(s-> System.out.println(s));
    }

    private static void method3() {
        System.out.println("--------数组放入流----------");
        int [] arr = {1,2,3};
        Arrays.stream(arr).forEach(s-> System.out.println(s));
    }

    private static void method2() {
        HashMap<String,Integer> hm = new HashMap<>();
        hm.put("zhangsan",23);
        hm.put("lisi",24);
        hm.put("wangwu",25);
        hm.put("zhaoliu",26);
        hm.put("qianqi",27);

        //双列集合不能直接获取Stream流

        System.out.println("---------所有键放入流---------");
        //方式1：keySet。先获取到所有的键，再把这个Set集合中所有的键放到Stream流中。
        hm.keySet().stream().forEach(s-> System.out.println(s));

        System.out.println("---------所有值放入流---------");
        //方式2：entrySet。先获取到所有的值，再把这个Collection集合中所有的值放到Stream流中。
        hm.values().stream().forEach(s-> System.out.println(s));

        System.out.println("--------所有键值对放入流----------");
        //方式3：entrySet。先获取到所有的键值对对象，再把这个Set集合中所有的键值对对象放到Stream流中。
        hm.entrySet().stream().forEach(s-> System.out.println(s));


    }

    private static void method1() {
        System.out.println("--------单列集合放入流----------");
        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

//        Stream<String> stream = list.stream();
//        stream.forEach(s-> System.out.println(s));
        list.stream().forEach(s-> System.out.println(s));
    }
}
/*
--------单列集合放入流----------
aaa
bbb
ccc
---------所有键放入流---------
lisi
qianqi
zhaoliu
zhangsan
wangwu
---------所有值放入流---------
24
27
26
23
25
--------所有键值对放入流----------
lisi=24
qianqi=27
zhaoliu=26
zhangsan=23
wangwu=25
--------数组放入流----------
1
2
3
--------同种数据类型的多个数据放入流----------
1.1
2.2
3.3
4.4
 */

1.3Stream流中间操作方法【应用】

• 概念

  中间操作的意思是,执行完此方法之后,Stream流依然可以继续执行其他操作

• 常见方法

  方法名	说明
  Stream filter(Predicate predicate)	用于对流中的数据进行过滤
  Stream limit(long maxSize)	返回此流中的元素组成的流，截取前指定参数个数的数据
  Stream skip(long n)	跳过指定参数个数的数据，返回由该流的剩余元素组成的流
  static Stream concat(Stream a, Stream b)	合并a和b两个流为一个流
  Stream distinct()	返回由该流的不同元素（根据Object.equals(Object) ）组成的流

• filter代码演示

import java.util.ArrayList;
import java.util.function.Predicate;

public class Demo02 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("张三丰");
        arrayList.add("张无忌");
        arrayList.add("野原新之助");
        arrayList.add("王二麻子");
        arrayList.add("张良");

        //Stream<T> filter(Predicate<? super T> predicate);
        /*
        filter方法是获取流中的每一个数据
        test方法中的s,就依次表示流中的每一个数据，如果判断的结果为true,就留下当前数据。为false,就不留。
         */
		//匿名内部类完整格式
        arrayList.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                boolean result = s.length() == 4;
                return result;
            }
        }).forEach(s -> System.out.println(s));
		//Lambda不省略
        arrayList.stream().filter(
                (String s)->{
                    boolean result = s.length() == 5;
                    return result;
                }
        ).forEach(s -> System.out.println(s));
		//Lambda省略
        arrayList.stream().filter(s -> s.length() == 2).forEach(s -> System.out.println(s));
    }
}
/*
王二麻子
野原新之助
张良
 */

• limit、skip、concat、distinct代码演示

import java.util.ArrayList;
import java.util.stream.Stream;
public class Demo03 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> arrayList = new ArrayList<String>();
        
        arrayList.add("张三丰");
        arrayList.add("张无忌");
        arrayList.add("野原新之助");
        arrayList.add("王二麻子");
        arrayList.add("张良");
        
        System.out.println("----需求1：取前4个数据在控制台输出----");
        arrayList.stream().limit(4).forEach(s-> System.out.println(s));

        System.out.println("----需求2：跳过2个元素，把剩下的元素在控制台输出----");
        arrayList.stream().skip(2).forEach(s-> System.out.println(s));

        System.out.println("----需求3：跳过2个元素，把剩下的元素中前2个在控制台输出----");
        arrayList.stream().skip(2).limit(2).forEach(s-> System.out.println(s));

        System.out.println("----需求4：合并需求1和需求2得到的流，并把结果在控制台输出----");
        Stream<String> s1 = arrayList.stream().limit(4);
        Stream<String> s2 = arrayList.stream().skip(2);
        Stream.concat(s1,s2).forEach(s-> System.out.println(s));
        
        System.out.println("----需求5：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复----");
        Stream<String> s3 = arrayList.stream().limit(4);
        Stream<String> s4 = arrayList.stream().skip(2);
        Stream.concat(s3,s4).distinct().forEach(s-> System.out.println(s));
    }
}
/*
----需求1：取前4个数据在控制台输出----
张三丰
张无忌
野原新之助
王二麻子
----需求2：跳过2个元素，把剩下的元素在控制台输出----
野原新之助
王二麻子
张良
----需求3：跳过2个元素，把剩下的元素中前2个在控制台输出----
野原新之助
王二麻子
----需求4：合并需求1和需求2得到的流，并把结果在控制台输出----
张三丰
张无忌
野原新之助
王二麻子
野原新之助
王二麻子
张良
----需求5：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复----
张三丰
张无忌
野原新之助
王二麻子
张良
*/

1.4Stream流终结操作方法【应用】

• 概念

  终结操作的意思是,执行完此方法之后,Stream流将不能再执行其他操作

• 常见方法

  方法名	说明
  void forEach(Consumer action)	对此流的每个元素执行操作
  long count()	返回此流中的元素数

import java.util.ArrayList;
import java.util.function.Consumer;
public class MyStream5 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("野原新之助");
        arrayList.add("王二麻子");

        method1(arrayList);

        //  long count()：返回此流中的元素数
        long count = arrayList.stream().count();
        System.out.println("此流中的元素数:"+count);
    }

    private static void method1(ArrayList<String> list) {
        //  void forEach(Consumer action)：对此流的每个元素执行操作
        //  Consumer接口中的方法void accept(T t)：对给定的参数执行此操作
        //在forEach方法的底层,会循环获取到流中的每一个数据.
        //并循环调用accept方法,并把每一个数据传递给accept方法
        //s就依次表示了流中的每一个数据.
        //所以,我们只要在accept方法中,写上处理的业务逻辑就可以了.
        System.out.println("==========Consumer匿名内部类==========");
        list.stream().forEach(
                new Consumer<String>() {
                    @Override
                    public void accept(String s) {
                        System.out.println(s);
                    }
                }
        );
        System.out.println("==========Lambda表达式==========");
        //Consumer接口中,只有一个accept方法,它是函数接口
        list.stream().forEach(
                (String s)->{
                    System.out.println(s);
                }
        );
        System.out.println("==========Lambda省略格式==========");
        list.stream().forEach(s->System.out.println(s));
    }
}
/*
==========Consumer匿名内部类==========
野原新之助
王二麻子
==========Lambda表达式==========
野原新之助
王二麻子
==========Lambda省略格式==========
野原新之助
王二麻子
此流中的元素数:2
*/

1.5Stream流的收集操作【应用】

• 概念

  对数据使用Stream流的方式操作完毕后,可以把流中的数据收集到集合中。
  因为Steam流不会对原数据做任何修改，若想得到流操作后的数据需要在终结前收集。

• 常用方法

  方法名	说明
  R collect(Collector collector)	把结果收集到集合中

• 工具类Collectors提供了具体的收集方式

  方法名	说明
  public static Collector toList()	把元素收集到List集合中
  public static Collector toSet()	把元素收集到Set集合中
  public static Collector toMap(Function keyMapper,Function valueMapper)	把元素收集到Map集合中

• Stream流不修改源数据代码演示

import java.util.ArrayList;
import java.util.List;
public class MyStream6 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
        //筛选出能被2整除的数
        list.stream().filter(number -> number % 2 == 0).forEach(number -> System.out.println(number));
        System.out.println("====================");
        for (Integer integer : list) {
            System.out.println(integer);
        }
    }
}
/*
2
4
6
8
10
====================
12345678910
*/

• Stream收集操作代码演示
  • toList和toSet方法演示：

import java.util.*;
import java.util.stream.Collectors;

// toList和toSet方法演示
public class MyStream6 {
    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            list1.add(i);
        }
        list1.add(10);
        list1.add(10);
        list1.add(10);

        //filter只负责过滤数据的。
        //collect只负责收集数据，但是他不负责创建容器,也不负责把数据添加到容器中。
        //Collectors.toList() : 在底层会创建一个List集合.并把所有的数据添加到List集合中.
        List<Integer> list2 = list1.stream().filter(number -> number % 2 == 0)
                .collect(Collectors.toList());

        System.out.println("Collectors.toList():"+list2);//List可重复

        Set<Integer> set = list1.stream().filter(number -> number % 2 == 0)
                .collect(Collectors.toSet());
        System.out.println("Collectors.toSet():"+set);//Set不可重复，toSet()会帮助去重
    }
}
/*
Collectors.toList():[2, 4, 6, 8, 10, 10, 10, 10]
Collectors.toSet():[2, 4, 6, 8, 10]
 */

import java.util.ArrayList;
import java.util.Map;
import java.util.stream.Collectors;

/**
 保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值
 */
public class MyStream8 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("zhangsan,23");
        arrayList.add("lisi,24");
        arrayList.add("wangwu,25");

        Map<String, Integer> map = arrayList.stream().filter(
                s -> {
                    String[] split = s.split(",");
                    int age = Integer.parseInt(split[1]);
                    return age >= 24;
                }

                //Collectors.toMap 创建一个map集合并将数据添加到集合当中
        ).collect(Collectors.toMap(
                s -> s.split(",")[0],//该lambda表达式是如何获取到Map中的键
                s -> Integer.parseInt(s.split(",")[1]) ));//该lambda表达式是如何获取Map中的值

        System.out.println(map);
    }
}
/*
{lisi=24, wangwu=25}
 */

2.File类

IO就可以对硬盘中的文件进行读写
File表示要读写的文件在哪，也可以对文件进行创建，删除等操作

2.1File类概述和构造方法【应用】

• File类介绍

  • 它是文件和目录路径名的抽象表示
  • 文件和目录是可以通过File封装成对象的
  • 对于File而言,其封装的并不是一个真正存在的文件,仅仅是一个路径名而已.它可以是存在的,也可以是不存在的.将来是要通过具体的操作把这个路径的内容转换为具体存在的

• File类的构造方法

  方法名	说明
  File(String pathname)	通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
  File(String parent, String child)	从父路径名字符串和子路径名字符串创建新的 File实例
  File(File parent, String child)	从父抽象路径名和子路径名字符串创建新的 File实例

import java.io.File;
public class FileDemo01 {
    public static void main(String[] args) {
        //File(String pathname): 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
        File f1 = new File("D:\\JavaSpace\\java.txt");
        System.out.println(f1);//D:\JavaSpace\java.txt

        //File(String parent, String child): 从父路径名字符串和子路径名字符串创建新的 File实例
        File f2 = new File("D:\\JavaSpace","java.txt");
        System.out.println(f2);//D:\JavaSpace\java.txt

        //File(File parent, String child): 从父抽象路径名和子路径名字符串创建新的 File实例
        File f3 = new File("D:\\JavaSpace");
        File f4 = new File(f3,"java.txt");
        System.out.println(f4);//D:\JavaSpace\java.txt
    }
}

2.2绝对路径和相对路径【理解】

• 绝对路径

  是一个完整的路径,从盘符开始

• 相对路径

  是一个简化的路径,相对当前项目下的路径

import java.io.File;
public class FileDemo02 {
    public static void main(String[] args) {
        // 是一个完整的路径,从盘符开始
        File file1 = new File("D:\\JavaSpace\\a.txt");//绝对路径

        //当前项目根目录下的a.txt
        File file2 = new File("a.txt");
        //当前项目的指定模块下的b.txt
        File file3 = new File("模块名\\b.txt");
    }
}

File file2 = new File(“a.txt”);//当前项目根目录下的a.txt

File file3 = new File(“FileModule\b.txt”);//当前项目的FileModule模块下的b.txt

2.3File类创建功能【应用】

• 方法分类

  方法名	说明
  public boolean createNewFile()	当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件
  public boolean mkdir()	创建由此抽象路径名命名的目录
  public boolean mkdirs()	创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录

• 注意事项

  • createNewFile方法
    • 如果文件存在，创建失败，返回false
    • 如果文件不存在，创建成功，返回true
    • 不管调用者有没有后缀名，都是创建的文件
  • mkdir方法
    • 只能创建单级文件夹，不能创建多级文件夹
    • 不管调用者有没有后缀名，都是创建的单级文件夹
  • mkdirs方法
    • 可以创建单级文件夹,也可以创建多级文件夹
    • 不管调用者有没有后缀名,只能创建文件夹
  • 疑问
    • 既然mkdirs能创建单级,也能创建多级.那么mkdir可以忽略? 答：是的

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

public class FileDemo03 {
    public static void main(String[] args) throws IOException {
        //需求1：创建多级文件夹
        File f4 = new File("D:\\JavaFileSpace\\JavaWEB\\java3.txt");//创建JavaFileSpace、JavaWEB、java3.txt这三个文件夹
        System.out.println(f4.mkdirs());
        System.out.println("--------");

        //需求2：创建单级文件夹
        File f3 = new File("D:\\JavaFileSpace\\JavaSE");//在D:\JavaFileSpace目录下创建一个单级文件夹JavaSE
        System.out.println(f3.mkdirs());//因为mkdirs也能创建单级，直接不考虑mkdir
        System.out.println("--------");

        //需求3：创建文件
        File f1 = new File("D:\\JavaFileSpace\\java.txt");//创建的java.txt文件
        System.out.println(f1.createNewFile());
        System.out.println("--------");
        File f2 = new File("D:\\JavaFileSpace\\java2");//创建的java2文件，不管有没有后缀名，都是创建的文件
        System.out.println(f2.createNewFile());
        System.out.println("--------");


        //需求4：在不存在的目录下创建文件 会报错
        File f5 = new File("D:\\JavaFileSpace\\JavaWEB2\\HTML2\\java4.txt");
        System.out.println(f5.createNewFile());
    }
}
/*
true
--------
true
--------
true
--------
true
--------
Exception in thread "main" java.io.IOException: 系统找不到指定的路径。
	at java.base/java.io.WinNTFileSystem.createFileExclusively(Native Method)
	at java.base/java.io.File.createNewFile(File.java:1024)
	at lesson.FileDemo02.main(FileDemo02.java:28)

第二次运行则全部为false,因为文件和目录都已存在
*/

2.4File类删除功能【应用】

• 方法分类

  方法名	说明
  public boolean delete()	删除由此抽象路径名表示的文件或目录

• 注意事项

  • 删除并不会进电脑回收站。
  • 只能删除文件和空文件夹。
  • 如果要删除一个有内容的文件夹，只能先进入到这个文件夹，把里面的内容全部删除完毕，才能再次删除这个文件夹。
  • 若文件或者文件夹正在被打开，也不能删除。

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

public class FileDemo04 {
    public static void main(String[] args) throws IOException {

        //需求1：删除绝对路径的文件
        File f1 = new File("D:\\JavaFileSpace\\java.txt：");
        System.out.println("删除绝对路径文件D:\\JavaFileSpace\\java.txt：" + f1.delete());
        //需求1：删除绝对路径的空文件夹
        File f2 = new File("D:\\JavaFileSpace\\JavaSE：");
        System.out.println("删除绝对路径文件夹D:\\JavaFileSpace\\JavaSE：" + f2.delete());

        //前提：在当前项目中创建a.txt文件，在当前模块中创建b.txt文件
        File f3 = new File("a.txt");
        File f4 = new File("FileModule\\b.txt");
        File f5 = new File("FileModule\\newDir");
        File f6 = new File("FileModule\\newDir\\c.txt");
        System.out.println("在当前项目中创建a.txt文件：" + f3.createNewFile());
        System.out.println("在当前模块中创建b.txt文件：" + f4.createNewFile());
        System.out.println("在当前模块目录下创建newDir文件夹：" + f5.mkdir());
        System.out.println("在当前模块的newDir文件夹下创建c.txt：" + f6.mkdir());

        System.out.println("删除当前项目中创建a.txt文件：" + f3.delete());
        System.out.println("删除当前模块目录下的b.txt：" + f4.delete());

        System.out.println("删除当前模块目录下的newDir文件夹(非空文件夹)：" + f5.delete());
        System.out.println("删除newDir文件夹下创建c.txt：" + f6.delete());
        System.out.println("删除当前模块目录下的newDir文件夹(空文件夹)：" + f5.delete());
    }
}
/*
删除绝对路径文件D:\JavaFileSpace\java.txt：false
删除绝对路径文件夹D:\JavaFileSpace\JavaSE：false
在当前项目中创建a.txt文件：true
在当前模块中创建b.txt文件：true
在当前模块目录下创建newDir文件夹：true
在当前模块的newDir文件夹下创建c.txt：true
删除当前项目中创建a.txt文件：true
删除当前模块目录下的b.txt：true
删除当前模块目录下的newDir文件夹(非空文件夹)：false
删除newDir文件夹下创建c.txt：true
删除当前模块目录下的newDir文件夹(空文件夹)：true
 */

2.5File类判断和获取功能【应用】

• 判断功能

  方法名	说明
  public boolean isDirectory()	测试此抽象路径名表示的File是否为目录
  public boolean isFile()	测试此抽象路径名表示的File是否为文件
  public boolean exists()	测试此抽象路径名表示的File是否存在

• 获取功能

  方法名	说明
  public String getAbsolutePath()	返回绝对路径的字符串
  public String getPath()	返回相对路径的字符串
  public String getName()	返回由此抽象路径名表示的文件或目录的名称
  public File[] listFiles()	返回此抽象路径名表示的目录中的文件和目录的File对象数组

• 注意事项

  • getName方法
    • 1.如果调用者是文件,那么获取的是文件名和后缀名
    • 2.如果调用者是一个文件夹,那么获取的是文件夹的名字
  • listFiles方法
    • 1.当调用者是一个文件时，返回null
    • 2,当调用者是一个空文件夹时，返回长度为0的数组
    • 3.当调用者是一个有内容的文件夹时，获取这个文件夹里面所有的文件和文件夹的File对象，并把这些File对象都放在一个数组中返回。包括隐藏文件和隐藏文件夹都可以获取。
    • 4.当调用者是一个有权限才能进入的文件夹时，返回null

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

public class FileDemo05 {
    public static void main(String[] args) throws IOException {
        File file1 = new File("a.txt");//当前项目下创建a.txt文件
        method(file1);

        file1.createNewFile();
        method(file1);

        File file2 = new File("FileModule\\newDir");//当前模块下创建newDir文件夹
        file2.mkdirs();
        method(file2);
        
		File file3 = new File(".");//当前项目
        File[] files = file3.listFiles();//返回值是一个File类型的数组
        System.out.println("File数组长度："files.length);
        for (File path : files) {
            System.out.println(path);
        }
    }

    private static void method(File file) {
        System.out.println(file.getName()+"该路径的File是文件吗？"+file.isFile());
        System.out.println(file.getName()+"该路径的File是文件甲吗？"+file.isDirectory());
        System.out.println("当前路径的File是否存在"+file.exists());
        System.out.println("File的绝对路径："+file.getAbsoluteFile());
        System.out.println("File的相对路径："+file.getPath());
        System.out.println("----------------------------");
    }
}
/*
a.txt该路径的File是文件吗？false
a.txt该路径的File是文件甲吗？false
当前路径的File是否存在false
File的绝对路径：D:\AAAAA\IDEAWorkSpace\MyJavaEE\a.txt
File的相对路径：a.txt
----------------------------
a.txt该路径的File是文件吗？true
a.txt该路径的File是文件甲吗？false
当前路径的File是否存在true
File的绝对路径：D:\IDEAWorkSpace\MyJavaEE\a.txt
File的相对路径：a.txt
----------------------------
newDir该路径的File是文件吗？false
newDir该路径的File是文件甲吗？true
当前路径的File是否存在true
File的绝对路径：D:\AAAAA\IDEAWorkSpace\MyJavaEE\FileModule\newDir
File的相对路径：FileModule\newDir
----------------------------
File数组长度：4
.\.idea
.\a.txt
.\FileModule
.\out

 */

2.6File类练习一：创建文件【应用】

• 案例需求
  • 在当前模块下的TestFiles文件夹中创建一个aaa.txt文件
• 注意事项
  • 文件所在的文件夹必须要存在

import java.io.File;
import java.io.IOException;
public class Test1 {
    public static void main(String[] args) throws IOException {
        //1.创建File对象,指向TestFiles文件夹
        File file = new File("FileModule\\TestFiles");
        //2.判断TestFiles文件夹是否存在,如果不存在则创建
        if(!file.exists()){
            //如果文件夹不存在,就创建出来
            file.mkdirs();
        }
        //3.创建File对象,指向aaa文件夹下的aaa.txt文件
        File newFile = new File(file,"aaa.txt");
        //4.创建这个文件
        newFile.createNewFile();
    }
}

2.7File类练习二：删除一个多级文件夹【应用】

• 案例需求

  • 删除一个多级文件夹

• 注意事项

  • delete方法只能删除文件和空文件夹。如果现在要删除一个有内容的文件夹?先删掉这个文件夹里面所有的内容,最后再删除这个文件夹。

• 实现步骤

  • 定义一个方法,接收一个File对象
  • 遍历这个File对象,获取它下边的每个文件和文件夹对象
  • 判断当前遍历到的File对象是文件还是文件夹
  • 如果是文件,直接删除
  • 如果是文件夹,递归调用自己,将当前遍历到的File对象当做参数传递
  • 参数传递过来的文件夹File对象已经处理完成,最后直接删除这个空文件夹

• 代码实现

import java.io.File;

public class Test2 {
    public static void main(String[] args) {
        File src = new File("D:\\JavaFileSpace");
        deleteDir(src);
    }

    //1.定义一个方法,接收一个File对象
    private static void deleteDir(File src) {
        //先删掉这个文件夹里面所有的内容.
        //递归: 方法在方法体中自己调用自己.
        //注意: 此方法可以解决所有文件夹和递归相结合的题目

        //2.遍历这个File对象,获取src它下边的每个文件和文件夹对象
        File[] files = src.listFiles();
        //3.判断当前遍历到的File对象是文件还是文件夹
        for (File file : files) {
            //4.如果是文件,直接删除
            if(file.isFile()){
                file.delete();
            }else{
                //5.如果是文件夹,递归调用自己,将当前遍历到的File对象当做参数传递
                deleteDir(file);//参数一定要是src文件夹里面的文件夹File对象
            }
        }
        //6.参数传递过来的文件夹File对象已经处理完成,最后直接删除这个空文件夹
        src.delete();
    }
}

2.8File类练习三： 统计文件夹中每种文件的个数【应用】

• 案例需求

  统计一个文件夹中每种文件的个数并打印

• 实现步骤

  • 定义一个方法,参数是HashMap集合用来统计次数和File对象要统计的文件夹
  • 遍历File对象,获取它下边的每一个文件和文件夹对象
  • 判断当前File对象是文件还是文件夹
  • 如果是文件,判断这种类型文件后缀名在HashMap集合中是否出现过
    • 没出现过,将这种类型文件的后缀名存入集合中,次数存1
    • 出现过,获取这种类型文件的后缀名出现的次数,对其+1,在存回集合中
  • 如果是文件夹,递归调用自己,HashMap集合就是参数集合,File对象是当前文件夹对象

import java.io.File;
import java.util.HashMap;

public class Test3 {
    public static void main(String[] args) {
        //统计一个文件夹中,每种文件出现的次数.
        //定义一个变量用来统计的弊端:同时只能统计一种文件。
        //利用map集合进行数据统计,键=文件后缀名，值=次数。

        File file = new File("FileModule\\TestFiles");
        HashMap<String, Integer> hm = new HashMap<>();
        getCount(hm, file);
        System.out.println(hm);
    }

    //1.定义一个方法,参数是HashMap集合用来统计次数和File对象要统计的文件夹
    private static void getCount(HashMap<String, Integer> hm, File file) {
        //2.遍历File对象,获取它下边的每一个文件和文件夹对象
        File[] files = file.listFiles();
        for (File f : files) {
            //3.判断当前File对象是文件还是文件夹
            if(f.isFile()){
                //如果是文件,判断这种类型文件后缀名在HashMap集合中是否出现过
                String fileName = f.getName();
                String[] fileNameArr = fileName.split("\\.");//没有后缀名的文件不考虑
                if(fileNameArr.length == 2){
                    String fileEndName = fileNameArr[1];
                    if(hm.containsKey(fileEndName)){
                        //出现过,获取这种类型文件的后缀名出现的次数,对其+1,在存回集合中
                        Integer count = hm.get(fileEndName);
                        //这种文件又出现了一次.
                        count++;
                        //把已经出现的次数给覆盖掉.
                        hm.put(fileEndName,count);
                    }else{
                        // 没出现过,将这种类型文件的后缀名存入集合中,次数存1
                        hm.put(fileEndName,1);
                    }
                }
            }else{
                //如果是文件夹,递归调用自己,HashMap集合就是参数集合,File对象是当前文件夹对象代码实现
                getCount(hm,f);
            }
        }
    }
}
/*
{jpg=2, txt=3, java=1, doc=2}
*/