Java进阶篇-2

不可变集合

创建不可变集合的应用场景
如果某个数据不能被修改，把它防御性地拷贝到不可变集合中是个很好的实践
当集合对象被不可信的库调用时，不可变形式是安全的

    List<String> list = List.of("张三"，"李四"，"王五"，"赵六");
    Map<String，String> map = Map.of("张三"，"李四"，"王五"，"赵六");
//细节:
//键不能重复
//Map里面的of方法，参数是有上限的，最多只能传递20个参数，10个键值对
//超过10个用ofEntries方法
    Map<Object, Object> map = Map.ofEntries(hm.entrySet().toArray(new Map.Entry[0]));
    Map<String，String> map = Map.copyOf(hm);  //JDK10之后

Stream流

list1.stream().filter(name->name.startsWith("张")).filter(name -> name.length() == 3).forEach(name-> System,out,println(name));

Stream流的作用:
结合了Lambda表达式，简化集合、数组的操作
Stream流的使用步骤:

1. 先得到一条Stream流(流水线)，并把数据放上去
2. 利用Stream流中的API进行各种操作

中间方法：过滤 转换
终结方法：统计 打印

//1.单列集合获取stream流
    ArrayList<String> list = new ArrayList<>();
    Collections .addAlL(list,"a","b","c","d","e");
//获取到一条流水线，并把集合中的数据放到流水线上
    Stream<String> stream1 = list.stream();
    list.stream().forEach(s -> System.out.println(s));
//2.双列集合获取
    HashMap<String,Integer> hm = new HashMap<>();
//第一种：
    hm.keySet().stream().forEach(s -> System.out.println(s));
//第二种：
    hm.entrySet().stream( ).forEach(s-> System.out.printIn(s));

//数组获取
    int[] arr = (1,2,3,4,5,6,7,8,9,10);

    Arrays.stream(arr).forEach(s-> System.out.printIn(s));
//零散数据
    Stream.of(1,2,3,4,5).forEach(s-> System.out.println(s));
    Stream.of("a","b","c","d","e").forEach(s-> System.out.println(s));

//注意:
//stream接口中静态方法of的细节
//方法的形参是一个可变参数，可以传递一堆零散的数据，也可以传递数组
//但是数组必须是引用数据类型的，如果传递基本数据类型，是会把整个数组当做一个元素，放到Stream当中。
    int[] arr1 = [1,2,3,4,5,6,7,8,9,10];
    Stream.of(arr1).forEach(s-> System.out.println(s));

中间方法

注意1: 中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程
注意2:修改Stream流中的数据，不会影响原来集合或者数组中的数据

    list.stream()
    .filter(s -> s.startsWith("张"))
    .filter(s -> s.length() == 3)
    .forEach(s -> System.out.println(s));

    list.stream
    .limit(3)
    .forEach(s -> System.out.println(s));//前三个元素

    list.stream
    .skip(4)
    .forEach(s -> System.out.println(s));//跳过前四个
    list.stream
    .limit(6)
    .skip(4)
    .forEach(s -> System.out.println(s));//输出4.5.6个元素

    ist.stream
    .distinct()
    .forEach(s -> System.out.println(s));//去重

    Stream
    .concat(list1.stream(),list2
    .stream())
    .forEach(s -> System.out.println(s));//合并

    //第一个类型:流中原本的数据类型
    //第二个类型: 要转成之后的类型
    list.stream()
    .map(s-> Integer.parseInt(s.split( "-")[1]))
    .forEach(s-> System.out.printIn(s));

终结方法

    list.stream().forEach(s -> System.out.println(s));

    long count = list.stream().count();//统计

    String[] arr2 = list.stream().toArray(value -> new String[value]);
    System.out.println(Arrays.toString(arr2));//收集到数组中

    //收集到List集合中
    //要把所有的男性收集起来
    List<String> newList = list.stream()
    .filter(s -> "男".equals(s.split("-")[1]))
    .collect(Collectors.toList());
    
    //收集到Set集合中
    //去除重复元素
    Set<String> newList2 = list.stream()
    .filter(s -> "男".equals(s.split( regex: "-")[1]))
    .collect(Collectors.toSet());

    //收集到Map集合中
    Map<String，Integer> map2 = list.stream()
    .filter(s ->"男".equals(s.split( regex: "-")[1]))
    .collect(Collectors.toMap(
        s -> s.split("-")[0],
        s -> Integer.parseInt(s.split("-")[2])));

