Java8 流式操作整理

简介：Stream 中文称为 “流”，通过将集合转换为这么一种叫做 “流” 的元素序列，通过声明性方式，能够对集合中的每个元素进行一系列并行或串行的流水线操作。

操作分类：

 

常见流操作API

中间操作

filter()： 对元素进行过滤
map()：元素映射
sorted()：对元素排序
distinct()：去除重复的元素

最终操作：

forEach()：遍历每个元素。
findFirst()：找第一个符合要求的元素。
reduce()：把Stream 元素组合起来。例如，字符串拼接，数值的 sum，min，max ，average 都是特殊的 reduce。
collect()：返回一个新的数据结构，基于Collectors有丰富的处理方法。
min()：找到最小值。
max()：找到最大值。

中间操作：中间操作包括去重、过滤、映射等操作,值得说明的是,如果没有为流定义终端操作,为了避免无谓的计算,中间操作也不会执行

终端操作：终端产生最终的执行结果,并中断流式编程的衔接链,因此结束操作是最后一个操作

案例说明

以下案例基于初始数据，生成代码如下：

private static List<DemoVO> initList(){
    List<DemoVO> list = new ArrayList<>();
    DemoVO demo1 = new DemoVO();
    demo1.setKey("a");
    demo1.setValue("str-a");
    list.add(demo1);
    DemoVO demo2 = new DemoVO();
    demo2.setKey("b");
    demo2.setValue("str-b");
    list.add(demo2);
    DemoVO demo3 = new DemoVO();
    demo3.setKey("c");
    demo3.setValue("str-c");
    list.add(demo3);
    return list;
}

1.filter过滤

private static void testFilter(List<DemoVO> list){
    List<DemoVO> listNew = list.stream().filter(item->item.getKey().equals("a")).collect(Collectors.toList());
    System.out.println(JSON.toJSONString(listNew));
}

输出结果：
[{"key":"a","value":"str-a"}]

● 比较两个List，得到差异元素

List<String> list1 = Arrays.asList("A", "B", "C", "D");
List<String> list2 = Arrays.asList("B", "C", "E", "F", "A", "D");
List<String> diff = list1.stream().filter(item -> !list2.contains(item)).collect(Collectors.toList());
List<String> diff1 = list2.stream().filter(item -> !list1.contains(item)).collect(Collectors.toList());
diff.addAll(diff1);
 
diff.forEach(x -> System.out.println(x));

2.Map映射

private static void listToMap(List<DemoVO> list){
    Map<String,DemoVO> demoMap1 = list.stream().collect(Collectors.toMap(DemoVO::getKey, Function.identity()));
    //当出现同名Key时，用后者替换前者
    Map<String,DemoVO> demoMap2 = list.stream().collect(Collectors.toMap(DemoVO::getKey, Function.identity(),(key1, key2) -> key2));
    System.out.println(JSON.toJSONString(demoMap1));
}



输出结果：
{"a":{"key":"a","value":"str-a"},"b":{"key":"b","value":"str-b"},"c":{"key":"c","value":"str-c"}}

3.sorted排序

private static void testSorted(List<DemoVO> list){
    //自然排序，先对key进行排序，再对value进行排序。
    List<DemoVO> collect = list.stream().sorted(Comparator.comparing(DemoVO::getKey).thenComparing(DemoVO::getValue)).collect(Collectors.toList());
    System.out.println(JSON.toJSONString(collect));
    collect = list.stream().sorted(Comparator.comparing(DemoVO::getKey).thenComparing(DemoVO::getValue)).collect(Collectors.toList());
    System.out.println(JSON.toJSONString(collect));
}



输出结果：
[{"key":"a","value":"str-a"},{"key":"b","value":"str-b"},{"key":"c","value":"str-c"}]

4.distinct去重

//原始数据新增
DemoVO demo4 = new DemoVO();
demo4.setKey("c");
demo4.setValue("str-c");
list.add(demo4);

//去重
private static void testDistinct(List<DemoVO> list){
    List<DemoVO> collect = list.stream().distinct().collect(Collectors.toList());
    System.out.println(JSON.toJSONString(collect));
}




//输出结果
[{"key":"a","value":"str-a"},{"key":"b","value":"str-b"},{"key":"c","value":"str-c"}]

5.List<Object>转List<attribute>

private static void convertToList(List<DemoVO> list){
    List<String> collect = list.stream().map(DemoVO::getValue).collect(Collectors.toList());
    System.out.println(JSON.toJSONString(collect));
}



//输出结果
["str-a","str-b","str-c"]

5.groupingBy分组

private static void groupList(List<DemoVO> list){
    Map<String,List<DemoVO>> demoMap = files.stream().collect(Collectors.groupingBy(DemoVO::getKey));
}



//输出结果
{"a":["str-a"],"b":["str-b"],"c":["str-c"]}