【Java】全面理解Java8特性

一、Java8中Interface接口

二、lambda表达式

语法格式

[三、函数式接口Functional Interface](#三、函数式接口Functional Interface)

[1. 作用](#1. 作用)

[2. 内置函数式接(Built-in Functional Interfaces)](#2. 内置函数式接(Built-in Functional Interfaces))

[1. Filter 过滤](#1. Filter 过滤)

[2. Sorted 排序](#2. Sorted 排序)

[3. Map 映射](#3. Map 映射)

[4. Match 匹配](#4. Match 匹配)

[5. Collect收集](#5. Collect收集)

[6. Statistics 统计](#6. Statistics 统计)

[7. 函数式接口总结](#7. 函数式接口总结)

五、日期时间

[1. 格式化](#1. 格式化)

[2. 字符串转日期格式](#2. 字符串转日期格式)

[3. 日期计算](#3. 日期计算)

[4. 获取指定日期](#4. 获取指定日期)

一、Java8中Interface接口

Java8 中，接口中除了抽象方法外，还可以定义default默认方法和 static 静态方法。

default修饰的默认方法，属于实例方法，可以被实现类调用或重写。

调用：实现类必须 implements 接口，才能调用该接口的 default 默认方法。

重写：实现类 implements不同接口时，接口中存在相同签名的方法(名称、参数、类型完全一致)，则实现类必须重写该方法明确方法定义;

static 修饰的静态方法，属于类的静态方法。但它不能被子类继承，只能用 interface 接口名称调用。

二、lambda表达式

Lambda表达式本质是一个匿名函数 ，用于把函数作为参数，传入方法中，实现函数式编程风格。

使用 Lambda表达式可以使代码变的更加简洁紧凑。

语法格式

（parameters)->expression或(parameters)->{statements;}

    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("s","sjv","safa","safth"));

        // Comparator接口的匿名实现方式（传统）
//        list.sort(new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                return o1.length()-o2.length();
//            }
//        });

        // lambda表达式的语法规则：(参数) -> {方法实现逻辑}
        // 使用lambda表达式,@FunctionalInterface接口,只有一个抽象方法（无方法体）
        // 通过lambda表达式实现Comparator接口
        list.sort((s1, s2) -> {
                        return s1.length()-s2.length();
                    });


        // 通过lambda表达式实现Consumer接口
        list.forEach((str)->{
            System.out.println(str.toUpperCase());
        });

        System.out.println(list);
    }

三、函数式接口Functional Interface

只有一个抽象方法的接口(可以定义多个非抽象方法)。可以使用 @FunctionalInterface 接

口定义，强化语义规范。

函数式接口，也被称为SAM接口(Single Abstract Method Interfaces)。

1. 作用

基于函数式接口，可以使用Lambda 表达式进行实现，实现函数式编程。

2. 内置函数式接(Built-in Functional Interfaces)

在 Java 8中专门有一个包放函数式接口 java.util.function ，该包下的所有接口都有 @FunctionalInterface 注解，提供函数式编程方式。

Predicate接口

Predicate 接口是只有一个参数的返回布尔类型值的断言型 接口。该接口包含多种默认方法来将Predicate 组合成其他复杂的逻辑 (比如:与 and，或or，非negate)。

    public static void main(String[] args) {
//        Predicate predicate = new Predicate() {
//            @Override
//            public boolean test(Object o) {
//                return false;
//            }
//        };
        List<String> arrayList = new ArrayList<>(Arrays.asList("Basic","QBasic","c","c++","PowerBuilder","go"));

        // 查找名称小于3个字符的元素
        Predicate<String> predicate1 = (lang)-> {
            if (lang.length()<=3) {
                return true;
            }
            return false;
        };

        // 查询前缀以"b"或"c"开头的元素
        Predicate<String> predicate2 = (lang)->{
            if (lang.toLowerCase().startsWith("b")||lang.toLowerCase().startsWith("c")){
                return true;
            }
            return false;
        };

        // 条件组合：形成"与" 或 "或"逻辑关系
        Predicate<String> predicate3 = predicate1.and(predicate2);
        Predicate<String> predicate4 = predicate1.or(predicate2);

        // "非"逻辑 (取反)
        Predicate<String> predicate5 = predicate1.negate();  // >3

        arrayList.forEach((lang)->{
            if (predicate1.test(lang)){
                System.out.println(lang);
            }
        });

    }

Function

Function 接口接受一个参数并生成结果。默认方法可用于将多个函数链接 在一起(compose，andThen)。

    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("Basic", "QBasic", "c", "c++", "PowerBuilder", "go"));

        // Function<参数类型,返回值类型>
        // 转换成大写字母形式
        Function<String, String> fun1 = (lang) -> {
            lang = lang.toUpperCase();
            return lang;
        };

        // 加上【】
        Function<String, String> fun2 = (lang) -> {
            lang = String.format("【%s】", lang);
            return lang;
        };

        // 组合
        Function<String, String> fun3 = fun1.andThen(fun2);  //先fun1，后fun2
        Function<String,String> fun4 = fun1.compose(fun2);

        list.forEach((lang) -> {
            String ret = fun3.apply(lang);
            System.out.println(ret);
        });
    }

Comparator

比较器接口，用于比较指定元素值的大小。 Java 8版本中，添加了多个新的 default 方法，用于比较器合并、反转等操作。

    public static void main(String[] args) {
        List<String> list = Arrays.asList("Basic", "QBasic", "c", "c++", "PowerBuilder", "to","go");

        Comparator<String> comparator1 = (lang1, lang2) -> {
            int ret = lang1.compareTo(lang2);
            if (ret ==0){
                return lang1.length()-lang2.length();
            }
            return ret;
        };

        Comparator<String> comparable2 = comparator1.reversed();  // 反转

        list.sort(comparable2);

        list.forEach((lang)->{
            System.out.println(lang);
        });

    }

四、Stream

java.util.Stream表示能应用在一组元素上一次执行的操作序列。

Stream 操作分为中间操作或者最终操作两种，最终操作返回一特定类型的计算结果，而中间操作返回 stream 本身，可以连续完成多个操作。

1. Filter 过滤

过滤通过一个 predicate 接口来过滤并只保留符合条件的元素，该操作属于中间操作 。所以过滤后的结果，可以继续进行其它 stream操作(例如forEach，forEach需要一个函数来对过滤后的元素依次执行。 forEach 是一个最终操作)。

    public static void main(String[] args) {
        Stream<String> stream = Stream.of("Basic", "QBasic", "c", "c++", "PowerBuilder", "go", "BuilderPower");

        // 过滤所有小写字母内容的元素，并排序
        stream.filter((lang) -> {
            for (int i = 0; i < lang.length(); i++) {
                char c = lang.charAt(i);
                if (c > 'A' && c < 'Z') {
                    return true;
                }
            }
            return false;
        }).sorted((c1, c2) -> {
            if (c1.length() == c2.length()) {
                return c1.compareTo(c2);
            } else {
                return c1.length() - c2.length();
            }
        }).forEach((lang) -> {
            System.out.println(lang);
        });
    }

2. Sorted 排序

排序是一个 中间操作，返回的是排序好后的Stream 。(不影响原数据)

    public static void main(String[] args) {
        Stream<String> stream = Stream.of("Basic", "QBasic", "c", "c++", "PowerBuilder", "go", "BuilderPower");

        // 过滤所有小写字母内容的元素，并排序
        stream.filter((lang) -> {
            for (int i = 0; i < lang.length(); i++) {
                char c = lang.charAt(i);
                if (c > 'A' && c < 'Z') {
                    return true;
                }
            }
            return false;
        }).sorted((c1, c2) -> {
            if (c1.length() == c2.length()) {
                return c1.compareTo(c2);
            } else {
                return c1.length() - c2.length();
            }
        }).forEach((lang) -> {
            System.out.println(lang);
        });
    }

3. Map 映射

映射是一个中间操作，会将元素根据指定的 Function 接口来依次将元素转成另外的对象。

    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(10, 20, 30, 40, 50, 60);

        // 映射：对每一个元素进行一次处理
        stream.map((n) -> {
            return n + 1;
        }).forEach((n) -> {
            System.out.println(n);
        });

        List<String> stringList = Arrays.asList("afa", "asf", "afsa");

        //转换字符串为大写，降序后输出
        stringList.stream().map((item) -> {
            return item.toUpperCase();
        }).sorted((s1, s2) -> {
            return s1.compareTo(s2);
        }).forEach((item) -> {
            System.out.println(item);
        });
    }

4. Match 匹配

Stream 提供了多种匹配操作，允许检测指定的 Predicate 是否匹配整个 Stream 。所有的匹配操作都是 最终操作 ，并返回一个boolean 类型的值。

    public static void main(String[] args) {

        List<String> stringList = Arrays.asList("gds","asfa","das");

        // allMatch:所有元素是否匹配
        boolean bool1 = stringList.stream().allMatch((item) -> {
            return item.length() == 3;
        });
        System.out.println(bool1);

        // anyMatch:任意元素是否匹配
        boolean bool2 = stringList.stream().anyMatch((item) -> {
            return item.length() == 3;
        });
        System.out.println(bool2);

    }

5. Collect收集

收集是一个 最终操作，返回 stream 中元素集合，返回值类型是集合(List、set、Map)或字符串。

    public static void main(String[] args) {
        List<String> stringList = Arrays.asList("1556","5612","8489");

        //将Stream流中的每个元素进行mapping映射操作后，然后收集至一个List集合
        //Collectors.mapping
        List<Integer> numberInt = stringList.stream().collect(Collectors.mapping(s -> Integer.parseInt(s) * 10, Collectors.toList()));
        System.out.println(numberInt);


        // 分组操作
        // Collectors.groupingBy
        // 按照元素的字符长度进行分组
        Stream<String> stream = Stream.of("Basic", "QBasic", "c", "c++", "PowerBuilder", "go","BuilderPower");
        Map<Integer, List<String>> resultMapGroup1 = stream.collect(Collectors.groupingBy(s -> s.length()));
        resultMapGroup1.forEach((k,v)->{
            System.out.println(k+":"+v);
        });
//        stream.collect(Collectors.groupingBy((s->s.length()))).forEach((k,v)->{
//            System.out.println(k+":"+v);
//        });

        // 按照元素的首字母进行分组
        stream = Stream.of("Basic", "QBasic", "c", "c++", "PowerBuilder", "go","BuilderPower");
        stream.collect(Collectors.groupingBy(s->s.charAt(0))).forEach((k,v)->{
            System.out.println(k+":"+v);
        });
    }

    public static void main(String[] args) {
        Stream<String> stream = Stream.of("Basic", "QBasic", "c", "c++", "PowerBuilder", "go","BuilderPower");

        // 分区操作（只有true和false）
        stream.collect(Collectors.partitioningBy(s->s.length()>3)).forEach((k,v)->{
            System.out.println(k+":"+v);
        });
    }

6. Statistics 统计

统计是一个最终操作，返回 Stream中元素的各类统计信息，返回值类型是 XXXConsumer。

    public static void main(String[] args) {
        //统计操作
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9);
        // Stream ===> IntStream
        IntStream intStream = list.stream().mapToInt(s -> s*10);
        IntSummaryStatistics statisticsResult = intStream.summaryStatistics();

        // 获取统计结果
        System.out.println("最大值："+statisticsResult.getMax());
        System.out.println("最小值："+statisticsResult.getMin());
        System.out.println("平均值："+statisticsResult.getAverage());
        System.out.println("累加和："+statisticsResult.getSum());
    }

7. 函数式接口总结

a. Predicate、Function、Consumer、Comparator

b. 通过链式编程，使得它可以方便地对数据进行链式处理。

c. 方法参数都是函数式接口类型

d. 一个stream 只能操作一次，操作完就关闭了，继续使用这个 stream会报错。Stream不保存数据，不改变数据源。

五、日期时间

LocalDateTime //日期+时间 format: yyyy-MM-ddTHH:mm:ss.SSS
LocalDate //日期 format: yyyy-MM-dd
LocalTime //时间 format: HH:mm:ss

1. 格式化

    public static void main(String[] args) {
        // 日期格式化
        // 默认格式： yyyy-MM-dd
        LocalDate date = LocalDate.now();
        System.out.println(String.format("Date Format:%s",date));

        // 默认格式：HH:mm:ss
        LocalTime time =LocalTime.now().withNano(0);
        System.out.println(String.format("Time Format:%s",time));

        LocalDateTime dateTime = LocalDateTime.now();

        // 自定义格式：yyyy-MM-dd HH:mm:ss
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
//        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH时mm分ss秒");
        String dateTimeStr = dateTime.format(dateTimeFormatter);
        System.out.println(String.format("DateTime Format:%s",dateTimeStr));
    }

2. 字符串转日期格式

    public static void main(String[] args) {
        // 字符串格式的日期内容，转换为LocalDate等之类的日期对象

        // 按照指定的日期的时间域值进行转换
        LocalDate date1 = LocalDate.of(2024,9,11);
        System.out.println(date1);

        // 按照默认格式(yyyy-MM-dd)的字符串，使用parse()方法进行转换
        LocalDate date2 = LocalDate.parse("2024-09-11");
        System.out.println(date2);

        // 按照默认格式（yyyy-MM-ddTHH:mm:ss）
        LocalDateTime dateTime1 = LocalDateTime.of(2024,9,11,17,50,30);
        LocalDateTime dateTime2 =LocalDateTime.parse("2024-09-11T17:50:30");
        System.out.println(dateTime1);
        System.out.println(dateTime2);

        // 按照默认格式（HH:mm:ss）
        LocalTime time1 = LocalTime.of(17,50,30);
        LocalTime time2 =LocalTime.parse("17:50:30");
        System.out.println(time1);
        System.out.println(time2);
    }

3. 日期计算

    public static void main(String[] args) {
        // 字符串格式的日期时间
        String strDatetime ="2024年12月15日";

        // 将字符串格式的日期，转换为LocalDate类型的日期对象
        LocalDate date = LocalDate.parse(strDatetime, DateTimeFormatter.ofPattern("yyyy年MM月dd日"));
        System.out.println(date);

        // 20天前
        LocalDate date1 = date.plusDays(-20);
        System.out.println(date1);

        //20天后
        LocalDate date2 = date.plusDays(20);
        System.out.println(date2);
    }

    public static void main(String[] args) {
        //计算两个日期间隔多少天，计算间隔多少年，多少月
        LocalDate date1 = LocalDate.parse("2024-07-12");
        LocalDate date2 = LocalDate.parse("2024-09-11");

        Period period =Period.between(date1,date2);
        System.out.println("date1到date2相间隔"+period.getYears()+"年"+period.getMonths()+"月"+period.getDays()+"天");

        long day = date2.toEpochDay() - date1.toEpochDay();
        System.out.println(date2+"和"+date1+"相差"+day+"天");
    }

4. 获取指定日期

    public static void main(String[] args) {
        LocalDate today = LocalDate.now();

        //获取当前月第一天
        LocalDate firstDayOfThisMonth = today.with(TemporalAdjusters.firstDayOfMonth());
        System.out.println("当前月第一天："+firstDayOfThisMonth);

        //获取本月最后一天
        LocalDate lastDayOfThisMonth = today.with(TemporalAdjusters.lastDayOfMonth());
        System.out.println("当前月最后一天："+lastDayOfThisMonth);

        // 获取下一天
        LocalDate nextDay = lastDayOfThisMonth.plusDays(1);
        System.out.println("下一天（次月第一天）:"+nextDay);

        LocalDate nextDay2 = today.plusDays(1);
        System.out.println("当前下一天："+nextDay2);

        //获取当年最后一天
        LocalDate lastday = today.with(TemporalAdjusters.lastDayOfYear());
        System.out.println("当年最后一天："+lastday);

        //获取当年最后一个周
        LocalDate lastMondayOfThisYear = lastday.with(TemporalAdjusters.lastInMonth(DayOfWeek.MONDAY));
        System.out.println("当年最后一个周一："+lastMondayOfThisYear);
    }