上一篇文章：基于Java8的Lambda表达式（1）
本篇继续讲几个常用的写法：

01.代码

package com.lambda;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.*;

public class TestLambda1 {

    public static void main(String[] args) {
        List<Sales> salesList1 = new ArrayList<>();
        salesList1.add(new Sales("天猫", 1000));
        salesList1.add(new Sales("亚马逊", 200));
        salesList1.add(new Sales("大润发", 600));
        salesList1.add(new Sales("欧尚", 800));
        salesList1.add(new Sales("京东", 8000));

        List<Sales> salesList2 = new ArrayList<>();
        salesList2.add(new Sales("天猫-1", 10));
        salesList2.add(new Sales("亚马逊-1", 20));
        salesList2.add(new Sales("大润发-1", 30));
        salesList2.add(new Sales("欧尚-1", 40));
        salesList2.add(new Sales("京东-1", 50));

        //1. 筛选出销售量大于800的渠道  filter
        List<Sales> list1 = salesList1.stream()
                .filter((sales) -> {
                    //返回true的Sales对象会被留下来
                    return sales.getSaleCount() > 800;
                })
                .collect(Collectors.toList());
        for (Sales s : list1) {
            System.out.println(s.getChannelName() + " " + s.getSaleCount());
        }

        //2. 把两个集合对象里的元素整合到一个集合里  flatMap
        //传统写法
        salesList1.addAll(salesList2);
        for (Sales s : salesList1) {
            System.out.println(s.getChannelName() + " " + s.getSaleCount());
        }
        //lambda写法：体现了对集合类数据的处理特点
        Stream<List<Sales>> inputStream = Stream.of(salesList1,salesList2);
        List<Sales> outputList = inputStream
                .flatMap((childList) -> childList.stream())
                .collect(Collectors.toList());
        for (Sales s : outputList) {
            System.out.println(s.getChannelName() + " " + s.getSaleCount());
        }

        //3, 如果电脑是多核的，可以试试并行计算的效率， parallel
        //可能要针对很耗时的处理问题才有效果吧，我试了常规的测试没啥变化

        //4, 把所有的销售数量累加起来 reduce
        //传统写法
        Integer count1=0;
        for(Sales obj : outputList) {
            count1 += obj.getSaleCount();
        }
        System.out.println(count1);

        //lambda写法
        Integer count2 = outputList.stream()
                //先把Sales对象流转换为销售量Integer的流
                .map(Sales::getSaleCount)
                //叠加Integer
                .reduce(Integer::sum)
                .get();
        System.out.println(count2);
    }
}

02.说明

• filter
  filter函数需要传入一个实现Predicate函数式接口的对象，该接口的抽象方法test接收一个参数并返回一个boolean值，留下返回true的数据。

• flatMap
  flatMap函数（注意flat这个单词，很形象），类似把一个二组数组的元素，扁平化到一维数组里。对多个流的整合处理有较大作用。

• parallel
  书上说是针对多核处理器的一种并行操作，暂时还没体会到效果。

• reduce
  reduce函数也很形象（类似sql语句里的sum函数），把stream里的一串数据经过处理缩减为一个数据。

• distinct、limit、skip、findFirst、max、min
  以上函数看名称就大概知道什么意思，大家可以都去试一下。

由于作者水平有限，难免出现纰漏，如有问题请帮忙指正，谢谢！