三个练习

    Collections.addAll(list,1, 2, 3, 4, 5, 6,7，8 9, 10) ;
//过滤奇数，只留下偶数
//进行判断，如果是偶数，返回true 保留
    List<Integer> ewList = list.stream()
        .filter(n -> n % 2 == 0)
        .collect(Collectors.toList());

方法引用

把已经有的方法拿过来用，当做函数式接口中抽象方法的方法体
:: 方法引用符
有要求：

1. 引用处必须是函数式接口
2. 被引用的方法必须已经存在
3. 被引用方法的形参和返回值需要跟抽象方法保持一致
4. 被引用方法的功能要满足当前需求

//可以是Java已经写好的，也可以是一些第三方的工具类
//表示引用FunctionDemo1类里面的subtraction方法
//把这个方法当做抽象方法的方法体
    Arrays.sort(arr，FunctionDemo1::subtraction);

引用静态方法

格式：类名::静态方法

    list.stream().map(new Function<String, Integer>() {
        @Override
        public Integer apply(String s) {
            int i = Integer.parseInt(s);
            return i;
        }
    }).forEach(s -> System.out.println(s));
    
    list.stream().map(Integer::parseInt).forEach(s-> System.out.println(s));

引用成员方法

格式: 对象::成员方法

1. 其他类: 其他类对象::方法名
2. 本类: this::方法名
3. 父类: super::方法名

//其他类
    public class StringOperation{
        public boolean stringJudge(String s){
            return s.startsWith("张") && s.length() == 3;
        }
    }

    StringOperation so = new StringOperation();
    list.stream().filter(so::stringJudge)
    .forEach(s-> System.out.printIn(s));

//本类，需要在非静态方法中使用this，否则
    list.stream().filter(new FunctionDemo3()::stringJudge)
    .forEach(s -> System.out.println(s));

    list.stream().filter(this::stringJudge);

//父类
    list.stream().filter(super::stringJudge);
    

引用本类父类的成员方法时,引用处不能是静态方法

引用构造方法

格式
类名::new

//封装成student对象并收集到List集合中
    list.stream().map(Student::new).collect(Collectors.toList());

类名引用成员方法

格式
类名::成员方法

/*抽象方法形参的详解:
第一个参数:表示被引用方法的调用者，决定了可以引用哪些类中的方法
在stream流当中，第一个参数一般都表示流里面的每一个数据。假设流里面的数据是字符串，那么使用这种方式进行方法引用，只能引用string这个类中的方法
第二个参数到最后一个参数:跟被引用方法的形参保持一致，如果没有第二个参数，说明被引用的方法需要是无参的成员方法

局限性:
不能引用所有类中的成员方法。
是跟抽象方法的第一个参数有关，这个参数是什么类型的，那么就只能引用这个类中的方法。
*/

//map(String::toUpperCase)
//拿着流里面的每一个数据，去调用string类中的toUpperCase方法，方法的返回值就是转换之后的结果.
    list.stream().map(String::toUpperCase).forEach(s -> System,out.println(s));

引用数组的构造方法

格式
数据类型[]::new

//1.创建集合并添加元
    ArrayList<Integer> list = new ArrayList<>();
    Collections.addAlL(list, ...elements: 1, 2，3，4，5);
//2.收集到数组当中
    Integer[] arr = list.stream().toArray(new IntFunction<Integer[]>() {
        @Override
        public Integer[] apply(int value) {
            return new Integer[value];
            }
    });
//改写成下面
//细节:
//数组的类型，需要跟流中数据的类型保持一致。
    Integer[] arr2 = list.stream().toArray(Integer[]::new);

技巧：

1. 现在有没有一个方法符合我当前的需求
2. 如果有这样的方法，这个方法是否满足引用的规则
   1. 静态类名::方法名
   2. 成员方法
   3. 构造方法 类名:: new

异常

异常就是代表程序出现的问题
Error:
代表的系统级别错误(属于严重问题),系统一旦出现问题，sun公司会把这些错误封装成Error对象
Exception:
叫做异常，代表程序可能出现的问题。我们通常会用Exception以及他的子类来封装程序出现的问题

运行时异常: RuntimeException及其子类，编译阶段不会出现异常，提醒运行时出现的异常(如:数组索引越界异常)
编译时异常: 编译阶段就会出现异常提醒的。(如:日期解析异常)

