当前位置：首页 > article >正文

Java笔记_17（异常、File）

article 2024/11/13 6:53:31

Java笔记_17

一、异常
- 1.1、异常体系介绍
- 1.2、编译时异常和运行时异常
- 1.3、异常的作用
- 1.4、异常的处理方式
- 1.5、捕获异常的灵魂四问
- 1.6、异常中的常见方法
- 1.7、抛出处理
- 1.8、异常-练习（键盘录入数据）
- 1.9、自定义异常
二、File
- 2.1、File的概述和构造
- 2.2、File的成员方法
- - 2.2.1、File的常见方法（判断、获取）
  - 2.2.2、File的常见方法（创建、删除）
  - 2.2.3、File的常见方法（获取并遍历）
  - 2.2.4、File的常见方法（所有获取并遍历）
- 2.3、综合练习
- - 2.3.1、在当前模块下的aaa文件夹中创建一个a.txt文件
  - 2.3.2、定义一个方法找某一个文件夹中，是否有以avi结尾的电影
  - 2.3.3、找到电脑中所有以avi结尾的电影
  - 2.3.4、删除一个多级文件夹
  - 2.3.5、统计一个文件夹的总大小
  - 2.3.6、统计一个文件夹中每种文件的个数并打印（考虑子文件夹）

一、异常

1.1、异常体系介绍

异常： 异常就是代表程序出现的问题
误区： 不是让我们以后不出异常，而是程序出了异常之后，该如何处理
在这里插入图片描述
Error: 代表的系统级别错误（属于严重问题)

系统一旦出现问题，sun公司会把这些错误封装成Error对象。
Error是给sun公司自己用的，不是给我们程序员用的。因此我们开发人员不用管它。

Exception: 叫做异常，代表程序可能出现的问题。

我们通常会用Exception以及他的子类来封装程序出现的问题。

运行时异常: RuntimeException及其子类

编译阶段不会出现异常提醒。
运行时出现的异常（如:数组索引越界异常)

编译时异常: 编译阶段就会出现异常提醒的。（如:日期解析异常)
在这里插入图片描述

1.2、编译时异常和运行时异常

编译时异常：
除了RuntimeExcpetion和他的子类，其他都是编译时异常。编译阶段需要进行处理，作用在于提醒程序员。
运行时异常：
RuntimeException本身和所有子类，都是运行时异常。编译阶段不报错，是程序运行时出现的。

package Exception;

import javax.xml.transform.Source;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Dome1 {
    public static void main(String[] args) throws ParseException {

        //编译时异常（在编译阶段，必须要手动处理，否则代码报错）
        String time = "2023年1月1日";
        SimpleDateFormat sdf = new SimpleDateFormat("YYYY年MM月dd日");

        Date date = sdf.parse(time);
        System.out.println(date);

        //运行时异常（在编译阶段不会处理，是代码运行时出现的）
        int[] arr =  {1,2,3,4};
        System.out.println(arr[7]);//ArrayIndexOutOfBoundsException
    }
}

在这里插入图片描述

1.3、异常的作用

异常是用来查询bug的关键参考信息
异常可以作为方法内部的一种特殊返回值，以便通知调用者底层的执行情况

package Exception;

public class Dome2 {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setAge(50);
        //此时运行就会出现RuntimeException异常
        //选择1：自己处理
        //选择2：打印在控制台上
    }
}
package Exception;

public class Student {
    private String name;
    private int age;


    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {

        if (age>=50||age<=18){
            throw new RuntimeException();
        }else {
            this.age = age;
        }
    }
    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

1.4、异常的处理方式

JVM默认的处理方式
- 把异常的名称，异常原因及异常出现的位置等信息输出在了控制台
- 程序停止执行，下面的代码不会再执行了
自己处理
- 目的：当代码出现异常的时候，可以让程序继续往下执行

package Exception;

public class Dome3 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7};

        try {
            System.out.println(arr[10]);
        /*此处出现了异常，程序就会在这里创建一个ArrayIndexOutOfBoundsException对象
        new ArrayIndexOutofBoundsException( );
        拿着这个对象到catch的小括号中对比，看括号中的变量是否可以接收这个对象
        如果能被接收，就表示该异常就被捕获（抓住)，执行catch里面对应的代码
        当catch里面所有的代码执行完毕，继续执行try. . .catch体系下面的其他代码
        */
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println("数组下标越界了");
        }
        System.out.println("看看我能不能执行");
    }
}

抛出异常

1.5、捕获异常的灵魂四问

