• Java8新特性实战

            Java 8 作为一个里程碑式的版本，其中所做出的改变，在许多方面比Java历史上任何一次改变都深远。Java为什么会一直在改变，因为编程语言就像生态系统一样，更优秀语言的出现，落后的语言就会被取代，除非它们不断地演变和进步。Java 8 引入的核心新特性包括：Lambda表达式、函数式接口、Stream流API、方法引用/构造器引用等。

    1. 什么是行为参数化

           行为参数化是Java 8 增加的一个编程概念，即把不同行为的代码通过参数传递给方法。对于初学者来说这可能不太好理解，我们需要记住的是Java 8 增加了把方法（你的代码）作为参数传递给另一个方法的能力。Java 8中的Lambda表达式和方法引用的语法就是使用了行为参数化的体现。

    • Lambda表达式，通过匿名函数传递代码。
    1. package com.mj.lambda;
    2.  
    3. /**
    4.  * @author: gjm
    5.  * @description: 常见的Lambda使用
    6.  */
    7. public class UseLambda {
    8.  
    9.     public static void main(String[] args) {
    10.         // Lambda表达式把一个匿名函数传递给方法
    11.         new Thread(()-> System.out.println("t1 running"),"t1").start();
    12.     }
    13. }
    • 方法引用语法，表示传递此方法的代码。
    1. package com.mj.method_ref;
    2.  
    3. import java.util.function.Function;
    4.  
    5. /**
    6.  * @author: gjm
    7.  * @description: 如何使用方法引用
    8.  */
    9. public class UseMethodRef {
    10.  
    11.     public static void main(String[] args) {
    12.         // 方法引用语法： （类::方法名），传递的是方法的代码
    13.         getThreadInfo(new Thread(()->
    14.                 System.out.println("t1 running"),"t1"),Thread::getId,Thread::getName);
    15.     }
    16.     
    17.     // 使用函数式接口接收
    18.     public static void getThreadInfo(Thread t, Function f, 
    19.                                      Function f1) {
    20.         // 调用函数，传递的方法不同，获取的结果也不同
    21.         Long threadId = f.apply(t);
    22.         String threadName = f1.apply(t);
    23.         System.out.println("threadId："+threadId);
    24.         System.out.println("threadName："+threadName);
    25.     }
    26.  
    27. }

    2. 方法引用的语法

          方法引用是Java 8 支持的新语法，使用 ": :" 的语法声明方法引用，可以引用静态方法、普通成员方法、构造器方法。

    • 语法一：使用类: :普通成员方法。
    1. package com.mj.method_ref;
    2.  
    3. import lombok.AllArgsConstructor;
    4. import lombok.Getter;
    5. import lombok.Setter;
    6. import lombok.ToString;
    7.  
    8. /**
    9.  * @author: gjm
    10.  * @description: 用户类
    11.  */
    12. @Setter
    13. @Getter
    14. @AllArgsConstructor
    15. @ToString
    16. public class User {
    17.     private long id;
    18.     private String username;
    19.     private int age;
    20. }
    1.  public static void main(String[] args) {
    2.      List users = new ArrayList<>();
    3.      users.add(new User(1L,"张三", 30));
    4.      users.add(new User(2L,"李四", 25));
    5.      users.add(new User(3L,"王五", 35));
    6.  
    7.      // 可以按照语法理解，通过年龄从小到大排序，
    8.      users.sort(Comparator.comparing(User::getAge));
    9.      System.out.println(users.toString());
    10.  }
    • 语法二：使用类: :静态成员方法。
    1. package com.mj.method_ref;
    2.  
    3. import lombok.AllArgsConstructor;
    4. import lombok.Getter;
    5. import lombok.Setter;
    6. import lombok.ToString;
    7.  
    8. /**
    9.  * @author: gjm
    10.  * @description: 用户类
    11.  */
    12. @Setter
    13. @Getter
    14. @AllArgsConstructor
    15. @NoArgsConstructor
    16. @ToString
    17. public class User {
    18.     private long id;
    19.     private String username;
    20.     private int age;
    21.     
    22.     // 按用户年龄降序排序
    23.     public static int compareByAgeDesc(User u1, User u2){
    24.         return u2.getAge() - u1.getAge();
    25.     }
    26. }
    1. public static void main(String[] args) {
    2.     List users = new ArrayList<>();
    3.     users.add(new User(1L,"张三", 30));
    4.     users.add(new User(2L,"李四", 25));
    5.     users.add(new User(3L,"王五", 35));
    6.  
    7.     // 使用工具类的排序方法，引用自定义排序规则的静态方法
    8.     Collections.sort(users, User::compareByAgeDesc);
    9.     System.out.println(users.toString());
    10.  }
    • 语法三：对象: :普通成员方法。
    1.  public int compareByAgeAsc(User u1, User u2){
    2.         return u1.getAge() - u2.getAge();
    3.  }
    1. public static void main(String[] args) {
    2.     List users = new ArrayList<>();
    3.     users.add(new User(1L,"张三", 30));
    4.     users.add(new User(2L,"李四", 25));
    5.     users.add(new User(3L,"王五", 35));
    6.  
    7.     // 使用工具类的排序方法，引用自定义排序规则的静态方法
    8.     User user = new User();
    9.     Collections.sort(users, user::compareByAgeAsc);
    10.     System.out.println(users.toString());
    11.  }
    • 语法四：构造器引用，类: :new。
    1. package com.mj.method_ref;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Collections;
    5. import java.util.List;
    6. import java.util.regex.Pattern;
    7. import java.util.stream.Collectors;
    8.  
    9. /**
    10.  * @author: gjm
    11.  * @description: 构造器引用
    12.  */
    13. public class ConstructorRef {
    14.  
    15.     public static void main(String[] args) {
    16.         List names = new ArrayList<>();
    17.         Collections.addAll(names,"11223","122","1222","12","21122","12aa");
    18.         // 找到所有以12开头的字符串，并转换为数字
    19.         List integers = names.stream().filter(num -> {
    20.             // 字符串只能是数字
    21.             Pattern pattern = Pattern.compile("[0-9]+");
    22.             return (pattern.matcher(num).matches() && num.startsWith("12"));
    23.         } )
    24.          // 把过滤出的数字字符串转换成 Integer类型，
    25.          // Integer::new所对应构造器为 public Integer(String s)
    26.         .map(Integer::new).collect(Collectors.toList());
    27.         System.out.println(integers.toString());
    28.     }
    29.  
    30. }

    3. Lambda表达式

          Lambda表达式也是Java 8 支持的新语法，本质就是一个匿名函数，把函数当成参数传递给其它方法。前面的方法引用使用的是具体方法，也就是需要被提前声明出的静态方法或普通成员方法才能被引用。

    • 一个Lambda表达式包括了三个部分。

        1. 参数列表： 和函数一样支持无参（），一个参数（a），多个参数(a, b , ..)，无需书写参数类型。

        2. 箭头： 箭头 —>把参数列表与Lambda主体分隔开。

        3. Lambda主体： 在大括号{ }中书写具体的执行代码，只有一行代码可以省略大括号。

    • Lambda表达式需匹配函数式接口才能使用。函数式接口就是只定义一个抽象方法的接口，具体说来，Lambda表达式是函数式接口一个具体实现的实例。
    • Lambda表达式主体内可以使用外部的变量，外部变量必须是最终变量或使用final修饰的实际最终变量。
    • 无参的Lambda表达式，可以有返回值和无返回值。
    1.   // 无参无返回值，对应的是函数式接口Runnable      
    2.   Runnable runnable = () -> { };
    3.   
    4.   // 无参有返回值，对应的是函数式接口Supplier或者Callable
    5.   Supplier supplier = () -> "Gets a result";
    6.   
    7.   // Callable一般用于多线程，可以拿到执行结果
    8.   Callable callable = () -> "Computes a result";
    • 一个参数的Lambda表达式，可以有返回值和无返回值。
    1. // 一个参数无返回值，对应的是函数式接口Consumer
    2. Consumer consumer = (a) -> { };
    3.  
    4. // 一个参数有返回值，对应的是函数式接口Function
    5. Function f = (a) -> a.toString();
    • 两个参数的Lambda表达式，可以有返回值和无返回值。
    1. // 两个参数无返回值，对应的是函数式接口BiConsumer
    2. BiConsumer biConsumer = (a, b) -> { };
    3.  
    4. // 两个参数有返回值，返回类型为int，对应的是函数式接口Comparator
    5. Comparator comparator = (u1, u2) -> u1.getAge() - u2.getAge();

     4. 函数式接口

           函数式接口也是Java 8 新增加的一种类型，函数式接口的定义是只有一个抽象方法的接口。函数式接口作为方法的参数时，可以使用Lambda表达式或者方法引用把代码作为参数值传递，这就是行为参数化。让方法通过接收多种不同的代码实现，来完成不同的行为，这也被称为函数式编程。

    • Predicate函数式接口。

             java.util.function.Predicate接口定义了一个名叫test的抽象方法，它接受泛型T对象，并返回一个boolean。我们可以使用一个具体的案例体验函数式编程的使用和强大之处，下面案例通过lambda表达式传入不同行为的代码，对过滤用户的方法完成了不一样的功能。这些代码必须匹配Predicate接口的抽象方法的定义规则，官方叫匹配函数式接口的函数描述符。

    1. package com.mj.lambda;
    2.  
    3. import com.mj.method_ref.User;
    4.  
    5. import java.util.ArrayList;
    6. import java.util.List;
    7. import java.util.function.Predicate;
    8.  
    9. /**
    10.  * @author: gjm
    11.  * @description: Predicate函数式接口使用
    12.  */
    13. public class UsePredicate {
    14.  
    15.     public static void main(String[] args) {
    16.         List users = new ArrayList<>();
    17.         users.add(new User(1L,"张三", 30));
    18.         users.add(new User(2L,"李四", 25));
    19.         users.add(new User(3L,"王五", 35));
    20.  
    21.         /**
    22.          *  filterUsers（）方法的第二个参数可以使用Lambda表达式
    23.          *  Lambda表达式必须匹配函数描述符: T-> boolean
    24.          *  函数描述符: T-> boolean,表示接收一个T类型参数，返回boolean类型结果
    25.          */
    26.          
    27.         // 找出大于等于35岁的用户
    28.         System.out.println(filterUsers(users, user -> user.getAge() >=30 ));
    29.          // 找出姓张的用户
    30.         System.out.println(filterUsers(users, user -> user.getUsername().startsWith("张") ));
    31.     }
    32.  
    33.     /**
    34.      * 过滤用户
    35.      * @param user
    36.      * @param p
    37.      * @return
    38.      */
    39.     public static List filterUsers(List users, Predicate p) {
    40.         List result = new ArrayList<>();
    41.         for (User user: users){
    42.             // 执行方法，就是执行了lambda表达式中的代码
    43.             if (p.test(user)) {
    44.                 result.add(user);
    45.             }
    46.         }
    47.         return result;
    48.     }
    49. }
    • Consumer函数式接口。

             java.util.function.Consumer定义了一个名叫accept的抽象方法，它接受泛型T的对象，没有返回（void）。你如果需要访问类型T的对象，并对其执行某些操作，就可以使用这个接口。由于只有输入参数，没有返回值，所以通常也叫消费型函数式接口。

    1. package com.mj.lambda;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Collections;
    5. import java.util.List;
    6.  
    7. /**
    8.  * @author: gjm
    9.  * @description: Consumer函数式接口
    10.  */
    11. public class UseConsumer {
    12.  
    13.     public static void main(String[] args) {
    14.         List names = new ArrayList<>();
    15.         Collections.addAll(names,"刘备","关羽","张飞");
    16.  
    17.         /**
    18.          *  forEach()方法的参数就是Consumer函数式接口
    19.          *  default void forEach(Consumer action) {}
    20.          *  forEach()方法也是jdk1.8新增加的接口中允许有实现的默认方法
    21.          */
    22.         names.forEach(str -> System.out.println(str));
    23.     }
    24.  
    25. }
    • Supplier函数式接口。

            java.util.function.Supplier接口定义了一个叫作get的方法，它不接收任何参数，只返回一个泛型T的对象。根据这个特性，通常也被称供给型函数式接口。

    1. package com.mj.lambda;
    2. import java.time.LocalDateTime;
    3. import java.time.Month;
    4. import java.time.format.DateTimeFormatter;
    5. import java.util.function.Supplier;
    6.  
    7.  
    8. /**
    9.  * @author: gjm
    10.  * @description: Supplier函数式接口
    11.  */
    12. public class UseSupplier {
    13.  
    14.     public static void main(String[] args) {
    15.         // 获取当前时间的字符串
    16.         String currentDateTime = getDateTimeStr(LocalDateTime::now, "yyyy-MM-dd HH:mm:ss");
    17.         System.out.println(currentDateTime);
    18.  
    19.         // 获取指定时间的字符串
    20.         String dateTime =  getDateTimeStr(()->LocalDateTime.of(2022, Month.APRIL,1,12,30),
    21.                 "yyyy-MM-dd HH:mm:ss");
    22.         System.out.println(dateTime);
    23.  
    24.     }
    25.  
    26.     /**
    27.      * 获取LocalDateTime时间的字符串格式
    28.      * @param supplier
    29.      * @param pattern
    30.      * @return
    31.      */
    32.     public static String getDateTimeStr(Supplier supplier,String pattern){
    33.         LocalDateTime time = supplier.get();
    34.         return time.format(DateTimeFormatter.ofPattern(pattern));
    35.     }
    36. }
    • Function函数式接口。

            java.util.function.Function接口定义了一个叫作apply的方法，它接受一个泛型T的对象，并返回一个泛型R的对象。根据这个接口的方法特点，我们可以利用它实现类型转换的功能。

    1. package com.mj.lambda;
    2.  
    3. import com.mj.method_ref.User;
    4. import java.util.ArrayList;
    5. import java.util.HashMap;
    6. import java.util.List;
    7. import java.util.Map;
    8. import java.util.function.Function;
    9.  
    10. /**
    11.  * @author: gjm
    12.  * @description: Function函数式接口
    13.  */
    14. public class UseFunction {
    15.  
    16.     public static void main(String[] args) {
    17.         List users = new ArrayList<>();
    18.         users.add(new User(1L,"张三", 30));
    19.         users.add(new User(2L,"李四", 25));
    20.         users.add(new User(3L,"王五", 35));
    21.         List dataMap = map(users, user -> {
    22.             // 转换为HashMap集合，以id为key
    23.             Map map = new HashMap<>();
    24.             map.put(user.getId(),user.getUsername());
    25.             return map;
    26.         });
    27.         System.out.println(dataMap.toString());
    28.  
    29.     }
    30.  
    31.     /**
    32.      * 把T类型的对象转换为R类型
    33.      * @param list
    34.      * @param f
    35.      * @param 
    36.      * @param 
    37.      * @return
    38.      */
    39.     public static  List map(List list, Function f) {
    40.         List result = new ArrayList<>();
    41.         for(T s: list){
    42.             result.add(f.apply(s));
    43.         }
    44.         return result;
    45.     }
    46.  
    47. }
    •  原始类型特化的函数式接口。

            Java 8为我们前面所说的函数式接口带来了一个专门的版本，以便在输入和输出都是原始类型时避免自动装箱的操作。这些函数式接口对原始类型进行了扩展，比如我们使用Predicate时需要指定输入参数的泛型T，如果输入的参数类型是可以确定的，比如int、long、double，那么我们就可以使用IntPredicate、LongPredicate、DoublePredicate等接口，这样可以避免使用包装类型，产生自动装箱操作。

    1. package com.mj.lambda;
    2.  
    3. import java.util.function.IntPredicate;
    4. import java.util.function.Predicate;
    5.  
    6. /**
    7.  * @author: gjm
    8.  * @description: IntPredicate
    9.  */
    10. public class UseIntPredicate {
    11.  
    12.     public static void main(String[] args) {
    13.         IntPredicate intPredicate = (int a) -> a==0;
    14.         intPredicate.test(0);            // 此时无自动装箱
    15.  
    16.         Predicate predicate = (Integer a) -> a==0;
    17.         predicate.test(0);               // 产生了自动装箱
    18.     } 
    19.  
    20. }
    • 自定义函数式接口。

           某些时候我们在java.util.function包下没找到符合自己要求的函数式接口时，我们可以自定义满足自己要求的函数式接口。根据函数式接口只有一个抽象方法的定义，我们也可以实现自定义函数式接口，从而来满足自己的开发。注意函数式接口上的@FunctionalInterface注解是非必需的，只是用来标识这是一个函数式接口，我们建议加上让代码更容易理解。

    1. package com.mj.lambda;
    2.  
    3. import java.lang.FunctionalInterface;
    4.  
    5. /**
    6.  * @author: gjm
    7.  * @description: 自定义函数式接口
    8.  */
    9. @FunctionalInterface
    10. public interface CustomFunInterface {
    11.  
    12.     R compute(T t, U u, X x);
    13. }
    1. package com.mj.lambda;
    2.  
    3. /**
    4.  * @author: gjm
    5.  * @description: 测试自定义函数式接口
    6.  */
    7. public class UseCustomFunInterface {
    8.  
    9.     public static void main(String[] args) {
    10.         Integer a = 90, b = 20, c = 30;
    11.         // 计算出a,b,c的最大值，并返回String
    12.         CustomFunInterface myFunInterface = (x, y, z)-> {
    13.             Integer max = x;
    14.             max = max > y ? max : y;
    15.             max = max > z ? max : z;
    16.             return max.toString();
    17.         };
    18.         String compute = myFunInterface.compute(a, b, c);
    19.         System.out.println(compute);
    20.  
    21.     }
    22.     
    23. }

     4. 什么是Stream流

          Stream流是Java 8 提供的新API，它主要是用来帮助我们简单和高效地处理集合数据的，Stream提供了集合处理的常用API。我们可以使用Stream的API配合前面学的函数式编程思想实现更简洁的声明式方法表达和几乎透明的并行处理。

         Java8之前如果我们想在集合中过滤掉并返回我们想要的数据，我们要对集合进行遍历，并书写自定义过滤逻辑处理再返回。这在代码层面往往不能够清晰地表达你所做的事情，Java8为我们提供了专门做这个事情的filter方法。

    1.    List employees = new ArrayList<>();
    2.    employees.add(new Employee(1L,"张三", 30));
    3.    employees.add(new Employee(2L,"李四", 25));
    4.    employees.add(new Employee(3L,"王五", 35));
    5.    List old = new ArrayList<>();
    6.    // Java8以前的写法
    7.    for(Employee e: employees){
    8.      if(e.getAge() >= 35)  old.add(e);
    9.      
    10.    }
    11.    // 使用Stream API的写法
    12.    old = employeeList.stream()
    13.                 .filter(employee -> employee.getAge() >=35).collect(toList());
    • Stream的filter方法，通过名称就能知道它的作用就是用于过滤数据，它只有一个参数并且类型是Predicate 的函数式接口，返回值为Stream，意味着它可以继续调用其它方法处理更复杂的逻辑，就像流一样把结果流向下一个方法处理。
    1.    List employees = new ArrayList<>();
    2.    employees.add(new Employee(1L,"张华", 35));
    3.    employees.add(new Employee(2L,"王五", 35));
    4.    employees.add(new Employee(3L,"张小樊", 21));
    5.    employees.add(new Employee(4L,"李东东", 25));
    6.    // 找到所有姓张的员工，并按年龄从小到大排序
    7.    List search = employeeList.stream()
    8.                 .filter(employee -> employee.getName().startsWith("张"))
    9.                 .sorted(Comparator.comparing(Employee::getAge))
    10.                 .collect(toList());
    •  Stream的map方法，map可以翻译为映射。这个名称比较有意思，我们可以这样理解，对于集合中的每一个元素，都可以通过一个函数的处理得到一个新的元素，这就叫映射。本质就是对流中每一个元素应用函数，使其做一种转换。它的方法参数是一个函数型的函数式接口Function，这也体现了它适合做类型转换的特点。
    1.    List roleRefResources = new ArrayList<>();
    2.    roleRefResources.add(new RoleRefResource(1L,"/api/employee","roleA"));
    3.    roleRefResources.add(new RoleRefResource(2L,"/api/department","roleB"));
    4.    roleRefResources.add(new RoleRefResource(3L,"/api/user","roleC"));
    5.    roleRefResources.add(new RoleRefResource(4L,"/api/employee","roleD"));
    6.    String resPath = "/api/employee";
    7.    // 获取可访问该资源路径的所有角色列表
    8.    List roles = roleRefResources.stream()
    9.                 // 过滤路径
    10.                 .filter(rr -> resPath.equals(rr.getResPath()))
    11.                 // 映射为角色名称
    12.                 .map(rr -> rr.getRoleName() )
    13.                 .collect(toList());
    • Stream的flatMap方法。这个方法主要用来做流的扁平化处理，我们可以理解为把每一个处理结果所返回的流都合并为一个流。它和map的区别是多了一步flat扁平化的操作，我们通常可以利用flatMap来做一些合并操作。
    1.    Integer[] a = new Integer[]{1,3,5,2};
    2.    Integer[] b = new Integer[]{1,4,5,9};
    3.    List list = Arrays.asList(a,b);
    4.    // 把a,b集合合并成一个新集合，并过滤重复元素
    5.    List uniqueInteger = list.stream()
    6.                         .flatMap(x -> Arrays.stream(x))  // 把每个集合都转换成流，并且合并
    7.                         .distinct()   // 对合并的这个流过滤重复元素
    8.                         .sorted()
    9.                         .collect(Collectors.toList());
    10.   System.out.println(uniqueInteger);
    • java.util.stream.Stream中的Stream接口定义了许多流操作（方法）。Stream的流操作主要分为两类：中间操作和终端操作，其中可以连接起来的流操作称为中间操作，关闭流的操作则称为终端操作。filter或sorted等中间操作会返回另一个流，返回的是流意味着它能继续执行其它流操作，就像工厂流水线一样分工执行。终端操作会从流的流水线生成结果，这返回的结果不再是任何的流而是Java中的各种类型List、Integer，或者是void。
    1.   long count = students.stream()
    2.                 .filter(s -> s.getGrade() >= 60) // 中间操作，返回的是流
    3.                 .distinct()  // 中间操作，返回的是流
    4.                 .limit(50)   // 中间操作，返回的是流
    5.                 .count();    // 终端操作，返回执行结果
    6.   System.out.println(count);
    • Stream接口的distinct方法，用于元素的去重，是一个中间操作。它会返回一个没有重复元素的流，当元素为对象类型时，需要根据流所生成元素的hashCode和equals方法判断是否重复。
    1.  List numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
    2.   numbers.stream()
    3.                .filter(i -> i % 2 == 0)  // 筛选偶数
    4.                .distinct()               // 排除重复元素
    5.                .forEach(System.out::println);  // 终端操作，打印元素
    • Stream接口的limit(n)方法，该方法用于截短流，限定生成流时的元素的个数是多少，也是一个中间操作。如果流是有序的，它会返回前n个元素；如果流是无序的，比如源是一个Set，它的limit结果也是无序的。
    1.   Set students = new HashSet<>();
    2.   students.add(new Student(10010, "李小军",77));
    3.   students.add(new Student(10013, "赵平",89));
    4.   students.add(new Student(10009, "刘小美",85));
    5.   // 输出结果是自己内部顺序，非元素放入顺序
    6.   students.stream().limit(5).forEach(System.out::println);
    • Stream接口的anyMatch方法，该方法用于至少匹配一个元素，只要有一个元素匹配就返回true，表示匹配成功。anyMatch方法返回一个boolean，因此是一个终端操作。
    1.   Set students = new HashSet<>();
    2.   students.add(new Student(10010, "李小军",77));
    3.   students.add(new Student(10013, "赵平",89));
    4.   students.add(new Student(10009, "刘小美",85));
    5.   // 判断是否有李小军这个学生
    6.   boolean b = students.stream().anyMatch(s -> "李小军".equals(s.getName()));
    7.   System.out.println(b);
    • Stream接口的findAny方法，该方法会返回当前流中的任意一个元素。findAny方法的返回结果是Optional类型，它可以帮我们处理结果为null值的情况，能够防止空指针。这个类也是JDK8新增加的容器类，后面也将会学习其使用。
    1.   Set students = new HashSet<>();
    2.   students.add(new Student(10010, "李小军",77));
    3.   students.add(new Student(10013, "赵平",89));
    4.   students.add(new Student(10009, "刘小美",85));
    5.   // 返回任意一个学生，并打印
    6.   Optional student = students.stream().findAny();
    7.   System.out.println(student.get());
    • Stream接口的reduce方法，该方法会对流元素进行归约操作，就是对流元素进行逐个处理，最终将流归约成一个值。我们通常使用这个方法做一些元素的累加和求最大最小值运算。
    1.    List list = Arrays.asList(1, 2, 4, 8);
    2.    // reduce接受两个参数：0是初始值，接收两个参数的Lambda表达式，归约操作是累加
    3.    Integer sum = list.stream().reduce(0, (a, b) -> a + b);
    4.    System.out.println(sum);
    5.    
    6.    // 求最大值操作，初始值为0，当元素为空时初始值为最大值
    7.    Integer max = numbers.stream().reduce(0, (x, y) -> x > y ? x : y);
    8.    Integer max = numbers.stream().reduce(0, Integer::max);
    9.    
    10.    // 求最大值操作，无初始值会返回Optional对象，因为元素为空时没有最大值
    11.    Optional max = numbers.stream().reduce(Integer::max);
    12.    System.out.println(max.get());
    13.    
    14.    // 求最小值操作，初始值为0，当元素为空时初始值为最大值
    15.    Integer min= numbers.stream().reduce(0, Integer::min);
    • 原始类型特化流接口IntStream、DoubleStream和LongStream。这三个流接口可以通过限定流元素类型来避免装箱操作带来的成本开销，这些接口都有进行常用数值归约的方法，比如sum和max等。
    1.    // 通过mapToInt转换成IntStream类型，即使用int类型的元素进行归约求和操作
    2.    int sum = students.stream().mapToInt(s -> s.getGrade()).sum();
    3.    System.out.println(sum);
    4.     
    5.    // 归约操作，找到最高的分数    
    6.    int max= students.stream().mapToInt(s -> s.getGrade()).max();
    7.    System.out.println(max);
    8.     
    9.    // IntStream转换为Stream，将所有int元素进行装箱，使用boxed()方法
    10.    IntStream intStream = students.stream().mapToInt(Student::getGrade);
    11.    Stream stream = intStream.boxed();

  • 相关阅读:
    [附源码]计算机毕业设计JAVA基于JSP社区生鲜配送系统
    下班后用微信处理工作时发病身亡，法院判决：工伤！
    温度敏感/PH敏感/电场敏感/温度/pH双重敏感/磁场敏感型水凝胶的制备
    使用phpMyAdmin管理WordPress数据库入门指南
    小白优化Oracle的利器”sqltrpt.sql”脚本
    原汁多功能榨汁机触摸芯片-DLT8T02S-杰力科创
    DDD领域驱动设计-视频讲解+实战
    怎么实现一个登录时需要输入验证码的功能
    求两个单链表的交点
    美国访问学者签证如何申请加急办理？
  • 原文地址：https://blog.csdn.net/G_12_M/article/details/130724480