java8 集合流式操作

一、 集合相关的中间操作 和 最终操作        
中间操作：
  • filter()： 对元素进行过滤
  • sorted()：对元素排序
  • map()：元素映射
  • distinct()：去除重复的元素
最终操作：
  • forEach()：遍历每个元素。
  • reduce()：把Stream 元素组合起来。例如，字符串拼接，数值的 sum，min，max ，average 都是特殊的 reduce。
  • collect()：返回一个新的集合。
  • min()：找到最小值。
  • max()：找到最大值。
 
3.1 filter() 对元素进行过滤
Demo（有一链表，{1,2,3,4,5}，把偶数过滤掉）： 
package com.dxz.study.jdk8;

import java.util.ArrayList;
import java.util.List;

public class Stream {
     public static void main(String[] args) throws InterruptedException {  
            List list = new ArrayList();  
            for(int i = 1 ; i <= 5; ++i){  
                list.add(i);  
            }  
            list.stream().filter(param -> (int)param % 2 == 1)  
                        .forEach(System.out::println);  
        }  
}
输出： 
1
3
5
3.2 sorted() 对元素进行排序
Demo（有一链表，{2,3,1,5,4}，从小到大排序）： 
        public static void sorted() {
        List list = new ArrayList();
        list.add(2);
        list.add(3);
        list.add(1);
        list.add(5);
        list.add(4);
        list.stream().sorted().forEach(System.out::println);
    }
 
输出： 
1
2
3
4
5
 
Ps1： 此时为升序，那么有时候我们可能会需要到降序，此时做法可以如下：
        流除了提供默认的升序 sorted() 方法，也提供了：    
Stream<T> sorted(Comparator<? super T> comparator);
        那么，自定义比较函数即可，如下代码： 
public static void test2() {
        List list = new ArrayList();  
        list.add(2);  
        list.add(3);  
        list.add(1);  
        list.add(5);  
        list.add(4);  
//      list.stream().sorted().forEach(System.out::println);  
        list.stream().sorted( (param1,param2) -> ((int)param1 < (int)param2 ? 1 : -1 ) )  
                .forEach(System.out::println);  
    }
输出为： 
5
4
3
2
1
3.3 map() 元素映射
        也就是说，原来的链表的每个元素可以按照规则变成相应的元素。
Demo（链表 (1,0)，变成 true，false）： 
       public static void test3() {
        List list = new ArrayList();  
        list.add(1);  
        list.add(0);  
        list.stream().map( param -> (int)param == 1 ? true:false )  
                .forEach(System.out::println);
    }
输出： 
true
false

我们先给map添加几个值：

        Map<String, String> someMap = new HashMap<>();
        someMap.put("jack","20");
        someMap.put("bill","35");

上面我们添加了name和age字段。

如果我们想查找age=20的key，则可以这样做：

复制代码
public class MapTest {

    public static void main(String[] args) {
        Map<String, String> someMap = new HashMap<>();
        someMap.put("jack","20");
        someMap.put("bill","35");
        Optional<String> optionalName = someMap.entrySet().stream()
                .filter(e -> "20".equals(e.getValue()))
                .map(Map.Entry::getKey)
                .findFirst();

        System.out.println(optionalName.get());
    }
}
复制代码

结果：

jack

因为返回的是Optional,如果值不存在的情况下，我们也可以处理：

        optionalName = someMap.entrySet().stream()
                .filter(e -> "Non ages".equals(e.getValue()))
                .map(Map.Entry::getKey).findFirst();

        System.out.println(optionalName.isPresent());

上面的例子我们通过调用isPresent来判断age是否存在。

如果有多个值，我们可以这样写：

复制代码
        someMap.put("alice","20");
        List<String> listnames = someMap.entrySet().stream()
                .filter(e -> e.getValue().equals("20"))
                .map(Map.Entry::getKey)
                .collect(Collectors.toList());

        System.out.println(listnames);
复制代码

上面我们调用了collect(Collectors.toList())将值转成了List。

结果：

[alice, jack]

上面我们获取的map的key，同样的我们也可以获取map的value：

        List<String> listAges = someMap.entrySet().stream()
                .filter(e -> e.getKey().equals("alice"))
                .map(Map.Entry::getValue)
                .collect(Collectors.toList());
        System.out.println(listAges);

上面我们匹配了key值是alice的value。

结果：

[20]
3.4  distinct() 去除重复元素
Demo： 
public static void test4() {
        List list = new ArrayList();
        list.add(1);
        list.add(1);
        list.add(0);
        list.stream().distinct().forEach(System.out::println);
    }
1
0
3.5 reduce() ：把Stream 元素组合起来。
Demo（从1加到5）： 
public static void test5() {
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        System.out.println(list.stream().reduce((param1, param2) -> (int) param1 + (int) param2).get());
    }
15
 注意，reduce() 返回一个 Optional 类型的对象，可以通过 get() 方法获得值。

3.6 collect() ：返回一个新的集合
Demo（先把 list 集合的 奇数去掉，然后把剩下的偶数返回到 _list 集合中）： 
public static void test6() {
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        List _list = (List) list.stream().filter((param) -> (int) param % 2 == 0).collect(Collectors.toList());
        _list.forEach(System.out::println);
    }
输出： 
2
4
3.7 min()，max()  找到最大值最小值 
public static void test7() {
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        System.out.println(list.stream().min((param1, param2) -> (int) param1 > (int) param2 ? 1 : -1).get());
        System.out.println(list.stream().max((param1, param2) -> (int) param1 > (int) param2 ? 1 : -1).get());
    }
 结果 
1
5
    注意， min()，max() 方法也是返回 Optional 对象， 可以通过 get() 方法返回值。
        
总结：
1. 流式操作的引入：提高执行效率（并行），方便编码（有很多API 可用），提高可读性。
2. 流的分类：可以分为串行流和并行流；对于操作：可以分为中间操作和最终操作
3. 流API：
        中间操作：
                filter()： 对元素进行过滤；
                sorted()：对元素排序；
                map()：元素映射；
                distinct()：去除重复的元素 。
        最终操作：
                forEach()：遍历每个元素；
                reduce()：把Stream 元素组合起来。例如，字符串拼接，数值的 sum，min，max ，average 都是特殊的 reduce。
                collect()：返回一个新的集合。
                min()：找到最小值。
                max()：找到最大值。
 
 
参考：
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/duanxz/p/2598726.html