编译时异常和运行时异常

//编译时异常
    String time ="2023年1月1日"
    SimpleDateFormat sdf = new SimpleDateFormat( pattern: "yyyy年MM月dd日");
    Date date = sdf.parse(time);//parse报错，没throws ParseException
    System.out.println(date);



//运行时异常，一般是由于参数传递错误带来的问题
    int[] arr = (1,2,3,4, 5);
    System.out.println(arr[1e]);

异常作用

/*
异常作用一:异常是用来查询bug的关键参考信息
异常作用二:异常可以作为方法内部的一种特殊返回值，以便通知调用者底层的执行情况
*/
    //抛出异常
    throw new RuntimeException();

处理异常

JVM默认的处理方式

1. 把异常的名称，异常原因及异常出现的位置等信息输出在了控制台
2. 程序停止执行，异常下面的代码不会再执行了

捕获异常

    try {
        可能出现异常的代码;
        } catch(异常类名 变量名) {
            异常的处理代码;
        }
//好处：可以让程序运行下去
    try{
    System.out.println(arr[10]);
    }catch(ArrayIndexOutOfBoundsException e){
        System.out.println("索引越界了");
    }

如果try中没有遇到问题，怎么执行?

    //会把try里面所有的代码全部执行完毕，不会执行catch里面的代码
    //注意:只有当出现了异常才会执行catch里面的代码

如果try中可能会遇到多个问题，怎么执行?

//会写多个catch与之对应

//如果我们要捕获多个异常，这些异常中如果存在父子关系的话，那么父类一定要写在下面

//在JDK7之后，我们可以在catch中同时捕获多个异常，中间用|进行隔开表示如果出现了A异常或者B异常的话，采取同一种处理方案
catch(ArrayIndexOutOfBoundsException ArithmeticException e)
    try{
        System.out.println(arr[10]);//ArrayIndexOutOfBoundsException
        System.out.println(2/0);//ArithmeticExceptionString s = null;
        System.out.println(s.equals("abc"));
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println("索引越界了");
        }catch(ArithmeticException e){
            System.out.println("除数不能为0");
        }catch(NullPointerException e){
            System.out.println("空指针异常");
        }
    System.out.println("看看我执行了吗?");

如果try中遇到的问题没有被捕获，怎么执行?

    try{
        System.out.println(arr[10]);//ArrayIndexOutofBoundsException
    }catch(NullPointerException e){
        System.out.println("空指针异常");
    }

//相当于try...catch的代码白写了，最终还是会交给虚拟机进行处理。

如果try中遇到了问题，那么try下面的其他代码还会执行吗?

    //下面的代码就不会执行了，直接跳转到对应的catch当中，执行catch里面的语句体
    //但是如果没有对应catch与之匹配，那么还是会交给虚拟机进行处理

异常常见方法

public void printStackTrace()
把异常的错误信息输出在控制台

//返回此 throwable 的详细消息字符串
    String message = e.getMessage();System.out.println(message)
    //Index 1 out of bounds for length 6

//返回此可抛出的简短描述  
    String str = e.toString();
    System.out.println(str);
    //java.lang.ArrayIndex0utOfBoundsException: Index 19 out of bounds for length
    
    e.printStackTrace();
    //只会打印信息，不会停止程序

抛出处理

在方法中，出现异常。
方法就没有继续运行下去的意义，采取抛出处理。
让该方法结束运行并告诉调用者出现问题

throws
注意:写在方法定义处，表示声明一个异常告诉调用者，使用本方法可能会有哪些异常

    public void 方法()throws 异常类名1,异常类名2...  

• 编译时异常: 必须要写
• 运行时异常: 可以不写

throw
注意:写在方法内，结束方法手动抛出异常对象，交给调用者方法中下面的代码不再执行了

    public void 方法(){  
        throw new NullPointerException();  
    }

练习

    while (true){
        try{
            System.out.printIn("请输入你心仪的女朋友的名字");
            String name = sc.nextLine();gf.setName(name);
            System.out.printIn("请输入你心仪的女朋友的年龄");
            String ageStr = sc.nextLine();
            int age = Integer.parseInt(ageStr);
            gf.setAge(age);
//如果所有的数据都是正确的，那么跳出循环
            break;
        }catch (NumberFormatException e){
            System.out.println("年龄的格式有误，请输入数字");
        }catch (RuntimeException e){
            System.out.println("姓名的长度或者年龄的范围有误");
        }
    }
    System.out.printIn(gf);