如果try中没有遇到问题，怎么执行?
- 会把try中所有的代码执行完毕，不会执行catch里面的代码
- 只有出现了异常才会执行catch里面的代码
如果try中可能会遇到多个问题，怎么执行?
- 只能捕获到最开始遇到的异常
- 写多个catch与之对应
- 如果我们要捕获多个异常，这些异常中如果存在父子关系的话，那么父类一定要写在下面
- 了解点：
  在JDK7之后，我们可以在catch中同时捕获多个异常，中间用|进行隔开表示如果出现了A异常或者B异常的话，采取同一种处理方案

package Exception;

public class Dome4 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7};

        try {
            System.out.println(arr[10]);
            System.out.println(2/0);
            String s = null;
            System.out.println(s.equals("abc"));
        }catch (ArrayIndexOutOfBoundsException|ArithmeticException e){
            System.out.println("数组越界");
        }catch (NullPointerException e){
            System.out.println("空指针异常");
        }catch (Exception e){
            System.out.println("Exception");
        }

        System.out.println("执行完毕");
    }
}

如果try中遇到的问题没有被捕获，怎么执行?
- 相当于try…catch的代码白写了，最终还是会交给虚拟机进行处理
如果try中遇到了问题，那么try下面的其他代码还会执行吗?
- 下面的代码就不会执行了，直接跳转到相应的catch中，执行catch的语句体
- 但是如果没有对应catch与之匹配，那么还是会交给虚拟机进行执行

1.6、异常中的常见方法

Throwable的成员方法

方法名称	说明
public string getMessage()	返回此 throwable的详细消息字符串
public string toString()	返回此可抛出的简短描述
public void printStackTrace()	把异常的错误信息输出在控制台

printStackTrace()
- 底层利用System.err.println进行输出
- 把异常以红色的字体打印出来
- 该方法结束之后不会停止程序运行

package Exception;

public class Dome5 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        try {
            System.out.println(arr[6]);
        }catch (ArrayIndexOutOfBoundsException e){
            String message = e.getMessage();
            System.out.println(message);

            String s = e.toString();
            System.out.println(s);

            e.printStackTrace();
        }
        System.out.println("执行了这段代码");
    }
}

1.7、抛出处理

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

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

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

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

package Exception;

public class Dome6 {
    public static void main(String[] args) {
        int[] arr = null;
        int max = 0;
        try {
            max = getMax(arr);
        } catch (NullPointerException e) {
            System.out.println("空指针异常");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("索引越界异常");
        }
        System.out.println(max);
        System.out.println("这段代码执行了");

    }
    public static int getMax(int[] arr) throws NullPointerException,ArrayIndexOutOfBoundsException/*这里的代码可以写可以不写*/{
        if (arr==null){
            //手动创建一个异常对象，并把这个异常交给方法的调用者处理
            //临时方法就会结束，下面的代码不会再执行了
            throw new NullPointerException();
        }

        if (arr.length==0){
            //手动创建一个异常对象，并把这个异常交给方法的调用者处理
            //此时方法就会结束，下面的代码就不会再执行了
            throw new ArrayIndexOutOfBoundsException();
        }
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]>max){
                max = arr[i];
            }
        }
        return max;
    }
}
}

1.8、异常-练习（键盘录入数据）

在这里插入图片描述

package Exception;

import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) {

        String name = "";
        int age = 0;
        Scanner sc = new Scanner(System.in);
        GrilFriend g1 = new GrilFriend();
        while (true) {
            try {
                System.out.println("请输入女朋友姓名");
                name =  sc.nextLine();
                g1.setName(name);

                System.out.println("请输入女朋友年龄");
                age = Integer.parseInt(sc.nextLine());
                g1.setAge(age);
                //如果所有的数据都是正确的就跳出循环
                break;
            //在格式化数字的时候，如果数字有误就会抛出异常
            }catch (NumberFormatException e){
                e.printStackTrace();
                continue;
            } catch (NameFormatExpection e){
                e.printStackTrace();
                continue;
            }catch (AgeFormatExpection e){
                e.printStackTrace();
                continue;
            }
        }
        System.out.println(g1);
    }
}

package Exception;

public class GrilFriend {
    private String name;
    private int age;
    public GrilFriend() {
    }
    public GrilFriend(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public String toString() {
        return "GrilFriend{name = " + name + ", age = " + age + "}";
    }
    public void setName(String name) {
        if (name.length()<3||name.length()>10){
            throw new NameFormatExpection("姓名长度有误，应该在 3~10 之间");
        }
            this.name = name;
    }
    public void setAge(int age) {
        if (age<18||age>40){
            throw new AgeFormatExpection("年龄长度有误，应该在 18~40 之间");
        }
            this.age = age;

    }
}
package Exception;

public class NameFormatExpection extends RuntimeException{
    public NameFormatExpection() {
    }

