• java8新特性

    视频链接：03_lambda表达式初步与函数式接口_哔哩哔哩_bilibili

     lambda表达式的基本结构：

    (parm1,parm2,parm3) -> {

    }

    函数式接口：

    1.如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口。

    2.如果在某个接口上声明了FunctionalInterface注解，那么编译器就会按照函数式接口的定义要求该接口。

    3.如果某个接口只有一个抽象方法，但我们并没有给该接口声明FunctionalInterface注解，那么编译器依旧会将该接口看做是函数式接口。

     1.使用lambda表达式 简化遍历：

     

    2.使用方法引用 ，简化遍历：

    在java中，lambda表达式是对象，他们必须依附于函数式接口。

    倒序排序：

    1. import java.util.Arrays;
    2. import java.util.Collections;
    3. import java.util.Comparator;
    4. import java.util.List;
    5.  
    6. public class StringComparator {
    7.     public static void main(String[] args) {
    8.         List names = Arrays.asList("zhangsan", "lisi", "wangwu");
    9. //        Collections.sort(names, new Comparator() {
    10. //            @Override
    11. //            public int compare(String o1, String o2) {
    12. //                return o2.compareTo(o1);//倒序
    13. //            }
    14. //        });
    15.  
    16. //        Collections.sort(names, (o1, o2) -> {return o2.compareTo(o1);});
    17. //        System.out.println(names);
    18.  
    19. //        Collections.sort(names, Comparator.reverseOrder());
    20. //        System.out.println(names);
    21.  
    22.         Collections.sort(names, (o1, o2) -> o2.compareTo(o1));
    23.         System.out.println(names);
    24.  
    25.     }
    26. }

    Stream

    为了简化代码，使用流Stream

     也可以换一种 方法引用的形式

    -------------------------------------------------------------8.22-----------------------------------------------------------

    多个function串联：

    例子：function中的compose方法和andThen方法的区别：

    compose方法先执行后面的（function2），andThen先执行前面的（function1）

     BiFunction:接受两个参数，返回一个结果。

    eg:使用BiFunction实现加减乘除 

     eg2:使用BiFunction的andThen方法（注意后面是function，而不是BiFunction，这是因为参数个数的问题，BiFunction没有compose方法也是这个原因，返回一个参数不足以供给两个参数的BiFunction）

     输出结果：25

    eg:stream在实际中的应用

     例2

     更灵活的方法：

     ---------------------------------------------------------------------

    总结一下：

    1.过滤（filter），去重(distinct)，获取流中的第一个元素（findFirst）；

    1. public class Demo {
    2.     public static void main ( String[] args ) {
    3.         // 流的筛选
    4.         List integerList = Arrays.asList(1, 2, 3,3, 4, 5, 6);
    5.         // 筛选出集合中数字大于4的元素
    6.         List collect = integerList.stream().filter(x -> x > 4).collect(Collectors.toList());
    7.         System.out.println(collect); //[5, 6]
    8.         // 集合中的去重
    9.         List collect1 = integerList.stream().distinct().collect(Collectors.toList());
    10.         System.out.println(collect1);//[1, 2, 3, 4, 5, 6]
    11.         // 获取流中的第一个元素
    12.         Optional first = integerList.stream().filter(x -> x > 4).findFirst();
    13.         Optional any = integerList.stream().filter(x -> x > 4).findAny();
    14.         Optional any1 = integerList.parallelStream().filter(x -> x > 4).findAny();
    15.         System.out.println(first); //Optional[5]
    16.         System.out.println(any); //Optional[5]
    17.         System.out.println(any1); // 预期结果不稳定
    18.  
    19.     }
    20. }
    21.

    2.获取最大值（max）,最小值（min）,计数（count）

    1. public class Demo {
    2.     public static void main(String[] args) {
    3.         List stringList = Arrays.asList("huainvhai", "xiaotiancai", "bennvhai");
    4.         // 获取集合中最长的字符串
    5.         Optional maxString = stringList.stream().max(Comparator.comparing(String::length));
    6.         // 获取集合中最短字符串
    7.         Optional minString = stringList.stream().min(Comparator.comparing(String::length));
    8.         System.out.println(maxString);
    9.         System.out.println(minString);
    10.         
    11.         
    12.         
    13.         // 获取集合中的最大值
    14.         List integerList = Arrays.asList(1, 2, 3);
    15.         Optional maxInteger = integerList.stream().max((i, j) -> {
    16.             return i - j;
    17.         });
    18.         // 获取集合中的最小值
    19.         Optional minInteger = integerList.stream().max((i, j) -> {
    20.             return j - i;
    21.         });
    22.         System.out.println(maxInteger);
    23.         System.out.println(minInteger);
    24.         
    25.         
    26.         
    27.         
    28.         // 集合泛型是个对象的最值
    29.         ArrayList personList = new ArrayList<>();
    30.         personList.add(new Person("xiao",12));
    31.         personList.add(new Person("xiao",20));
    32.         personList.add(new Person("xiao",18));
    33.         Optional max = personList.stream().max(Comparator.comparing(Person::getAge));
    34.         // 获取集合中的元素数量
    35.         long count = personList.stream().filter(p -> p.getAge() > 12).count();
    36.         System.out.println(max);
    37.         System.out.println(count);
    38.     }
    39. }

    3.缩减（reduce）：就是把一个流缩减成一个值,比如说对一个集合中求和，求乘积等

    1. public class Demo4 {
    2.     public static void main(String[] args) {
    3.         List integers = Arrays.asList(1, 2, 3, 4);
    4.         // 写法一 集合中的元素求和 (就是集合中的元素求和再加上1)
    5.         Integer integer = integers.stream().reduce(1, Integer::sum);
    6.         // 写法二
    7.         integers.stream().reduce(1,(x,y)->x+y);
    8.         System.out.println(integer); // 11
    9.  
    10.         // 第二种缩减方式 集合中的元素求和
    11.         Optional reduce = integers.stream().reduce(Integer::sum);
    12.         // 写法二
    13.         Optional reduce1 = integers.stream().reduce((x, y) -> x + y);
    14.         System.out.println(reduce); //Optional[10]
    15.         System.out.println(reduce1); //Optional[10]
    16.  
    17.         // 集合中使用reduce求最值问题
    18.         Optional reduce2 = integers.stream().reduce(Integer::max);
    19.         System.out.println(reduce2);
    20.  
    21.         /**
    22.          * 对象集合求和 求最值问题
    23.          */
    24.         ArrayList personList = new ArrayList<>();
    25.         personList.add(new Person("xiao",12));
    26.         personList.add(new Person("xiao",20));
    27.         personList.add(new Person("xiao",18));
    28.         // 求集合中对象的年龄的总和
    29.         Optional reduce3 = personList.stream().map(p -> p.getAge()).reduce(Integer::sum);
    30.         System.out.println(reduce3);  //Optional[50]
    31.  
    32.         // 求集合中年龄最大的对象
    33.         Optional reduce4 = personList.stream().reduce((p1, p2) -> p1.getAge() > p2.getAge() ? p1 : p2);
    34.         Optional max = personList.stream().max(Comparator.comparingInt(Person::getAge));
    35.         System.out.println(reduce4);
    36.         System.out.println(max);
    37.     }
    38. }

    4.汇集（collect）

    1. public class Demo5 {
    2.     public static void main(String[] args) {
    3.         ArrayList personList = new ArrayList<>();
    4.         personList.add(new Person("xiao",12));
    5.         personList.add(new Person("xiao",20));
    6.         personList.add(new Person("xiao",18));
    7.         // 获取平均年龄 averaging
    8.         Double collect = personList.stream().collect(Collectors.averagingInt(Person::getAge));
    9.         System.out.println(collect); //16.666666666666668
    10.  
    11.         // summarizing
    12.         DoubleSummaryStatistics collect1 = personList.stream().collect(Collectors.summarizingDouble(Person::getAge));
    13.         System.out.println(collect1); // DoubleSummaryStatistics{count=3, sum=50.000000, min=12.000000, average=16.666667, max=20.000000}
    14.  
    15.         //joining
    16.         String collect2 = personList.stream().map(p -> p.getName()).collect(Collectors.joining(","));
    17.         System.out.println(collect2);  //xiao,xiao,xiao
    18.  
    19.         // reduce
    20.         Integer collect3 = personList.stream().collect(Collectors.reducing(0, Person::getAge, (x, y) -> x + y));
    21.         Optional reduce = personList.stream().map(Person::getAge).reduce(Integer::sum);
    22.         System.out.println(collect3); //50
    23.         System.out.println(reduce);   //Optional[50]
    24.  
    25.         // groupingBy
    26.         // 以名字进行分组
    27.         Map> collect4 = personList.stream().collect(Collectors.groupingBy(Person::getName));
    28.         System.out.println(collect4); //{xiao=[Person(name=xiao, age=12), Person(name=xiao, age=20), Person(name=xiao, age=18)]}
    29.         // 先以名字分组，再以年龄分组
    30.         Map>> collect5 = personList.stream().collect(Collectors.groupingBy(Person::getName, Collectors.groupingBy(Person::getAge)));
    31.         System.out.println(collect5); //{xiao={18=[Person(name=xiao, age=18)], 20=[Person(name=xiao, age=20)], 12=[Person(name=xiao, age=12)]}}
    32.  
    33.         // toList、toSet、toMap
    34.         Set collect6 = personList.stream().collect(Collectors.toSet());
    35.         System.out.println(collect6);//[Person(name=xiao, age=18), Person(name=xiao, age=20), Person(name=xiao, age=12)]
    36.  
    37.     }
    38. }

    5.映射（map）:将一个流的元素按照一定的映射规则映射到另一个流中

    1. public class Demo6 {
    2.     public static void main(String[] args) {
    3.         String[] strArr = { "abcd", "bcdd", "defde", "ftr" };
    4.         Arrays.stream(strArr).map(x->x.toUpperCase()).forEach(System.out::print); //ABCDBCDDDEFDEFTR
    5.         List collect = Arrays.stream(strArr).map(x -> x.toUpperCase()).collect(Collectors.toList());
    6.         System.out.println(collect); // [ABCD, BCDD, DEFDE, FTR]
    7.  
    8.     }
    9. }

    6.排序（Sorted）

    1. public class Demo7 {
    2.     public static void main(String[] args) {
    3.         String[] strArr = { "ab", "bcdd", "defde", "ftr" };
    4.         // 自然排序
    5.         List collect = Arrays.stream(strArr).sorted().collect(Collectors.toList());
    6.         System.out.println(collect);  // [ab, bcdd, defde, ftr]
    7.  
    8.         // 自定义排序
    9.         // 按照字符串的长度 长度 从小到大
    10.         List collect1 = Arrays.stream(strArr).sorted(Comparator.comparing(String::length)).collect(Collectors.toList());
    11.         System.out.println(collect1); //[ab, ftr, bcdd, defde]
    12.         // 按照字符串的长度逆序排序
    13.         List collect2 = Arrays.stream(strArr).sorted(Comparator.comparing(String::length).reversed()).collect(Collectors.toList());
    14.         System.out.println(collect2); //[defde, bcdd, ftr, ab]
    15.  
    16.         // 首字母倒序
    17.         List collect3 = Arrays.stream(strArr).sorted(Comparator.reverseOrder()).collect(Collectors.toList());
    18.         System.out.println(collect3); //[ftr, defde, bcdd, ab]
    19.         // 首字母自然排序
    20.         List collect4 = Arrays.stream(strArr).sorted(Comparator.naturalOrder()).collect(Collectors.toList());
    21.         System.out.println(collect4); //[ab, bcdd, defde, ftr]
    22.     }
    23. }

    7.组合（concat）、跳过（skip）

    1. public class Demo8 {
    2.     public static void main(String[] args) {
    3.         String[] arr1 = {"a","b","c","d"};
    4.         String[] arr2 = {"d","e","f","g"};
    5.         String[] arr3 = {"i","j","k","l"};
    6.  
    7.         Stream stream1 = Arrays.stream(arr1);
    8.         Stream stream2 = Arrays.stream(arr2);
    9.         Stream stream3 = Arrays.stream(arr3);
    10.         // 可以把两个stream合并成一个stream（合并的stream类型必须相同）,只能两两合并
    11. //        List collect = Stream.concat(stream1, stream2).collect(Collectors.toList());
    12. //        System.out.println(collect); //[a, b, c, d, d, e, f, g]
    13.         // 合并去重
    14.         List collect1 = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
    15.         System.out.println(collect1); //[a, b, c, d, e, f, g]
    16.  
    17.         // limit，限制从流中获得前n个数据
    18. //        List collect = collect1.stream().limit(3).collect(Collectors.toList());
    19. //        System.out.println(collect); //[a, b, c]
    20.  
    21.         // skip，跳过前n个数据
    22.         List collect = collect1.stream().skip(1).limit(3).collect(Collectors.toList());
    23.         System.out.println(collect);//[b, c, d]
    24.     }
    25. }
  • 相关阅读:
    RabbitMQ用户管理
    北邮“一号邮路”上的数学体验
    Python 进阶语法：JSON
    springboot中自定义JavaBean返回的json对象属性名称大写变小写问题
    通过IP地址可以做什么
    李宏毅机器学习2023作业（目录）
    windows 驱动与内核调试 学习
    可视化看板有那么多应用场景，该如何快速搭建？可视化工具该如何选择？
    OpenResty无损升级内嵌nginx版本0DAY漏洞
    docker常用操作
  • 原文地址：https://blog.csdn.net/Mcdull__/article/details/126404898