• 十六章：Java8的其它新特性

    目录

    16.1：Lambda表达式

    16.2：函数式（Function）接口

    16.3：方法引用和构造器引用

    16.4：强大的Stream API

                    ①Stream实例化

                    ②Stream的中间操作

                    ③终止操作

    16.5：Option类

    16.1：Lambda表达式

    1. package com.jiayifeng.java;
    2.  
    3. import org.junit.Test;
    4.  
    5. import java.util.Comparator;
    6. import java.util.function.Consumer;
    7.  
    8. /**
    9.  * author 爱编程的小贾
    10.  * create 2023-10-19 12:29
    11.  *
    12.  * 一：Lambda表达式的使用
    13.  *      1.举例：(o1,o2) -> Integer.compare(o1,o2);
    14.  *      2.格式：
    15.  *          "->"：Lambda操作符或箭头操作符
    16.  *          "->"左边：Lambda形参列表（也就是接口中的抽象方法的形参列表）
    17.  *          "->"左边：Lambda体（也就是重写的抽象方法的方法体）
    18.  *
    19.  *      3.Lambda表达式的使用：（六种情况）
    20.  *
    21.  *      4.Lambda表达式的本质：作为函数式接口的实例
    22.  *          如果一个接口中只声明了一个抽象方法，则此接口就称之为函数式接口。
    23.  *          我们可以在一个接口上使用@FunctionalInterface注解，这样可以检验它
    24.  *          是否是一个函数式接口
    25.  *
    26.  *
    27.  *      5.总结
    28.  *          "->"左边：Lambda形参列表的参数类型可以省略（类型推断）；
    29.  *              如果Lambda形参列表只有一个参数，其一对()也可以省略
    30.  *          "->"右边：Lambda体应使用一对{}包裹；
    31.  *              如果Lambda体只有一条执行语句（也可能是return语句），可以省略这一对{}和return关键字
    32.  *
    33.  */
    34. public class Lambda {
    35.     @Test
    36.     public void test1(){
    37.         Runnable r1 = new Runnable(){
    38.             @Override
    39.             public void run() {
    40.                 System.out.println("我爱北京天安门！");
    41.             }
    42.         };
    43.         r1.run();
    44.         System.out.println("************");
    45.  
    46. //        Lambda表达式的写法
    47.         Runnable r2 = () -> System.out.println("我爱北京故宫！");
    48.         r2.run();
    49.         System.out.println("************");
    50.  
    51. //        方法引用
    52.         Comparator com3 = Integer::compare;
    53.         int compare = com3.compare(32, 21);
    54.         System.out.println(compare);
    55.     }
    56.  
    57. //  语法格式一：无参、无返回值
    58.     @Test
    59.     public void test2(){
    60.         Runnable r1 = new Runnable(){
    61.             @Override
    62.             public void run() {
    63.                 System.out.println("我爱北京天安门！");
    64.             }
    65.         };
    66.         r1.run();
    67.         System.out.println("************");
    68.  
    69. //        Lambda表达式的写法
    70.         Runnable r2 = () -> {
    71.             System.out.println("我爱北京故宫！");
    72.         };
    73.         r2.run();
    74.     }
    75.  
    76. //    语法格式二：Lambda需要一个参数，但是没有返回值
    77.     @Test
    78.     public void test3(){
    79.         Consumer con = new Consumer() {
    80.  
    81.             @Override
    82.             public void accept(String s) {
    83.                 System.out.println(s);
    84.             }
    85.         };
    86.         con.accept("谎言和誓言的区别是什么？");
    87.         System.out.println("**************");
    88.  
    89.         Consumer con1 = (String s) -> {
    90.             System.out.println(s);
    91.         };
    92.         con1.accept("一个是听的人当真了，一个是说的人当真了");
    93.     }
    94.  
    95. //    语法格式三：数据类型可以省略，因为可由编译推断得出，称为“类型推断”
    96.     @Test
    97.     public void test4(){
    98.         Consumer con1 = (String s) -> {
    99.             System.out.println(s);
    100.         };
    101.         con1.accept("一个是听的人当真了，一个是说的人当真了");
    102.         System.out.println("******************");
    103.  
    104.         Consumer con2 = (s) -> {
    105.             System.out.println(s);
    106.         };
    107.         con1.accept("一个是听的人当真了，一个是说的人当真了!");
    108.     }
    109.  
    110. //    语法格式四：Lambda若只需要一个参数时，参数的小括号可以省略
    111.     @Test
    112.     public void test5(){
    113.         Consumer con1 = s -> {
    114.             System.out.println(s);
    115.         };
    116.         con1.accept("一个是听的人当真了，一个是说的人当真了");
    117.     }
    118.  
    119. //    语法格式五：Lambda需要两个或两个以上的参数，多条执行语句，并且可以有返回值
    120.     @Test
    121.     public void test6() {
    122.         Comparator com1 = new Comparator() {
    123.  
    124.             @Override
    125.             public int compare(Integer o1, Integer o2) {
    126.                 System.out.println(o1);
    127.                 System.out.println(o2);
    128.                 return o1.compareTo(o2);
    129.             }
    130.         };
    131.         System.out.println(com1.compare(12,21));
    132.         System.out.println("**************");
    133.  
    134.         Comparator com2 = (o1, o2) -> {
    135.             System.out.println(o1);
    136.             System.out.println(o2);
    137.             return o1.compareTo(o2);
    138.         };
    139.         System.out.println(com2.compare(12,6));
    140.     }
    141.  
    142. //    语法格式六：当Lambda体只有一条语句时，return与大括号若有，都可以省略
    143.     @Test
    144.     public void test7(){
    145.         Comparator com1 = (o1, o2) -> {
    146.             return o1.compareTo(o2);
    147.         };
    148.         System.out.println(com1.compare(12,6));
    149.         System.out.println("***********");
    150.  
    151.         Comparator com2 = (o1, o2) -> o1.compareTo(o2);
    152.         System.out.println(com1.compare(12,9));
    153.     }
    154. }

    16.2：函数式（Function）接口

    Java内置四大核心函数式接口
    函数式接口参数类型返回类型用途
    Consumer消费型接口Tvoid对类型为T的对象应用操作，包含方法：void accept(T t)
    Supplier供给型接口无T返回类型为T的对象，包含方法：T get()
    Function函数型接口TR对类型为T的对象应用操作，并返回结果，结果是R类型的对象。包含方法：R apply(T t)
    Predicate断定型接口Tboolean确定类型为T的对象是否满足某约束，并返回boolean值。包含方法：boolean test(T t)
    1. package com.jiayifeng.java;
    2.  
    3. import org.junit.Test;
    4.  
    5. import java.util.function.Consumer;
    6.  
    7. /**
    8.  * author 爱编程的小贾
    9.  * create 2023-10-19 16:51
    10.  *
    11.  * 一：Java内置的四大核心函数式接口
    12.  */
    13. public class LambdaTest1 {
    14.     @Test
    15.     public void test1(){
    16.         happyTime(500, new Consumer() {
    17.             @Override
    18.             public void accept(Double aDouble) {
    19.                 System.out.println("学习太累了，去超市买瓶水，价格为：" + aDouble);
    20.             }
    21.         });
    22.         System.out.println("**************");
    23.  
    24.         happyTime(400,money -> System.out.println("学习太累了，去超市喝了瓶水，价格为：" + money));
    25.     }
    26.  
    27.     public void happyTime(double money, Consumer con){
    28.         con.accept(money);
    29.     }
    30. }

    16.3：方法引用和构造器引用

    1. package com.jiayifeng.java;
    2.  
    3. import org.junit.Test;
    4.  
    5. import java.io.PrintStream;
    6. import java.util.function.Consumer;
    7.  
    8. /**
    9.  * author 爱编程的小贾
    10.  * create 2023-10-19 17:10
    11.  *
    12.  * 一：方法引用和构造器引用
    13.  *      1.使用情景：当要传递给Lambda体的操作已经有实现的方法了，可以使用方法引用
    14.  *      2.方法引用，本质上就是Lambda表达式，而Lambda表达式作为函数式接口的实例。
    15.  *      所以方法引用，也是函数式接口的实例
    16.  *      3.使用格式：类（或对象） :: 方法名
    17.  *      4.具体分为如下的三种情况：
    18.  *          对象 :: 非静态方法
    19.  *          类 :: 静态方法
    20.  *          类 :: 非静态方法
    21.  *      5.方法引用使用的要求：要求接口中的抽象方法的形参列表和返回值类型与
    22.  *        方法引用的方法的形参列表和返回值类型相同（针对于前两种情况）
    23.  */
    24. public class MethodRefTest {
    25.     @Test
    26.     public void test1(){
    27. //        情况一：对象 :: 实例方法
    28. //        Consumer中的void accept(T t)
    29. //        PrintStream中的void Println(T t)
    30.         Consumer con1 = str -> System.out.println(str);
    31.         con1.accept("北京");
    32.         System.out.println("**********");
    33.  
    34.         PrintStream ps = System.out;
    35.         Consumer con2 = ps :: println;
    36.         con2.accept("beijing");
    37.     }
    38. }

    构造器引用：

            和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致

    数组引用：

            可以将数组看做是一个特殊的类，写法与构造器引用一致

    16.4：强大的Stream API

            使用Stream API对数据集合进行操作，就类似于使用SQL执行的数据库查询

            简言之：Stream API提供了一种高效且易于使用的处理数据的方式

            定义：Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列

                    “集合讲的是数据，Stream讲的是计算”

            注意：

                    ①Stream自己不会存储数据

                    ②Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream

                    ③Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行

            执行流程：

                    ①Stream实例化
    1. package com.jiayifeng.java;
    2.  
    3. /**
    4.  * author 爱编程的小贾
    5.  * create 2023-10-19 19:34
    6.  */
    7. public class Employee {
    8.  
    9.     private int id;
    10.     private String name;
    11.     private int age;
    12.     private double salary;
    13.  
    14.  
    15.     public Employee(int id) {
    16.         this.id = id;
    17.     }
    18.  
    19.  
    20.     public Employee(int id, String name, int age) {
    21.         this.id = id;
    22.         this.name = name;
    23.         this.age = age;
    24.     }
    25.  
    26.     public Employee(int id, String name) {
    27.         this.id = id;
    28.         this.name = name;
    29.     }
    30.  
    31.     @Override
    32.     public boolean equals(Object o) {
    33.         if (this == o) return true;
    34.         if (!(o instanceof Employee)) return false;
    35.  
    36.         Employee employee = (Employee) o;
    37.  
    38.         if (getId() != employee.getId()) return false;
    39.         if (getAge() != employee.getAge()) return false;
    40.         if (Double.compare(employee.getSalary(), getSalary()) != 0) return false;
    41.         return getName() != null ? getName().equals(employee.getName()) : employee.getName() == null;
    42.     }
    43.  
    44.     @Override
    45.     public int hashCode() {
    46.         int result;
    47.         long temp;
    48.         result = getId();
    49.         result = 31 * result + (getName() != null ? getName().hashCode() : 0);
    50.         result = 31 * result + getAge();
    51.         temp = Double.doubleToLongBits(getSalary());
    52.         result = 31 * result + (int) (temp ^ (temp >>> 32));
    53.         return result;
    54.     }
    55.  
    56.     @Override
    57.     public String toString() {
    58.         return "Employee{" +
    59.                 "id=" + id +
    60.                 ", name='" + name + '\'' +
    61.                 ", age=" + age +
    62.                 ", salary=" + salary +
    63.                 '}';
    64.     }
    65.  
    66.     public int getId() {
    67.         return id;
    68.     }
    69.  
    70.     public void setId(int id) {
    71.         this.id = id;
    72.     }
    73.  
    74.     public String getName() {
    75.         return name;
    76.     }
    77.  
    78.     public void setName(String name) {
    79.         this.name = name;
    80.     }
    81.  
    82.     public int getAge() {
    83.         return age;
    84.     }
    85.  
    86.     public void setAge(int age) {
    87.         this.age = age;
    88.     }
    89.  
    90.     public double getSalary() {
    91.         return salary;
    92.     }
    93.  
    94.     public void setSalary(double salary) {
    95.         this.salary = salary;
    96.     }
    97.  
    98.     public Employee() {
    99.     }
    100.  
    101.     public Employee(int id, String name, int age, double salary) {
    102.         this.id = id;
    103.         this.name = name;
    104.         this.age = age;
    105.         this.salary = salary;
    106.     }
    107. }
    1. package com.jiayifeng.java;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.List;
    5.  
    6. /**
    7.  * author 爱编程的小贾
    8.  * create 2023-10-19 19:35
    9.  */
    10. public class EmployeeData {
    11.     public static List getEmp() {
    12.  
    13.         List list = new ArrayList<>();
    14.         list.add(new Employee(1001, "马化腾", 34, 6000.38));
    15.         list.add(new Employee(1002, "马云", 12, 9876.12));
    16.         list.add(new Employee(1003, "刘强东", 33, 3000.82));
    17.         list.add(new Employee(1004, "雷军", 26, 7657.37));
    18.         list.add(new Employee(1005, "李彦宏", 65, 5555.21));
    19.         list.add(new Employee(1006, "比尔盖茨", 42, 9500.43));
    20.         list.add(new Employee(1006, "任正非", 26, 4333.32));
    21.         list.add(new Employee(1006, "扎克伯格", 35, 2500.32));
    22.         return list;
    23.     }
    24. }
    1. package com.jiayifeng.java;
    2.  
    3. import org.junit.Test;
    4.  
    5. import java.util.Arrays;
    6. import java.util.List;
    7. import java.util.stream.IntStream;
    8. import java.util.stream.Stream;
    9.  
    10. /**
    11.  * author 爱编程的小贾
    12.  * create 2023-10-19 19:26
    13.  *
    14.  * 一：Stream API
    15.  *      1.Stream关注的是对数据的运算，与CPU打交道
    16.  *        集合关注的是数据的存储，与内存打交道
    17.  *
    18.  *      2.Stream执行流程
    19.  *          ①Stream实例化
    20.  *          ②一系列的中间操作（过滤、映射等）
    21.  *          ③终止操作
    22.  *
    23.  *      3.说明
    24.  *          ①一个中间操作链，对数据源的数据进行处理
    25.  *          ②一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被调用
    26.  *
    27.  */
    28. public class StreamAPI {
    29.     /**
    30.      * 创建Stream方式1：通过集合List
    31.      */
    32.     @Test
    33.     public void test1() {
    34.  
    35.         List emp = EmployeeData.getEmp();
    36.         //通过集合来创建
    37.         //顺序流
    38.         Stream stream = emp.stream();
    39.         //并行流
    40.         Stream employeeStream = emp.parallelStream();
    41.     }
    42.  
    43.     /**
    44.      * 创建Stream方式2：通过数组
    45.      */
    46.     @Test
    47.     public void test2() {
    48.         int arr[] = new int[]{1, 2, 3, 4, 5, 6};
    49.         //调用Arrays.stream返回数组
    50.         IntStream stream = Arrays.stream(arr);
    51.  
    52.         Employee e1 = new Employee(1, "1", 1, 1);
    53.         Employee e2 = new Employee(2, "1", 1, 1);
    54.  
    55.         Employee employees[] = new Employee[]{e1, e2};
    56.         Stream stream1 = Arrays.stream(employees);
    57.     }
    58.  
    59.  
    60.     /**
    61.      * 创建Stream方式3： 通过Stream的of()来创建
    62.      */
    63.     @Test
    64.     public void test3() {
    65.         Stream integerStream = Stream.of(1, 2, 3, 4, 5, 6);
    66.         Streamextends Number> stream = Stream.of(1.0, 2, 3, 4, 5, 6);
    67.     }
    68.  
    69.     /**
    70.      * 创建Stream方式4：创建无限流
    71.      */
    72.     @Test
    73.     public void test4() {
    74.         //迭代
    75.         //遍历前10个偶数
    76.         Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);
    77.         //生成
    78.         Stream.generate(Math::random).limit(10).forEach(System.out::println);
    79.     }
    80. }
                    ②Stream的中间操作
    1. package com.jiayifeng.java;
    2.  
    3. import org.junit.Test;
    4.  
    5. import java.util.ArrayList;
    6. import java.util.Arrays;
    7. import java.util.List;
    8. import java.util.stream.Stream;
    9.  
    10. /**
    11.  * author 爱编程的小贾
    12.  * create 2023-10-19 19:46
    13.  *
    14.  * 一：测试Stream的中间操作
    15.  */
    16. public class StreamAPITest1 {
    17. //    1.筛选与切片
    18.     @Test
    19.     public void test1(){
    20.         List list = EmployeeData.getEmp();
    21. //        filter(Predicate p)：接收Lambda，从流中欧排除某些元素
    22.         Stream stream = list.stream();
    23. //        查询员工表中薪资大于7000的员工信息
    24.         stream.filter(e -> e.getSalary() > 7000).forEach(System.out :: println);
    25.         System.out.println();
    26.  
    27. //        limit(n)：截断流，使其元素不超过给定数量
    28.         list.stream().limit(3).forEach(System.out :: println);
    29.         System.out.println();
    30.  
    31. //        skip(n)：跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流
    32.         list.stream().skip(3).forEach(System.out :: println);
    33.         System.out.println();
    34.  
    35. //        distinct()：筛选，通过流所生成元素的hashCode()和equals()去除重复元素
    36.         list.add(new Employee(1010,"刘强东",40,8000));
    37.         list.add(new Employee(1010,"刘强东",40,8000));
    38.         list.add(new Employee(1010,"刘强东",40,8000));
    39.         list.add(new Employee(1010,"刘强东",40,8000));
    40.         list.add(new Employee(1010,"刘强东",40,8000));
    41. //        System.out.println(list);
    42.  
    43.         list.stream().distinct().forEach(System.out :: println);
    44.     }
    45.  
    46. //    2.映射
    47.     @Test
    48.     public void test2(){
    49. //        map(Function f)：接受一个函数作为参数，将元素转换成其它形式或提取信息，该函数会
    50. //        被应用到每一个元素上，并将其映射成一个新的元素
    51.         List list = Arrays.asList("aa","bb","cc","dd");
    52.         list.stream().map(str -> str.toUpperCase()).forEach(System.out :: println);
    53.  
    54. //        flatMap(Function f)：接收一个函数作为参数，将流中的每一个值都换成另一个流，然后把所有
    55. //        流连接成一个流
    56.         ArrayList list1 = new ArrayList<>();
    57.         list1.add(1);
    58.         list1.add(2);
    59.         list1.add(3);
    60.  
    61.         ArrayList list2 = new ArrayList();
    62.         list2.add(4);
    63.         list2.add(5);
    64.         list2.add(6);
    65.  
    66.         list1.addAll(list2);
    67.         System.out.println(list1);
    68.     }
    69.  
    70. //    3.排序
    71.     @Test
    72.     public void test3(){
    73. //       sort()：自然排序
    74.         List list = Arrays.asList(12, 45, 24, 46, 67, 98);
    75.         list.stream().sorted().forEach(System.out :: println);
    76.  
    77. //        抛异常，原因：Employee没有实现Comparable接口
    78. //        List emp = EmployeeData.getEmp();
    79. //        emp.stream().sorted().forEach(System.out :: println);
    80.  
    81. //       sorted(Compatater com)：定制排序
    82.         List emp = EmployeeData.getEmp();
    83.         emp.stream().sorted((e1,e2) -> Integer.compare(e1.getAge(),e2.getAge()))
    84.             .forEach(System.out :: println);
    85.  
    86.     }
    87. }
                    ③终止操作
    1. package com.jiayifeng.java1;
    2.  
    3. /**
    4.  * author 爱编程的小贾
    5.  * create 2023-10-21 11:49
    6.  */
    7.  
    8. public class Student {
    9.     private int id;//id
    10.     private String name;//姓名
    11.     private int age;//年龄
    12.     private Score score;//成绩（优秀、良好、及格）
    13.  
    14.     public int getId() {
    15.         return id;
    16.     }
    17.  
    18.     public void setId(int id) {
    19.         this.id = id;
    20.     }
    21.  
    22.     public String getName() {
    23.         return name;
    24.     }
    25.  
    26.     public void setName(String name) {
    27.         this.name = name;
    28.     }
    29.  
    30.     public int getAge() {
    31.         return age;
    32.     }
    33.  
    34.     public void setAge(int age) {
    35.         this.age = age;
    36.     }
    37.  
    38.     public Score getScore() {
    39.         return score;
    40.     }
    41.  
    42.     public void setScore(Score score) {
    43.         this.score = score;
    44.     }
    45.  
    46.     public enum Score{
    47.         EXCELLENT,
    48.         GOOD,
    49.         PASS
    50.     }
    51.  
    52.     public Student(int id, String name, int age, Score score) {
    53.         this.id = id;
    54.         this.name = name;
    55.         this.age = age;
    56.         this.score = score;
    57.     }
    58. }
    1. package com.jiayifeng.java1;
    2.  
    3. /**
    4.  * author 爱编程的小贾
    5.  * create 2023-10-21 11:50
    6.  */
    7. import com.jiayifeng.java.Employee;
    8. import com.jiayifeng.java.EmployeeData;
    9. import org.junit.Test;
    10.  
    11. import java.util.Arrays;
    12. import java.util.List;
    13. import java.util.Optional;
    14. import java.util.stream.Collectors;
    15. import java.util.stream.Stream;
    16.  
    17. /**
    18.  * @description: 终止操作
    19.  *                  allMatch——检查是否匹配所有元素
    20.  *                  anyMatch——检查是否至少匹配一个元素
    21.  * 		            noneMatch——检查是否没有匹配的元素
    22.  * 		            findFirst——返回第一个元素
    23.  * 		            findAny——返回当前流中的任意元素
    24.  * 		            count——返回流中元素的总个数
    25.  * 		            max——返回流中最大值
    26.  * 		            min——返回流中最小值
    27.  * @author: xz
    28.  */
    29. public class StreamTest {
    30.     public static void main(String[] args) {
    31.         List studentsList = Arrays.asList(
    32.                 new Student(1, "李四", 20,Student.Score.EXCELLENT),
    33.                 new Student(2, "张三", 19,Student.Score.GOOD ),
    34.                 new Student(3, "王五", 24,Student.Score.PASS),
    35.                 new Student(4, "赵六", 23, Student.Score.GOOD),
    36.                 new Student(5, "xz", 21, Student.Score.PASS )
    37.         );
    38.  
    39.         //检查学生的成绩是都是良好
    40.         boolean b = studentsList.stream()
    41.                 .allMatch(s -> s.getScore().equals(Student.Score.GOOD));
    42.         System.out.println("allMatch——"+b);
    43.  
    44.         //检查学生的成绩至少有一个是良好
    45.         boolean b1 = studentsList.stream()
    46.                 .anyMatch(s -> s.getScore().equals(Student.Score.GOOD));
    47.         System.out.println("anyMatch——"+b1);
    48.  
    49.         //检查学生的成绩是否没有匹配到良好
    50.         boolean b2 = studentsList.stream()
    51.                 .noneMatch(s -> s.getScore().equals(Student.Score.GOOD));
    52.         System.out.println("noneMatch——"+b2);
    53.  
    54.         //按年龄排序且返回第一个元素
    55.         Optional op1 = studentsList.stream()
    56.                 .sorted((s1, s2) -> Integer.compare(s1.getAge(), s2.getAge()))
    57.                 .findFirst();
    58.         System.out.println("findFirst（按年龄排序且返回第一个元素）——"+op1.get());
    59.  
    60.         //查找学生成绩为及格且返回的任意元素
    61.         Optional op2 = studentsList.parallelStream()
    62.                 .filter(s -> s.getScore().equals(Student.Score.PASS))
    63.                 .findAny();
    64.         System.out.println("findAny（查找学生成绩为及格且返回的任意元素）——"+op2.get());
    65.  
    66.         ///查找学生的总人数
    67.         long count = studentsList.stream()
    68.                 .count();
    69.         System.out.println("count——"+count);
    70.  
    71.         //查找年龄最大的学生信息
    72.         Optional op3 = studentsList.stream()
    73.                 .max((s1, s2) -> Integer.compare(s1.getAge(), s2.getAge()));
    74.         System.out.println("max——"+op3.get());
    75.  
    76.         //查找学生所有的年龄范围，并获取最小的年龄
    77.         Optional op4 = studentsList.stream()
    78.                 .map(Student::getAge)
    79.                 .min(Integer::compare);
    80.         System.out.println("min——"+op4.get());
    81.     }
    82.     /*
    83.         allMatch——false
    84.         anyMatch——true
    85.         noneMatch——false
    86.         findFirst（按年龄排序且返回第一个元素）——com.jiayifeng.java1.Student@5f184fc6
    87.         findAny（查找学生成绩为及格且返回的任意元素）——com.jiayifeng.java1.Student@34a245ab
    88.         count——5
    89.         max——com.jiayifeng.java1.Student@34a245ab
    90.         min——19
    91.      */
    92.  
    93. //    规约
    94.     @Test
    95.     public void Test1(){
    96. //        练习一：计算1-10的自然数之和
    97.         List list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
    98.         Integer sum = list.stream().reduce(0,Integer::sum);
    99.         System.out.println(sum);//55
    100.  
    101. //        练习二：计算公司所有员工工资的总和
    102.         List employees = EmployeeData.getEmp();
    103.         Stream salaryStream = employees.stream().map(Employee::getSalary);
    104.         Optional sumMoney = salaryStream.reduce((d1, d2) -> (d1 + d2));
    105.         System.out.println(sumMoney);
    106.     }
    107.  
    108. //    收集
    109.     @Test
    110.     public void test2(){
    111.         List emp = EmployeeData.getEmp();
    112.         List employeeList = emp.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
    113.         employeeList.forEach(System.out::println);
    114.     }
    115. }

    Stream的详细介绍参考：http://t.csdnimg.cn/bAycz

    16.5：Optional类

            为了解决空指针异常而引入Optional类

            Optional类的javadoc描述如下：这是一个可以为null的容器对象。如果值存在，则isPresent()方法会返回true，调用get()方法会返回该对象

            

    1. package com.jiayifeng.java2;
    2.  
    3. /**
    4.  * author 爱编程的小贾
    5.  * create 2023-10-21 12:25
    6.  */
    7. public class Girl {
    8.     private String name;
    9.  
    10.     public String getName() {
    11.         return name;
    12.     }
    13.  
    14.     public void setName(String name) {
    15.         this.name = name;
    16.     }
    17.  
    18.     public Girl() {
    19.     }
    20.  
    21.     @Override
    22.     public String toString() {
    23.         return "Girl{" +
    24.                 "name='" + name + '\'' +
    25.                 '}';
    26.     }
    27.  
    28.     public Girl(String name) {
    29.         this.name = name;
    30.     }
    31. }
    1. package com.jiayifeng.java2;
    2.  
    3. /**
    4.  * author 爱编程的小贾
    5.  * create 2023-10-21 12:25
    6.  */
    7. public class Boy {
    8.     private Girl girl;
    9.  
    10.     public Boy(Girl girl) {
    11.         this.girl = girl;
    12.     }
    13.  
    14.     public Boy() {
    15.     }
    16.  
    17.     @Override
    18.     public String toString() {
    19.         return "Boy{" +
    20.                 "girl=" + girl +
    21.                 '}';
    22.     }
    23.  
    24.     public Girl getGirl() {
    25.         return girl;
    26.     }
    27.  
    28.     public void setGirl(Girl girl) {
    29.         this.girl = girl;
    30.     }
    31. }
    1. package com.jiayifeng.java2;
    2.  
    3. import org.junit.Test;
    4.  
    5. import java.util.Optional;
    6.  
    7. /**
    8.  * author 爱编程的小贾
    9.  * create 2023-10-21 12:27
    10.  *
    11.  * 一：Optional类：为了在程序中避免出现空指针异常而创建的
    12.  */
    13. public class OptionalTest {
    14.     @Test
    15.     public void test1(){
    16. //        1.Optional.of(T t)：创建一个Optional实例，t必须为空
    17.         Girl girl = new Girl();
    18.         Optional girl1 = Optional.of(girl);
    19.  
    20. //        2.Optional.empty()：创建一个空的Optional实例
    21.  
    22. //        3.Optional.ofNullable(T t)：t可以为空
    23.         Girl girl2 = new Girl();
    24.         girl2 = null;
    25.         Optional optionalGirlgirl1 = Optional.ofNullable(girl2);
    26.         System.out.println(optionalGirlgirl1);
    27.     }
    28.  
    29.     public String getGirlName(Boy boy){
    30.         Optional boyOptional = Optional.ofNullable(boy);
    31. //        此时的boy1一定非空
    32.         Boy boy1 = boyOptional.orElse(new Boy(new Girl("迪丽热巴")));
    33.  
    34.         Girl girl1 = boy1.getGirl();
    35.  
    36.         Optional girlOptional = Optional.ofNullable(girl1);
    37. //        girl2一定非空
    38.         Girl girl2 = girlOptional.orElse(new Girl("古力娜扎"));
    39.  
    40.         return girl2.getName();
    41.     }
    42.  
    43.     @Test
    44.     public void test2(){
    45.         Boy boy = null;
    46.         boy = new Boy();
    47.         boy = new Boy(new Girl("贾老师"));
    48.         String girlName = getGirlName(boy);
    49.         System.out.println(girlName);
    50.     }
    51. }
  • 相关阅读:
    环境配置之终端WezTerm
    线程状态与线程安全
    SpringBoot项目中使用MultipartFile来上传文件(包含多文件)
    单片机涉及到这么多行业？
    训练环境搭建过程中遇到的一些问题
    Linux 文本处理命令 - chmod
    leetcode做题笔记155. 最小栈
    echart 设置 legend.type=“scroll“ 翻页时，中文上面被截取，显示不完整，解决办法
    企业级-PDF文件下载
    基于ssm的搬家管理系统
  • 原文地址：https://blog.csdn.net/weixin_63925896/article/details/133923963