JDK8中的Lambda和StreamApi

傷城~ 2022-12-29 00:14 121阅读 0赞

# Lambda #

本文只是简单记录，供自己查阅，详细的还请看 [恕我直言，你真的不会JAVA系列][JAVA]

（param1，param2，param3 ...，paramN）-  > {    //代码块； }

# 准备数据 #

数据会在下面多个例子中用到

Employee e1 = new Employee(1,23,"M","Rick","Beethovan");
    Employee e2 = new Employee(2,13,"F","Martina","Hengis");
    Employee e3 = new Employee(3,43,"M","Ricky","Martin");
    Employee e4 = new Employee(4,26,"M","Jon","Lowman");
    Employee e5 = new Employee(5,19,"F","Cristine","Maria");
    Employee e6 = new Employee(6,15,"M","David","Feezor");
    Employee e7 = new Employee(7,68,"F","Melissa","Roy");
    Employee e8 = new Employee(8,79,"M","Alex","Gussin");
    Employee e9 = new Employee(9,15,"F","Neetu","Singh");
    Employee e10 = new Employee(10,45,"M","Naveen","Jain");
    List<Employee> employees = Arrays.asList(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10);

# StreamApi #

## filter ##

我理解为过滤、帅选

如下过滤元素中age大于70且为男性的元素

List<Employee> filtered = employees.stream()
            .filter(e -> e.getAge() > 70 && e.getGender().equals("M"))
            .collect(Collectors.toList());

还可以把上面的age大于70且性别为男性定义出来，这个叫谓词逻辑

public static Predicate<Employee> ageGreaterThan70 = x -> x.getAge() >70;
    public static Predicate<Employee> genderM = x -> x.getGender().equals("M");

然后就可以使用

List<Employee> filtered = employees.stream()
            .filter(Employee.ageGreaterThan70.and(Employee.genderM))
            .collect(Collectors.toList());

除了`and`还有`or(交集)`和`negate(取反)`

List<Employee> filtered = employees.stream()
            .filter(Employee.ageGreaterThan70.or(Employee.genderM))
            .collect(Collectors.toList());

List<Employee> filtered = employees.stream()
            .filter(Employee.ageGreaterThan70.or(Employee.genderM).negate())
            .collect(Collectors.toList());

## map、peek、flatMap ##

**map**  
map可以理解为转换、映射

比如如下可以输出员工的name信息

employees.stream().map(e->e.getName).forEach(System.out::println)

或者把name转大写然后输出

employees.stream().map(String::toUpperCase).forEach(System.out::println)

**peek**  
peek可以理解为无返回值的map，比如我们希望员工年龄+1，输出性别的全部子母，用peek可以如下实现

List<Employee> maped = employees.stream()
                .peek(e -> { 
                    e.setAge(e.getAge() + 1);
                    e.setGender(e.getGender().equals("M")?"male":"female");
                }).collect(Collectors.toList());

用map则需要返回值

List<Employee> maped = employees.stream()
                .map(e -> { 
                    e.setAge(e.getAge() + 1);
                    e.setGender(e.getGender().equals("M")?"male":"female");
                    return e;
                }).collect(Collectors.toList());

**flatMap**  
map可以对管道流中的数据进行转换操作，但是如果管道中还有管道该如何处理？即：如何处理二维数组及二维集合类。实现一个简单的需求：将“hello”，“world”两个字符串组成的集合，元素的每一个字母打印出来。

如果用map会发现打印出来的依然是两个stream

List<String> words = Arrays.asList("hello", "word");
    words.stream()
            .map(w -> Arrays.stream(w.split("")))    //[[h,e,l,l,o],[w,o,r,l,d]]
            .forEach(System.out::println);

如果是用flatMap就可以实现

words.stream()
            .flatMap(w -> Arrays.stream(w.split(""))) // [h,e,l,l,o,w,o,r,l,d]
            .forEach(System.out::println);

## Limit、Skip、Distinct、parallel ##

**limit**  
取前面两个元素

List<String> limitN = Stream.of("Monkey", "Lion", "Giraffe", "Lemur")
            .limit(2)
            .collect(Collectors.toList()); // ["Monkey", "Lion"]

**skip**  
取除前面两个元素之外的元素

List<String> skipN = Stream.of("Monkey", "Lion", "Giraffe", "Lemur")
            .skip(2)
            .collect(Collectors.toList()); // ["Giraffe", "Lemur"]

**Distinct 去重**

List<String> uniqueAnimals = Stream.of("Monkey", "Lion", "Giraffe", "Lemur", "Lion")
            .distinct()
            .collect(Collectors.toList());	//["Monkey", "Lion", "Giraffe", "Lemur"]

**parallel 并行**

Stream.of("Monkey", "Lion", "Giraffe", "Lemur", "Lion")
            .parallel()
            .forEach(System.out::println); // ["Monkey", "Lion", "Lemur", "Giraffe", "Lion"]

由于不能保证元素的顺序性，所以最好不要用什么limit这种，不然你limit的元素是不确定的

## sorted排序 ##

List<String> cities = Arrays.asList(
            "Milan",
            "london",
            "San Francisco",
            "Tokyo",
            "New Delhi"
    );

使用Comparator.naturalOrder()字母自然顺序排序，结果是：\[Milan, New Delhi, San Francisco, Tokyo, london\]

cities.stream().sorted(Comparator.naturalOrder()).forEach(System.out::println);

## 查找与匹配 ##

**anyMatch**

boolean isExistAgeThan70 = employees.stream().anyMatch(Employee.ageGreaterThan70);
    // 或者
    boolean isExistAgeThan72 = employees.stream().anyMatch(e -> e.getAge() > 70);

anyMatch，判断Stream流中是否包含某一个“匹配规则”的元素。这个匹配规则可以是lambda表达式或者谓词。

**allMatch**

boolean isExistAgeThan10 = employees.stream().allMatch(e -> e.getAge() > 10);

allMatch匹配规则函数：判断是够Stream流中的所有元素都符合某一个"匹配规则"。

**noneMatch**

oolean isExistAgeLess18 = employees.stream().noneMatch(e -> e.getAge() < 18);

noneMatch匹配规则函数：判断是否Stream流中的所有元素都不符合某一个"匹配规则"。

## Optional 非空处理 ##

从列表中按照顺序查找第一个年龄大于40的员工。

Optional<Employee> employeeOptional
            =  employees.stream().filter(e -> e.getAge() > 40).findFirst();
    System.out.println(employeeOptional.get());

Optional类代表一个值存在或者不存在。在java8中引入，这样就不用返回null了。

*  isPresent() 将在 Optional 包含值的时候返回 true , 否则返回 false 。
 *  ifPresent(Consumer block) 会在值存在的时候执行给定的代码块。
 *  T get() 会在值存在时返回值，否则?出一个 NoSuchElement 异常。
 *  T orElse(T other) 会在值存在时返回值，否则返回一个默认值。

## reduce 规约 ##

求和

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
    int result = numbers
            .stream()
            .reduce(0, (subtotal, element) -> subtotal + element);
    System.out.println(result);  //21
    
    int result = numbers
            .stream()
            .reduce(0, Integer::sum);
    System.out.println(result); //21

字符串拼接

List<String> letters = Arrays.asList("a", "b", "c", "d", "e");
    String result = letters
            .stream()
            .reduce("", (partialString, element) -> partialString + element);
    System.out.println(result);  //abcde
    
    
    String result = letters
            .stream()
            .reduce("", String::concat);
    System.out.println(result);  //ancde

复杂对象归约

Integer total = employees.stream().map(Employee::getAge).reduce(0,Integer::sum);
    System.out.println(total); //346

这里用了map先把流中的对象转成了Age，也可以不转直接用reduce

因为Stream流中的元素是Employee，累加器的返回值是Integer，所以二者的类型不匹配。这种情况下可以使用Combiner合并器对累加器的结果进行二次归约，相当于做了类型转换。

Integer total3 = employees.stream()
            .reduce(0,(totalAge,emp) -> totalAge + emp.getAge(),Integer::sum); //注意这里reduce方法有三个参数
    System.out.println(total); //346

在进行并行流计算的时候，可能会将集合元素分成多个组计算。为了更快的将分组计算结果累加，可以使用合并器。

Integer total2 = employees
            .parallelStream()
            .map(Employee::getAge)
            .reduce(0,Integer::sum,Integer::sum);  //注意这里reduce方法有三个参数
    
    System.out.println(total); //346

## ForEach和ForEachOrdered ##

Stream.of("Monkey", "Lion", "Giraffe", "Lemur", "Lion")
            .parallel()
            .forEach(System.out::println);
    Stream.of("Monkey", "Lion", "Giraffe", "Lemur", "Lion")
            .parallel()
            .forEachOrdered(System.out::println);

*  parallel()函数表示对管道中的元素进行并行处理，而不是串行处理，这样处理速度更快。但是这样就有可能导致管道流中后面的元素先处理，前面的元素后处理，也就是元素的顺序无法保证
 *  forEachOrdered从名字上看就可以理解，虽然在数据处理顺序上可能无法保障，但是forEachOrdered方法可以在元素输出的顺序上保证与元素进入管道流的顺序一致。

## 元素的收集collect ##

**收集为set**

Set<String> collectToSet = Stream.of(
       "Monkey", "Lion", "Giraffe", "Lemur", "Lion"
    ) 
    .collect(Collectors.toSet());

**收集为list**

List<String> collectToList = Stream.of(
       "Monkey", "Lion", "Giraffe", "Lemur", "Lion"
    ).collect(Collectors.toList());

**通用的收集方式**

LinkedList<String> collectToCollection = Stream.of(
       "Monkey", "Lion", "Giraffe", "Lemur", "Lion"
    ).collect(Collectors.toCollection(LinkedList::new));
    、、

当然你还可以使用诸如LinkedHashSet::new和PriorityQueue::new将数据元素收集为其他的集合类型，这样就比较通用了。  
**收集到Array**

String[] toArray = Stream.of(
       "Monkey", "Lion", "Giraffe", "Lemur", "Lion"
    ) .toArray(String[]::new);

**收集到Map**  
使用Collectors.toMap()方法将数据元素收集到Map里面，但是出现一个问题：那就是管道中的元素是作为key，还是作为value。我们用到了一个Function.identity()方法，该方法很简单就是返回一个“ t -> t ”（输入就是输出的lambda表达式）。另外使用管道流处理函数distinct()来确保Map键值的唯一性。

Map<String, Integer> toMap = Stream.of(
        "Monkey", "Lion", "Giraffe", "Lemur", "Lion"
    )
    .distinct()
    .collect(Collectors.toMap(
           Function.identity(),   //元素输入就是输出，作为key
           s -> (int) s.chars().distinct().count()// 输入元素的不同的字母个数，作为value
    ));
    
    // 最终toMap的结果是: {Monkey=6, Lion=4, Lemur=5, Giraffe=6}

**分组收集groupingBy**  
Collectors.groupingBy用来实现元素的分组收集，下面的代码演示如何根据首字母将不同的数据元素收集到不同的List，并封装为Map。

Map<Character, List<String>> groupingByList =  Stream.of(
        "Monkey", "Lion", "Giraffe", "Lemur", "Lion"
    )
    .collect(Collectors.groupingBy(
           s -> s.charAt(0) ,  //根据元素首字母分组，相同的在一组
           // counting() // 加上这一行代码可以实现分组统计
    ));
    
    // 最终groupingByList内的元素: {G=[Giraffe], L=[Lion, Lemur, Lion], M=[Monkey]}
    //如果加上counting() ，结果是: {G=1, L=3, M=1}

## 排序Map ##

**HashMap的merge()函数**  
该函数应用场景就是当Key重复的时候，如何处理Map的元素值。这个函数有三个参数：

*  参数一：向map里面put的键
 *  参数二：向map里面put的值
 *  参数三：如果键发生重复，如何处理值。可以是一个函数，也可以写成lambda表达式。

String k = "key";
    HashMap<String, Integer> map = new HashMap<String, Integer>() { { 
        put(k, 1);
    }};
    map.merge(k, 2, (oldVal, newVal) -> oldVal + newVal);

看上面一段代码，我们首先创建了一个HashMap，并往里面放入了一个键值为k:1的元素。当我们调用merge函数，往map里面放入k:2键值对的时候，k键发生重复，就执行后面的lambda表达式。表达式的含义是：返回旧值oldVal加上新值newVal(1+2)，现在map里面只有一项元素那就是k:3。

**按Map的键排序**

// 创建一个Map，并填入数据
    Map<String, Integer> codes = new HashMap<>();
    codes.put("United States", 1);
    codes.put("Germany", 49);
    codes.put("France", 33);
    codes.put("China", 86);
    codes.put("Pakistan", 92);
    
    // 按照Map的键进行排序
    Map<String, Integer> sortedMap = codes.entrySet().stream()    
            .sorted(Map.Entry.comparingByKey())
            .collect(
                    Collectors.toMap(
                        Map.Entry::getKey, 
                        Map.Entry::getValue,
                        (oldVal, newVal) -> oldVal,
                        LinkedHashMap::new
                    )
            );
    
    // 将排序后的Map打印
    sortedMap.entrySet().forEach(System.out::println);

看上文中第二段代码：

*  首先使用entrySet().stream() 将Map类型转换为Stream流类型。
 *  然后使用sorted方法排序，排序的依据是Map.Entry.comparingByKey()，也就是按照Map的键排序
 *  最后用collect方法将Stream流转成LinkedHashMap。 其他参数都好说，重点看第三个参数，就是一个merge规则的lambda表达式，与merge方法的第三个参数的用法一致。由于本例中没有重复的key，所以新值旧值随便返回一个即可。

**按Map的值排序**

Map<String, Integer> sortedMap2 = codes.entrySet().stream()
            .sorted(Map.Entry.comparingByValue())
            .collect(Collectors.toMap(
                    Map.Entry::getKey,
                    Map.Entry::getValue,
                    (oldVal, newVal) -> oldVal,
                    LinkedHashMap::new));
    
    sortedMap2.entrySet().forEach(System.out::println);

**使用TreeMap(最简单有效的方法)**  
TreeMap内的元素是有顺序的，所以利用TreeMap排序也是可取的一种方法。

Map<String, Integer> codes = new HashMap<>();
    codes.put("United States", 1);
    codes.put("Germany", 49);
    codes.put("France", 33);
    codes.put("China", 86);
    codes.put("Pakistan", 92);
    Map<String, Integer> sorted = new TreeMap<>(codes);

[JAVA]: https://www.kancloud.cn/hanxt/javacrazy/1572192