JavaBean类中：

    public void setName(String name){
        int len = name.length();
        if(len < 3 ll len > le){
            throw new RuntimeException();
        }
        this.name = name;
    }

    getAge也重新写

自定义异常

1. 定义异常类
2. 写继承关系
3. 空参构造
4. 带参构造

意义:就是为了让控制台的报错信息更加的见名之意

//NameFormatException.java
    public class NameFormatException extends RuntimeException{

        public NameFormatException() {

        }
        
        public NameFormatException(String message){
            super(message);
        }
    }

File

• File对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径
• 这个路径可以是存在的，也允许是不存在的

根据文件路径创建文件对象
    public File(String pathname)
//根据父路径名字符申和子路径名宁符串创建文件对象
    public File(String parent, String child)
//根据父路径对应文件对象和子路径名宁符串创建文件对象
    public File(File parent，String child)

//1.根据字符串表示的路径，变成File对象
    String str ="C:\\Users\\alienware\\Desktop\\a.txt";
    File fl = new File(str);
    System.out.printIn(f1);//C:\Users\ alienware\Desktop\a.txt


//2.父级路径: C:\Users\alienware\Desktop//于级路径: a.txt
    String parent ="C:\\Users\\alienware\\Desktop";
    String child = "a.txt";
    File f2 = new File(parent,child);
    System.out.println(f2);//C:\Users \alienware\Desktop\a.txt

//或者自己拼接，使用较少，linux：/ ：
    File f3 = new File(pathname: parent + "\\"+ child);

//3.把一个File表示的路径和string表示路径进行拼接
    File parent2 = new File(pathname: "C:\\Users\\alienware\\Desktop");
    String child2 = "a.txt";
    File f4 = new File(parent2,child2);
    System.out.println(f4);

File成员方法

public boolean isDirectory()
public boolean isFile()
public boolean exists()
public long length()
public String getAbsolutePath()
public string getPath()
public String getName()
public long lastModified()
/*
判断此路径名表示的File是否为文件夹判断此路径名表示的File是否为文件判断此路径名表示的File是否存在
返回文件的大小(字节数量)
返回文件的绝对路径
返回定义文件时使用的路径
返回文件的名称，带后缀
返回文件的最后修改时间 (时间毫秒值)
*/

FileDemo.java

    //1.对一个文件的路径进行判断
    File f1 = new File( pathname: "D:\\aaa\\a.txt");
    System.out.printIn(f1.isDirectory());//false
    System.out.println(f1.isFile());//true
    System.out.println(f1.exists());//true

获取

//1.length 返回文件的大小(宇节数量)
//细节1: 这个方法只能获取文件的大小，单位是字节
//如果单位我们要是M，G，可以不断的除以1024
//细节2: 这个方法无法获取文件夹的大小
//如果我们要获取一个文件夹的大小，需要把这个文件夹里面所有的文件大小都累加在一起。

    File f1 = new File( pathname:"D:\\aaa\\a.txt");
    long len = f1.length();
    System.out.println(len);//12
    
    File f2 = new File( pathname: "D:\\aaa\\bbb");
    long len2 = f2.length();
    System.out.println(len2);//0

//2.getAbsolutePath 返回文件的绝对路径

    File f4 = new File("myFile\\a.txt");
    //当前项目下
    //不写myFile就是直接在项目下
    String path2 = f4.getAbsolutePath();
    System.out.printIn(path2);//绝对路径

//3.getPath 返回定义文件时使用的路径
    File fs = new File( pathname: "D:\\aaa\\a.txt");
    String path3 = f5.getPath();
    System.out.println(path3);//D:\aaa\a.txt

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


//4.getName 获取名字


    File f7 = new File( pathname:"D:\\aaa\\a.txt");
    String name1 = f7.getName();
    System.out.printIn(name1);

    File f8 = new File("D:\\aaa\\bbb");
    String name2 = f8.getName();
    System.out.printIn(name2);//bbb

//5.lastModified 返回文件的最后修改时间(时间毫秒值)

    File f9 = new File("D:\\aaa\\a.txt");long time = f9.lastModified();
    System.out.println(time);//1667380952425

创建删除