    public NameFormatExpection(String message) {
        super(message);
    }
}
package Exception;

public class AgeFormatExpection extends RuntimeException{
    public AgeFormatExpection() {
    }

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

1.9、自定义异常

定义异常类
写继承关系
- 如果是运行时期异常要继承RuntimeException
- 如果是编译时期异常要继承Exception
空参构造
带参构造

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

自定义一个年龄格式化出现问题的异常

package Exception;

public class AgeFormatExpection extends RuntimeException{
    public AgeFormatExpection() {
    }

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

自定义一个姓名格式化出现问题的异常

package Exception;

public class NameFormatExpection extends RuntimeException{
    public NameFormatExpection() {
    }

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

二、File

2.1、File的概述和构造

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

方法名称	说明
public File(string pathname)	根据文件路径创建文件对象
public File(string parent，String child)	根据父路径名字符串和子路径名字符串创建文件对象
public File(File parent，String child)	根据父路径对应文件对象和子路径名字符串创建文件对象

package File;

import java.io.File;

public class Dome1 {
    public static void main(String[] args) {
        //"D:\\学习资料文件\\2023上半年全国计算机等级考试成绩发布.xls"

        String str = "D:\\学习资料文件\\2023上半年全国计算机等级考试成绩发布.xls";
        File f1 = new File(str);
        System.out.println(f1);

        String str2 = "D:\\学习资料文件";
        String str3 = "\\2023上半年全国计算机等级考试成绩发布.xls";
        File f2 = new File(str2+str3);
        System.out.println(f2);

        File parent = new File(str2);
        File f3 = new File(parent+str3);
        System.out.println(f3);
    }
}

绝对路径和相对路径是什么意思?

绝对路径是带盘符的。
相对路径是不带盘符的，默认到当前项目下去找。

2.2、File的成员方法

2.2.1、File的常见方法（判断、获取）

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

length()
- 这个方法只能获取文件的大小，单位是字节
- 该方法无法获取文件夹的大小，如果需要获取文件夹的大小，需要把所有的文件大小都累加到一起
getAbsolutePath()
- 不管File获取的是绝对路径还是相对路径，返回的都是绝对路径
getName()
- 调用者是文件，则返回的是文件的名称以及后缀
- 调用者是文件夹，则返回的是文件夹的名称

package File;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class Dome2 {
    public static void main(String[] args) {
        String str = "D:\\学习资料文件\\2023上半年全国计算机等级考试成绩发布.xls";

        File f1 = new File(str);
        //判断该File是否存在
        boolean exists = f1.exists();
        System.out.println(exists);
        //判断该File是否为文件
        boolean file = f1.isFile();
        System.out.println(file);
        //判断该File是否为文件夹
        boolean directory = f1.isDirectory();
        System.out.println(directory);
        //返回文件的大小(字节数量)
        long length = f1.length();
        System.out.println(length);
        //返回文件的绝对路径
        String absolutePath = f1.getAbsolutePath();
        System.out.println(absolutePath);
        //返回定义文件时使用的路径
        String path = f1.getPath();
        System.out.println(path);
        //返回文件的名称，带后缀
        String name = f1.getName();
        System.out.println(name);
        //返回该文件最后一次修改的时间
        long l = f1.lastModified();
        System.out.println(l);

        Calendar c1 = Calendar.getInstance();
        Date d1 = new Date(0L);
        c1.setTime(d1);
        c1.setTimeInMillis(l);
        System.out.print(c1.get(Calendar.YEAR)+"年");
        System.out.print(c1.get(Calendar.MONTH)+"月");
        System.out.print(c1.get(Calendar.DAY_OF_MONTH)+"日");

        Date d2 = new Date(l);
        SimpleDateFormat sdf1 = new SimpleDateFormat("YYYY年MM月dd HH:mm:ss EE");
        String format = sdf1.format(d2);
        System.out.println(format);
    }
}

2.2.2、File的常见方法（创建、删除）

方法名称	说明
public boolean createNewFile()	创建一个新的空的文件
public boolean mkdir()	创建单级文件夹
public boolean mkdirs()	创建多级文件夹
public boolean delete()	删除文件、空文件夹

createNewFile()
- 细节一：
  - 如果当前路径表示的文件是不存在的，则创建成功，方法返回true
  - 如果当前路径表示的文件是存在的，则创建失败，方法返回false
- 细节二：
  - 如果父级路径是不存在的，那么方法会有异常（IOExpection）
- 细节三：
  - createNewFile方法创建的一定是文件，如果路径中不包含后缀名，则创建一个没有后缀的文件
mkdir()
- 细节一: windows当中路径是唯一的，如果当前路径已经存在，则创建失败，返回false
- 细节二: mkdir方法只能创建单级文件夹，无法创建多级文件夹。
mkdirs()
- 细节：既可以创建多级的又可以创建单级的
delete
- 细节:
  - 如果删除的是文件，则直接删除，不走回收站。
  - 如果删除的是空文件夹，则直接删除，不走回收站
  - 如果删除的是有内容的文件夹，则删除失败

package File;

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

public class Dome3 {
    public static void main(String[] args) throws IOException {
        String str = "D:\\学习资料文件\\2023上半年全国计算机等级考试成绩发布.xls";

        File f1 = new File("D:\\学习资料文件\\a.txt");

        boolean b1 =  f1.createNewFile();
        System.out.println(b1);

        File f2 = new File("D:\\学习资料文件\\aaa");
        boolean mkdir = f2.mkdir();
        System.out.println(mkdir);

        File f3  = new File("D:\\学习资料文件\\aa1\\aa2\\aa2");
        boolean mkdirs = f3.mkdirs();
        System.out.println(mkdirs);

        boolean delete3 = f2.delete();//true
        System.out.println(delete3);
        boolean delete = f1.delete();//true
        System.out.println(delete);
        boolean delete1 = f3.delete();
        System.out.println(delete1);
    }
}

2.2.3、File的常见方法（获取并遍历）

方法名称	说明
public File[ ] listFiles()	获取当前该路径下所有内容

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

package File;

import java.io.File;

public class Dome4 {
    public static void main(String[] args) {
        File f = new File("D:\\学习资料文件");

        File[] files = f.listFiles();
        for (File file : files) {
            //file依次表示文件夹下的文件或者文件夹
            System.out.println(file);
        }
    }
}

2.2.4、File的常见方法（所有获取并遍历）

方法名称	说明
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)	利用文件名过滤器获取当前该路径下所有内容

package File;

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

public class Dome5 {
    public static void main(String[] args) {
        File f = new File("D:\\学习资料文件");
        File[] files = File.listRoots();
        for (File file : files) {
            System.out.println(file);
        }

        String[] list = f.list();
        for (String s : list) {
            System.out.println(s);
        }
        String[] list2 = f.list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                File f1 = new File(dir,name);
                return f1.isFile()&&f1.getName().endsWith(".pdf");
            }
        });
        for (String s : list2) {
            System.out.println(s);
        }

