Java stream&File

1.Stream流

1.1体验Stream流【理解】

  • 案例需求

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

    • 创建一个集合,存储多个字符串元素

    • 把集合中所有以"张"开头的元素存储到一个新的集合

    • 把"张"开头的集合中的长度为3的元素存储到一个新的集合

    • 遍历上一步得到的集合

  • 原始方式示例代码

    public class MyStream1 {
        public static void main(String[] args) {
            //集合的批量添加
            ArrayList list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"));
            //list.add()
    ​
            //遍历list1把以张开头的元素添加到list2中。
            ArrayList list2 = new ArrayList<>();
            for (String s : list1) {
                if(s.startsWith("张")){
                    list2.add(s);
                }
            }
            //遍历list2集合,把其中长度为3的元素,再添加到list3中。
            ArrayList list3 = new ArrayList<>();
            for (String s : list2) {
                if(s.length() == 3){
                    list3.add(s);
                }
            }
            for (String s : list3) {
                System.out.println(s);
            }      
        }
    }

  • 使用Stream流示例代码

    public class StreamDemo {
        public static void main(String[] args) {
            //集合的批量添加
            ArrayList list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"));
    ​
            //Stream流
            list1.stream().filter(s->s.startsWith("张"))
                    .filter(s->s.length() == 3)
                    .forEach(s-> System.out.println(s));
        }
    }

  • Stream流的好处

    • 直接阅读代码的字面意思即可完美展示无关逻辑方式的语义:获取流、过滤姓张、过滤长度为3、逐一打印

    • Stream流把真正的函数式编程风格引入到Java中

    • 代码简洁

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

  • Stream流的思想

  • Java stream&File_第1张图片

  • Stream流的三类方法

    • 获取Stream流

      • 创建一条流水线,并把数据放到流水线上准备进行操作

    • 中间方法

      • 流水线上的操作

      • 一次操作完毕之后,还可以继续进行其他操作

    • 终结方法

      • 一个Stream流只能有一个终结方法

      • 是流水线上的最后一个操作

  • 生成Stream流的方式

    • Collection体系集合

      使用默认方法stream()生成流, default Stream stream()

    • Map体系集合

      把Map转成Set集合,间接的生成流

    • 数组

      通过Arrays中的静态方法stream生成流

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

      通过Stream接口的静态方法of(T... values)生成流

  • 代码演示

    public class StreamDemo {
        public static void main(String[] args) {
            //Collection体系的集合可以使用默认方法stream()生成流
            List list = new ArrayList();
            Stream listStream = list.stream();
    ​
            Set set = new HashSet();
            Stream setStream = set.stream();
    ​
            //Map体系的集合间接的生成流
            Map map = new HashMap();
            Stream keyStream = map.keySet().stream();
            Stream valueStream = map.values().stream();
            Stream> entryStream = map.entrySet().stream();
    ​
            //数组可以通过Arrays中的静态方法stream生成流
            String[] strArray = {"hello","world","java"};
            Stream strArrayStream = Arrays.stream(strArray);
          
            //同种数据类型的多个数据可以通过Stream接口的静态方法of(T... values)生成流
            Stream strArrayStream2 = Stream.of("hello", "world", "java");
            Stream intStream = Stream.of(10, 20, 30);
        }
    }

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代码演示

    public class MyStream3 {
        public static void main(String[] args) {
    //        Stream filter(Predicate predicate):过滤
    //        Predicate接口中的方法   boolean test(T t):对给定的参数进行判断,返回一个布尔值
    ​
            ArrayList list = new ArrayList<>();
            list.add("张三丰");
            list.add("张无忌");
            list.add("张翠山");
            list.add("王二麻子");
            list.add("张良");
            list.add("谢广坤");
    ​
            //filter方法获取流中的 每一个数据.
            //而test方法中的s,就依次表示流中的每一个数据.
            //我们只要在test方法中对s进行判断就可以了.
            //如果判断的结果为true,则当前的数据留下
            //如果判断的结果为false,则当前数据就不要.
    //        list.stream().filter(
    //                new Predicate() {
    //                    @Override
    //                    public boolean test(String s) {
    //                        boolean result = s.startsWith("张");
    //                        return result;
    //                    }
    //                }
    //        ).forEach(s-> System.out.println(s));
    ​
            //因为Predicate接口中只有一个抽象方法test
            //所以我们可以使用lambda表达式来简化
    //        list.stream().filter(
    //                (String s)->{
    //                    boolean result = s.startsWith("张");
    //                        return result;
    //                }
    //        ).forEach(s-> System.out.println(s));
    ​
            list.stream().filter(s ->s.startsWith("张")).forEach(s-> System.out.println(s));
    ​
        }
    }

  • limit&skip代码演示

    public class StreamDemo02 {
        public static void main(String[] args) {
            //创建一个集合,存储多个字符串元素
            ArrayList list = new ArrayList();
    ​
            list.add("林青霞");
            list.add("张曼玉");
            list.add("王祖贤");
            list.add("柳岩");
            list.add("张敏");
            list.add("张无忌");
    ​
            //需求1:取前3个数据在控制台输出
            list.stream().limit(3).forEach(s-> System.out.println(s));
            System.out.println("--------");
    ​
            //需求2:跳过3个元素,把剩下的元素在控制台输出
            list.stream().skip(3).forEach(s-> System.out.println(s));
            System.out.println("--------");
    ​
            //需求3:跳过2个元素,把剩下的元素中前2个在控制台输出
            list.stream().skip(2).limit(2).forEach(s-> System.out.println(s));
        }
    }

  • concat&distinct代码演示

    public class StreamDemo03 {
        public static void main(String[] args) {
            //创建一个集合,存储多个字符串元素
            ArrayList list = new ArrayList();
    ​
            list.add("林青霞");
            list.add("张曼玉");
            list.add("王祖贤");
            list.add("柳岩");
            list.add("张敏");
            list.add("张无忌");
    ​
            //需求1:取前4个数据组成一个流
            Stream s1 = list.stream().limit(4);
    ​
            //需求2:跳过2个数据组成一个流
            Stream s2 = list.stream().skip(2);
    ​
            //需求3:合并需求1和需求2得到的流,并把结果在控制台输出
    //        Stream.concat(s1,s2).forEach(s-> System.out.println(s));
    ​
            //需求4:合并需求1和需求2得到的流,并把结果在控制台输出,要求字符串元素不能重复
            Stream.concat(s1,s2).distinct().forEach(s-> System.out.println(s));
        }
    }

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

  • 概念

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

  • 常见方法

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

    public class MyStream5 {
        public static void main(String[] args) {
            ArrayList list = new ArrayList<>();
            list.add("张三丰");
            list.add("张无忌");
            list.add("张翠山");
            list.add("王二麻子");
            list.add("张良");
            list.add("谢广坤");
    ​
            //method1(list);
            
    //        long count():返回此流中的元素数
            long count = list.stream().count();
            System.out.println(count);
        }
    ​
        private static void method1(ArrayList list) {
            //  void forEach(Consumer action):对此流的每个元素执行操作
            //  Consumer接口中的方法void accept(T t):对给定的参数执行此操作
            //在forEach方法的底层,会循环获取到流中的每一个数据.
            //并循环调用accept方法,并把每一个数据传递给accept方法
            //s就依次表示了流中的每一个数据.
            //所以,我们只要在accept方法中,写上处理的业务逻辑就可以了.
            list.stream().forEach(
                    new Consumer() {
                        @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));
        }
    }

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

  • 概念

    对数据使用Stream流的方式操作完毕后,可以把流中的数据收集到集合中

  • 常用方法

    方法名 说明
    R collect(Collector collector) 把结果收集到集合中
  • 工具类Collectors提供了具体的收集方式

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

    // toList和toSet方法演示 
    public class MyStream7 {
        public static void main(String[] args) {
            ArrayList list1 = new ArrayList<>();
            for (int i = 1; i <= 10; i++) {
                list1.add(i);
            }
    ​
            list1.add(10);
            list1.add(10);
            list1.add(10);
            list1.add(10);
            list1.add(10);
    ​
            //filter负责过滤数据的.
            //collect负责收集数据.
                    //获取流中剩余的数据,但是他不负责创建容器,也不负责把数据添加到容器中.
            //Collectors.toList() : 在底层会创建一个List集合.并把所有的数据添加到List集合中.
            List list = list1.stream().filter(number -> number % 2 == 0)
                    .collect(Collectors.toList());
    ​
            System.out.println(list);
    ​
        Set set = list1.stream().filter(number -> number % 2 == 0)
                .collect(Collectors.toSet());
        System.out.println(set);
    }
    }
    /**
    Stream流的收集方法 toMap方法演示
    创建一个ArrayList集合,并添加以下字符串。字符串中前面是姓名,后面是年龄
    "zhangsan,23"
    "lisi,24"
    "wangwu,25"
    保留年龄大于等于24岁的人,并将结果收集到Map集合中,姓名为键,年龄为值
    */
    public class MyStream8 {
        public static void main(String[] args) {
            ArrayList list = new ArrayList<>();
            list.add("zhangsan,23");
            list.add("lisi,24");
            list.add("wangwu,25");
    ​
            Map map = list.stream().filter(
                    s -> {
                        String[] split = s.split(",");
                        int age = Integer.parseInt(split[1]);
                        return age >= 24;
                    }
    ​
             //   collect方法只能获取到流中剩余的每一个数据.
             //在底层不能创建容器,也不能把数据添加到容器当中
    ​
             //Collectors.toMap 创建一个map集合并将数据添加到集合当中
    ​
              // s 依次表示流中的每一个数据
    ​
              //第一个lambda表达式就是如何获取到Map中的键
              //第二个lambda表达式就是如何获取Map中的值
            ).collect(Collectors.toMap(
                    s -> s.split(",")[0],
                    s -> Integer.parseInt(s.split(",")[1]) ));
    ​
            System.out.println(map);
        }
    }

