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流概述【理解】
      • 1.2Stream流的常见生成方式【应用】
      • 1.3Stream流中间操作方法【应用】
      • 1.4Stream流终结操作方法【应用】
      • 1.5Stream流的收集操作【应用】
    • 2.File类
      • 2.1File类概述和构造方法【应用】
      • 2.2绝对路径和相对路径【理解】
      • 2.3File类创建功能【应用】
      • 2.4File类删除功能【应用】
      • 2.5File类判断和获取功能【应用】
      • 2.6File类练习一:创建文件【应用】
      • 2.7File类练习二:删除一个多级文件夹【应用】
      • 2.8File类练习三: 统计文件夹中每种文件的个数【应用】


1.Stream流

1.1Stream流概述【理解】

  • Stream流的好处

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

  • 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 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 filter(Predicate 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
JavaSE进阶09:Stream流、File类_第2张图片
File file3 = new File(“FileModule\b.txt”);//当前项目的FileModule模块下的b.txt
JavaSE进阶09:Stream流、File类_第3张图片

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,因为文件和目录都已存在
*/

JavaSE进阶09:Stream流、File类_第4张图片
JavaSE进阶09:Stream流、File类_第5张图片

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类练习三: 统计文件夹中每种文件的个数【应用】

  • 案例需求

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

JavaSE进阶09:Stream流、File类_第6张图片

  • 实现步骤

    • 定义一个方法,参数是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}
*/

你可能感兴趣的:(JAVA进阶笔记,JAVA)