        File[] xlsxes = f.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.isFile() && pathname.getName().endsWith("xlsx");
            }
        });
        for (File xlsx : xlsxes) {
            System.out.println(xlsx);
        }
    }
}

2.3、综合练习

2.3.1、在当前模块下的aaa文件夹中创建一个a.txt文件

在这里插入图片描述

package File;

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

public class Test1 {
    public static void main(String[] args) throws IOException {
        File f1 = new File("aaa");
        boolean mkdirs = f1.mkdirs();
        System.out.println(mkdirs);

        File f2 = new File(f1,"a.txt");
        boolean newFile = f2.createNewFile();
        System.out.println(newFile);
    }
}

2.3.2、定义一个方法找某一个文件夹中，是否有以avi结尾的电影

在这里插入图片描述

package File;

import java.io.File;

public class Test2 {
    public static void main(String[] args) {
        File f = new File("D:\\学习资料文件");
        System.out.println(isAvi(f));
    }
    public static boolean isAvi(File f){
        File[] files = f.listFiles();
        for (File file : files) {
            if (file.isFile()&&file.getName().endsWith("avi")){
                return true;
            }
        }
        return false;
    }
}

2.3.3、找到电脑中所有以avi结尾的电影

在这里插入图片描述

使用递归的思想

package File;

import java.io.File;

public class Test3 {
    public static void main(String[] args) {
        //1.进入文件夹
        //2.遍历数组
        //3.判断
        //4.判断
        findAVI();
    }
    public static void findAVI(){
        File[] files = File.listRoots();
        //遍历所有的盘符
        for (File file : files) {
            findAVI(file);
        }
    }
    public static void findAVI(File file){
        File[] files = file.listFiles();

        if (files!=null){
            //判断该file是否为文件，
            // 如果是文件则打印，
            // 如果是文件夹则进行递归调用该函数，遍历该文件夹
            for (File file1 : files) {
                if (file1.isFile()){
                    String name = file1.getName();
                    if (name.endsWith(".avi")){
                        System.out.println(file1);
                    }
                }else {
                    findAVI(file1);
                }
            }
        }
    }
}