1.6Stream流综合练习【应用】

  • 案例需求

    现在有两个ArrayList集合,分别存储6名男演员名称和6名女演员名称,要求完成如下的操作

    • 男演员只要名字为3个字的前三人

    • 女演员只要姓林的,并且不要第一个

    • 把过滤后的男演员姓名和女演员姓名合并到一起

    • 把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据

    演员类Actor已经提供,里面有一个成员变量,一个带参构造方法,以及成员变量对应的get/set方法

  • 代码实现

    演员类

    public class Actor {
        private String name;
    ​
        public Actor(String name) {
            this.name = name;
        }
    ​
        public String getName() {
            return name;
        }
    ​
        public void setName(String name) {
            this.name = name;
        }
    }

    测试类

    public class StreamTest {
        public static void main(String[] args) {
            //创建集合
            ArrayList manList = new ArrayList();
            manList.add("周润发");
            manList.add("成龙");
            manList.add("刘德华");
            manList.add("吴京");
            manList.add("周星驰");
            manList.add("李连杰");
      
            ArrayList womanList = new ArrayList();
            womanList.add("林心如");
            womanList.add("张曼玉");
            womanList.add("林青霞");
            womanList.add("柳岩");
            womanList.add("林志玲");
            womanList.add("王祖贤");
      
            //男演员只要名字为3个字的前三人
            Stream manStream = manList.stream().filter(s -> s.length() == 3).limit(3);
      
            //女演员只要姓林的,并且不要第一个
            Stream womanStream = womanList.stream().filter(s -> s.startsWith("林")).skip(1);
      
            //把过滤后的男演员姓名和女演员姓名合并到一起
            Stream stream = Stream.concat(manStream, womanStream);
      
            // 将流中的数据封装成Actor对象之后打印
            stream.forEach(name -> {
                Actor actor = new Actor(name);
                System.out.println(actor);
            }); 
        }
    }