//delete方法默认只能删除文件和空文件夹，delete方法直接删除不走回收站
    
//1.createNewFile 创建一个新的空的文件
    File f1 = new File("D:\\aaa\\c.txt");
    boolean b = f1.createNewFile();
    System.out.println(b);
//细节1: c.txt存在，不会报错，显示创建失败
//细节2: 如果父级路径是不存在的，那么方法会有异常IOException
//细节3: createNewFle方法创建的一定是文件，如果路径中不包含后缀名，则创建一个没有后缀的文件

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

//3.mkdirs 创建多级文件夹
//细节：单级、多级文件夹都能创建
    File f3 = new File("D:\\aaa\\aaa\\bbb\\ccc");
    boolean b = f3.mkdirs();
    System.out.printIn(b);//true

//4.删除文件
    boolean b = f1.delete();
/*细节1:
如果制除的是文件，则直接删除，不走回收站。如果删除的是空文件夹，则直接删除，不走回收站如果删除的是有内容的文件夹，则删除失败
*/

获取并遍历

    File f = new File("D:\\aaa");
//listFiles方法
//作用: 获取aaa文件夹里面的所有内容，把所有的内容放到数组中返回
    File[] files = f.listFiles();
    for (File file : files) {
//file依次表示aaa文件夹里面的每一个文件或者文件夹
        System.out.printIn(file);
    }

/*细节
当调用者File表示的路径不存在时，返回null
当调用者File表示的路径是文件时，返回null
当调用者File表示的路径是一个空文件夹时，返回一个长度为0的数组
当调用者File表示的路径是一个有内容的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回
当调用者File表示的路径是一个有隐藏文件的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏文件
当调用者File表示的路径是需要权限才能访问的文件夹时，返回null
*/

/*
public static File[] listRoots() 列出可用的文件系统盘符
public string[] list() 获取当前该路径下所有内容（只能获取名字）
public string[] list(FilenameFilter filter) 利用文件名过滤器获取当前该路径下所有内容
(掌握) public File[] listFiles() 获取当前该路径下所有内容
public File[] listFiles(FileFilter filter) 利用文件名过滤器获取当前该路径下所有内容
public File[] listFiles(FilenameFilter filter) 利用文件名过滤器获取当前该路径下所有内容
*/

    File[] arr = File.listRoots();
    String[] arr2 = f.list();

listFiles()

    File[] arr = f.listFiles();
    for (File file : arr){
//file依次表小aaa文件夹里面每一个文件或者文件夹的路径
        if(file.isFile() && file.getName().endsWith(".txt")){
            System.out.println(file);
        }
    }

listFiles()重载：

1. listFiles(FileFilter filter)

//accept参数是完整路径
    File[] arr = f.listFiles(new FileFilter()){
        @Override
        public boolean accept(File pathname){
            return pathname.isFile() && pathname.getName().endsWith(".txt");
        }
    };

2. File[] listFiles(FilenameFilter filter)

//拼接
    File[] arr2 = f.listFiles(new FilenameFilter()){
        @Override
        public boolean accept(File dir,String name){
            File src = new File(dir, name);
            return src.isFile() && name.endsWith(".txt");
        }
    }

练习：

​1. 找到电脑中所有以avi结尾的电影。（需要考虑子文件夹）

代码示例：

public class Test3 {
    public static void main(String[] args) {
        /* 需求：
        找到电脑中所有以avi结尾的电影。（需要考虑子文件夹）


        套路：
            1，进入文件夹
            2，遍历数组
            3，判断
            4，判断

        */

        findAVI();

    }

    public static void findAVI(){
        //获取本地所有的盘符
        File[] arr = File.listRoots();
        for (File f : arr) {
            findAVI(f);
        }
    }

    public static void findAVI(File src){//"C:\\
        //1.进入文件夹src
        File[] files = src.listFiles();
        //2.遍历数组,依次得到src里面每一个文件或者文件夹
        if(files != null){
            for (File file : files) {
                if(file.isFile()){
                    //3，判断，如果是文件，就可以执行题目的业务逻辑
                    String name = file.getName();
                    if(name.endsWith(".avi")){
                        System.out.println(file);
                    }
                }else{
                    //4，判断，如果是文件夹，就可以递归
                    //细节：再次调用本方法的时候，参数一定要是src的次一级路径
                    findAVI(file);
                }
            }
        }
    }
}