2.3.4、删除一个多级文件夹

在这里插入图片描述

package File;

import java.io.File;

public class Test4 {
    public static void main(String[] args) {
        //进入一个多级文件夹
        //D:\Java\aaa
        //采用递归的方法，
        // 遇到文件则删除
        // 遇到文件夹则遍历

        File f1 = new File("D:\\Java\\aaa");
        deleteFile(f1);
    }
    public static void deleteFile(File file){
        File[] files = file.listFiles();
        for (File file1 : files) {
            //判断是否为文件
            if(file1.isFile()){
                file1.delete();
            }else {
                //如果是文件夹则递归该函数
                deleteFile(file1);
            }
        }
        file.delete();
    }
}

2.3.5、统计一个文件夹的总大小

在这里插入图片描述

package File;

import java.io.File;

public class Test6 {
    public static void main(String[] args) {
        //"D:\学习资料文件"
        File f = new File("D:\\学习资料文件");
        long num = getNum(f);
        System.out.println(num);
    }
    public static long getNum(File file){
        long len = 0;
        File[] files = file.listFiles();
        for (File file1 : files) {
            if (file1.isFile()){
                len = len + file1.length();
            }else {
                //累加所有文件夹的大小
                len = len + getNum(file1);
            }
        }
        return len;
    }
}

2.3.6、统计一个文件夹中每种文件的个数并打印（考虑子文件夹）

在这里插入图片描述
方法一：

package File;

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

public class Test5 {
    public static void main(String[] args) {
        //"D:\互联网+项目"
        Map<String,Integer> hm = new HashMap<>();
        File f = new File("D:\\互联网+项目");
        getdex(f,hm);
        Set<Map.Entry<String, Integer>> entries = hm.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
    }
    public static void getdex(File file,Map<String,Integer> hm){

        File[] files = file.listFiles();
        for (File file1 : files) {
            if (file1.isFile()){
                String name = file1.getName();
                //使用 \\. 转义的 . 来分割字符串
                String[] split = name.split("\\.");
                //如果数组长度大于2则采用以下的方法
                if (split.length>=2) {
                    if (hm.containsKey(split[split.length - 1])) {
                        //先得到这个后缀的次数
                        int count = hm.get(split[split.length - 1]);
                        //在进行++
                        count++;
                        //重新存入
                        hm.put(split[split.length - 1], count);
                    } else {
                        //如不这个后缀不重复
                        hm.put(split[split.length - 1], 1);
                    }
                }
            }else {
                //如果是文件夹回调这个函数
                getdex(file1,hm);
            }
        }
    }
}

方法二：

package File;

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

public class Test5_2 {
    public static void main(String[] args) {
        File f = new File("D:\\高数");
        Map<String, Integer> map = getdex1(f);
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
                System.out.println(entry.getKey()+":"+entry.getValue());
            }
    }

    public static Map<String, Integer> getdex1(File file) {
        Map<String, Integer> hm = new HashMap<>();
        File[] files = file.listFiles();
        for (File file1 : files) {
            if (file1.isFile()) {
                String name = file1.getName();
                //使用 \\. 转义的 . 来分割字符串
                String[] split = name.split("\\.");
                //如果数组长度大于2则采用以下的方法
                if (split.length >= 2) {
                    if (hm.containsKey(split[split.length - 1])) {
                        //先得到这个后缀的次数
                        int count = hm.get(split[split.length - 1]);
                        //在进行++
                        count++;
                        //重新存入
                        hm.put(split[split.length - 1], count);
                    } else {
                        //如不这个后缀不重复
                        hm.put(split[split.length - 1], 1);
                    }
                }
            } else {
                //如果是文件夹回调这个函数
                Map<String, Integer> somHm = getdex1(file1);
                Set<Map.Entry<String, Integer>> entries = somHm.entrySet();
                for (Map.Entry<String, Integer> entry : entries) {
                    Integer value = entry.getValue();
                    String key = entry.getKey();
                    if (hm.containsKey(key)){
                        int count = hm.get(key);
                        count = count + value;
                        hm.put(key,count);
                    }else{
                        hm.put(key,value);
                    }
                }
            }
        }
        return hm;
    }
}