2.File类

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

  • File类介绍

    • 它是文件和目录路径名的抽象表示

    • 文件和目录是可以通过File封装成对象的

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

  • File类的构造方法

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

    public class FileDemo01 {
        public static void main(String[] args) {
            //File(String pathname): 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
            File f1 = new File("E:\\itcast\\java.txt");
            System.out.println(f1);
    ​
            //File(String parent, String child): 从父路径名字符串和子路径名字符串创建新的 File实例
            File f2 = new File("E:\\itcast","java.txt");
            System.out.println(f2);
    ​
            //File(File parent, String child): 从父抽象路径名和子路径名字符串创建新的 File实例
            File f3 = new File("E:\\itcast");
            File f4 = new File(f3,"java.txt");
            System.out.println(f4);
        }
    }

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

  • 绝对路径

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

  • 相对路径

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

  • 示例代码

    public class FileDemo02 {
        public static void main(String[] args) {
            // 是一个完整的路径,从盘符开始
            File file1 = new File("D:\\itheima\\a.txt");
    ​
            // 是一个简化的路径,从当前项目根目录开始
            File file2 = new File("a.txt");
            File file3 = new File("模块名\\a.txt");
        }
    }

2.3File类创建功能【应用】

  • 方法分类

    方法名 说明
    public boolean createNewFile() 当具有该名称的文件不存在时,创建一个由该抽象路径名命名的新空文件
    public boolean mkdir() 创建由此抽象路径名命名的目录
    public boolean mkdirs() 创建由此抽象路径名命名的目录,包括任何必需但不存在的父目录
  • 示例代码.4File类删除功能【应用】

    public class FileDemo02 {
        public static void main(String[] args) throws IOException {
            //需求1:我要在E:\\itcast目录下创建一个文件java.txt
            File f1 = new File("E:\\itcast\\java.txt");
            System.out.println(f1.createNewFile());
            System.out.println("--------");
    ​
            //需求2:我要在E:\\itcast目录下创建一个目录JavaSE
            File f2 = new File("E:\\itcast\\JavaSE");
            System.out.println(f2.mkdir());
            System.out.println("--------");
    ​
            //需求3:我要在E:\\itcast目录下创建一个多级目录JavaWEB\\HTML
            File f3 = new File("E:\\itcast\\JavaWEB\\HTML");
    //        System.out.println(f3.mkdir());
            System.out.println(f3.mkdirs());
            System.out.println("--------");
    ​
            //需求4:我要在E:\\itcast目录下创建一个文件javase.txt
            File f4 = new File("E:\\itcast\\javase.txt");
    //        System.out.println(f4.mkdir());
            System.out.println(f4.createNewFile());
        }
    }