2.删除多级文件夹

需求： 如果我们要删除一个有内容的文件夹
1.先删除文件夹里面所有的内容
2.再删除自己

代码示例：

public class Test4 {
    public static void main(String[] args) {
        /*
           删除一个多级文件夹
           如果我们要删除一个有内容的文件夹
           1.先删除文件夹里面所有的内容
           2.再删除自己
        */

        File file = new File("D:\\aaa\\src");
        delete(file);

    }

    /*
    * 作用：删除src文件夹
    * 参数：要删除的文件夹
    * */
    public static void delete(File src){
        //1.先删除文件夹里面所有的内容
        //进入src
        File[] files = src.listFiles();
        //遍历
        for (File file : files) {
            //判断,如果是文件，删除
            if(file.isFile()){
                file.delete();
            }else {
                //判断,如果是文件夹，就递归
                delete(file);
            }
        }
        //2.再删除自己
        src.delete();
    }
}

3.统计一个文件夹的总大小

代码示例：

public class Test5 {
    public static void main(String[] args) {
       /*需求：
            统计一个文件夹的总大小
      */


        File file = new File("D:\\aaa\\src");

        long len = getLen(file);
        System.out.println(len);//4919189
    }

    /*
    * 作用：
    *       统计一个文件夹的总大小
    * 参数：
    *       表示要统计的那个文件夹
    * 返回值：
    *       统计之后的结果
    *
    * 文件夹的总大小：
    *       说白了，文件夹里面所有文件的大小
    * */
    public static long getLen(File src){
        //1.定义变量进行累加
        long len = 0;
        //2.进入src文件夹
        File[] files = src.listFiles();
        //3.遍历数组
        for (File file : files) {
            //4.判断
            if(file.isFile()){
                //我们就把当前文件的大小累加到len当中
                len = len + file.length();
            }else{
                //判断，如果是文件夹就递归
                len = len + getLen(file);
            }
        }
        return len;
    }
}

4.统计文件个数

需求：统计一个文件夹中每种文件的个数并打印。（考虑子文件夹）
打印格式如下：
txt:3个
doc:4个
jpg:6个

代码示例：

public class Test6 {
    public static void main(String[] args) throws IOException {
        /*
            需求：统计一个文件夹中每种文件的个数并打印。（考虑子文件夹）
            打印格式如下：
            txt:3个
            doc:4个
            jpg:6个
        */
        File file = new File("D:\\aaa\\src");
        HashMap<String, Integer> hm = getCount(file);
        System.out.println(hm);
    }

    /*
    * 作用：
    *       统计一个文件夹中每种文件的个数
    * 参数：
    *       要统计的那个文件夹
    * 返回值：
    *       用来统计map集合
    *       键：后缀名 值：次数
    *
    *       a.txt
    *       a.a.txt
    *       aaa（不需要统计的）
    *
    *
    * */
    public static HashMap<String,Integer> getCount(File src){
        //1.定义集合用来统计
        HashMap<String,Integer> hm = new HashMap<>();
        //2.进入src文件夹
        File[] files = src.listFiles();
        //3.遍历数组
        for (File file : files) {
            //4.判断，如果是文件，统计
            if(file.isFile()){
                //a.txt
                String name = file.getName();
                String[] arr = name.split("\\.");
                if(arr.length >= 2){
                    String endName = arr[arr.length - 1];
                    if(hm.containsKey(endName)){
                        //存在
                        int count = hm.get(endName);
                        count++;
                        hm.put(endName,count);
                    }else{
                        //不存在
                        hm.put(endName,1);
                    }
                }
            }else{
                //5.判断，如果是文件夹，递归
                //sonMap里面是子文件中每一种文件的个数
                HashMap<String, Integer> sonMap = getCount(file);
                //hm:  txt=1  jpg=2  doc=3
                //sonMap: txt=3 jpg=1
                //遍历sonMap把里面的值累加到hm当中
                Set<Map.Entry<String, Integer>> entries = sonMap.entrySet();
                for (Map.Entry<String, Integer> entry : entries) {
                    String key = entry.getKey();
                    int value = entry.getValue();
                    if(hm.containsKey(key)){
                        //存在
                        int count = hm.get(key);
                        count = count + value;
                        hm.put(key,count);
                    }else{
                        //不存在
                        hm.put(key,value);
                    }
                }
            }
        }
        return hm;
    }
}