Java进阶篇-2

标签：Java System 进阶篇文件夹 File println new out

不可变集合

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

    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流的使用步骤:

先得到一条Stream流(流水线)，并把数据放上去
利用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());

方法引用

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

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

//可以是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));

引用成员方法

格式: 对象::成员方法

其他类: 其他类对象::方法名
本类: this::方法名
父类: 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. 成员方法
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默认的处理方式

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

捕获异常

    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也重新写

自定义异常

定义异常类
写继承关系
空参构造
带参构造

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

//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()重载：

listFiles(FileFilter filter)


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

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;
    }
}

标签：Java,System,进阶篇,文件夹,File,println,new,out
From： https://www.cnblogs.com/shuijibaobao/p/17653919.html

不可变集合

Stream流

中间方法

终结方法

方法引用

引用静态方法

引用成员方法

引用构造方法

类名引用成员方法

引用数组的构造方法

异常

编译时异常和运行时异常

异常作用

处理异常

JVM默认的处理方式

捕获异常

异常常见方法

抛出处理

自定义异常

File

File成员方法

练习：

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

2.删除多级文件夹

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

4.统计文件个数

相关文章

赞助商

阅读排行

Java进阶篇-2

不可变集合

Stream流

中间方法

终结方法

方法引用

引用静态方法

引用成员方法

引用构造方法

类名引用成员方法

引用数组的构造方法

异常

编译时异常和运行时异常

异常作用

处理异常

JVM默认的处理方式

捕获异常

异常常见方法

抛出处理

自定义异常

File

File成员方法

练习：

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

2.删除多级文件夹

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

4.统计文件个数

相关文章

赞助商

阅读排行

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