2.4File类删除功能【应用】

  • 方法分类

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

    public class FileDemo03 {
        public static void main(String[] args) throws IOException {
    //        File f1 = new File("E:\\itcast\\java.txt");
            //需求1:在当前模块目录下创建java.txt文件
            File f1 = new File("myFile\\java.txt");
    //        System.out.println(f1.createNewFile());
    ​
            //需求2:删除当前模块目录下的java.txt文件
            System.out.println(f1.delete());
            System.out.println("--------");
    ​
            //需求3:在当前模块目录下创建itcast目录
            File f2 = new File("myFile\\itcast");
    //        System.out.println(f2.mkdir());
    ​
            //需求4:删除当前模块目录下的itcast目录
            System.out.println(f2.delete());
            System.out.println("--------");
    ​
            //需求5:在当前模块下创建一个目录itcast,然后在该目录下创建一个文件java.txt
            File f3 = new File("myFile\\itcast");
    //        System.out.println(f3.mkdir());
            File f4 = new File("myFile\\itcast\\java.txt");
    //        System.out.println(f4.createNewFile());
    ​
            //需求6:删除当前模块下的目录itcast
            System.out.println(f4.delete());
            System.out.println(f3.delete());
        }
    }

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对象数组
  • 示例代码

    public class FileDemo04 {
        public static void main(String[] args) {
            //创建一个File对象
            File f = new File("myFile\\java.txt");
    ​
    //        public boolean isDirectory():测试此抽象路径名表示的File是否为目录
    //        public boolean isFile():测试此抽象路径名表示的File是否为文件
    //        public boolean exists():测试此抽象路径名表示的File是否存在
            System.out.println(f.isDirectory());
            System.out.println(f.isFile());
            System.out.println(f.exists());
    ​
    //        public String getAbsolutePath():返回此抽象路径名的绝对路径名字符串
    //        public String getPath():将此抽象路径名转换为路径名字符串
    //        public String getName():返回由此抽象路径名表示的文件或目录的名称
            System.out.println(f.getAbsolutePath());
            System.out.println(f.getPath());
            System.out.println(f.getName());
            System.out.println("--------");
    ​
    //        public File[] listFiles():返回此抽象路径名表示的目录中的文件和目录的File对象数组
            File f2 = new File("E:\\itcast");
            File[] fileArray = f2.listFiles();
            for(File file : fileArray) {
    //            System.out.println(file);
    //            System.out.println(file.getName());
                if(file.isFile()) {
                    System.out.println(file.getName());
                }
            }
        }
    }

2.6File类练习一【应用】

  • 案例需求

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

  • 实现步骤

    • 创建File对象,指向aaa文件夹

    • 判断aaa文件夹是否存在,如果不存在则创建

    • 创建File对象,指向aaa文件夹下的a.txt文件

    • 创建这个文件

  • 代码实现

    public class Test1 {
        public static void main(String[] args) throws IOException {
            //练习一:在当前模块下的aaa文件夹中创建一个a.txt文件
           /* File file = new File("filemodule\\aaa\\a.txt");
            file.createNewFile();*/
            //注意点:文件所在的文件夹必须要存在.
    ​
            //1.创建File对象,指向aaa文件夹
            File file = new File("filemodule\\aaa");
            //2.判断aaa文件夹是否存在,如果不存在则创建
            if(!file.exists()){
                //如果文件夹不存在,就创建出来
                file.mkdirs();
            }
            //3.创建File对象,指向aaa文件夹下的a.txt文件
            File newFile = new File(file,"a.txt");
            //4.创建这个文件
            newFile.createNewFile();
        }
    }

2.7File类练习二【应用】

  • 案例需求

    删除一个多级文件夹

  • 实现步骤

    • 定义一个方法,接收一个File对象

    • 遍历这个File对象,获取它下边的每个文件和文件夹对象

    • 判断当前遍历到的File对象是文件还是文件夹

    • 如果是文件,直接删除

    • 如果是文件夹,递归调用自己,将当前遍历到的File对象当做参数传递

    • 参数传递过来的文件夹File对象已经处理完成,最后直接删除这个空文件夹

  • 代码实现

    public class Test2 {
        public static void main(String[] args) {
            //练习二:删除一个多级文件夹
            //delete方法
            //只能删除文件和空文件夹.
            //如果现在要删除一个有内容的文件夹?
            //先删掉这个文件夹里面所有的内容.
            //最后再删除这个文件夹
    ​
            File src = new File("C:\\Users\\apple\\Desktop\\src");
            deleteDir(src);
        }
      
        //1.定义一个方法,接收一个File对象
        private static void deleteDir(File src) {
            //先删掉这个文件夹里面所有的内容.
            //递归 方法在方法体中自己调用自己.
            //注意: 可以解决所有文件夹和递归相结合的题目
            //2.遍历这个File对象,获取它下边的每个文件和文件夹对象
            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类练习三【应用】

  • 案例需求

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

    打印格式如下:

    txt:3个

    doc:4个

    jpg:6个

  • 实现步骤

    • 定义一个方法,参数是HashMap集合用来统计次数和File对象要统计的文件夹

    • 遍历File对象,获取它下边的每一个文件和文件夹对象

    • 判断当前File对象是文件还是文件夹

    • 如果是文件,判断这种类型文件后缀名在HashMap集合中是否出现过

      • 没出现过,将这种类型文件的后缀名存入集合中,次数存1

      • 出现过,获取这种类型文件的后缀名出现的次数,对其+1,在存回集合中

    • 如果是文件夹,递归调用自己,HashMap集合就是参数集合,File对象是当前文件夹对象

  • 代码实现

    public class Test3 {
        public static void main(String[] args) {
            //统计一个文件夹中,每种文件出现的次数.
            //统计 --- 定义一个变量用来统计. ---- 弊端:同时只能统计一种文件
            //利用map集合进行数据统计,键 --- 文件后缀名  值 ----  次数
    ​
            File file = new File("filemodule");
            HashMap hm = new HashMap<>();
            getCount(hm, file);
            System.out.println(hm);
        }
      
        //1.定义一个方法,参数是HashMap集合用来统计次数和File对象要统计的文件夹
        private static void getCount(HashMap 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);
                }
            }
        }
      
    }

你可能感兴趣的:(Java,开发语言,java)