Java8之22个lambda表达式用法入门示例超简单，这还不会你就Out了-51CTO.COM

lambda表达式简明扼要的以流水线的方式去处理集合内的数据，可以很轻松的完成过滤、分组、收集、归约这类操作。

总得来说，lambda的操作分为两类：中间型和最终型。

中间型操作

1、filter

filter会按照指定的条件匹配出符合要求的元素，并返回一个新的stream流，可以配合其他中间型或最终型API使用。

示例：

List<String> dataList = Lists.newArrayList("first", "second", "third");
List<String> filter = dataList.stream()
        .filter(
          //筛选出值为second的匹配项
          data -> data.equals("second")
        )
        .collect(Collectors.toList());
System.out.println(filter);// [second]

2、map

map可以将一个对象转换为另一个对象，并返回一个新的stream流，比如将一个Integer对象转换为String对象。

示例：

List<Integer> dataList = Lists.newArrayList(1, 2, 3);
List<String> transform = dataList.stream()
        .map(
            //也可以写成String::valueOf
            data -> String.valueOf(data)
        )
        .collect(Collectors.toList());
System.out.println(JSON.toJSONString(transform));// ["1","2","3"]

3、peek

peek会对流中的元素逐个遍历处理，它与map的区别在于：map一般用于对象的转换，peek用于对象的消费，即不改变元素本身的类型。

List<String> dataList = Lists.newArrayList("a", "b", "c");
List<String> transform = dataList.stream()
    //peek是对元素逐一消费，在这里程序会逐个打印a、b、c
    .peek(data -> System.out.println(data))
    //map是对元素进行转换，这里将其转成大写：["A","B","C"]
    .map(data -> data.toUpperCase())
    .collect(Collectors.toList());

4、flatMap

flatMap可以将已有的对象转换为另一个对象，它是一个一对多的逻辑。它与map的区别在于：map是一对一的，即将一个对象转换为另一个对象，而flatMap是一对多的，即将一个对象拆分对多个对象。

//将["hello", "world"]转换为["h","e","l","l","o","w","o","r","l","d"]
List<String> dataList = Lists.newArrayList("hello", "world");
List<String> transform = dataList.stream()
    .flatMap(
      data -> Arrays.stream(data.split(""))
    )
    .collect(Collectors.toList());
System.out.println(JSON.toJSONString(transform));

5、limit

就相当于sql中的limit，可以指定保留前N的元素。

List<String> dataList = Lists.newArrayList("hello", "world", "good", "boy");
List<String> transform = dataList.stream()
      .limit(2)
      .collect(Collectors.toList());
System.out.println(JSON.toJSONString(transform));
//["hello","world"]

6、skip

作用与limit相反，会抛弃前N的元素。

List<String> dataList = Lists.newArrayList("hello", "world", "good", "boy");
List<String> transform = dataList.stream()
      .skip(2)
      .collect(Collectors.toList());
System.out.println(JSON.toJSONString(transform));
//["good","boy"]

7、concat

可以将多个流的数据合并为一个流。

List<String> transform = Stream.concat(
      Stream.of("hello"),
      Stream.of("world")
    ).collect(Collectors.toList());
System.out.println(JSON.toJSONString(transform));
//["hello","world"]

8、distinct

用于对流中的元素去重。

ArrayList<String> dataList = Lists.newArrayList("1", "2", "2", "3", "3");
List<String> transform = dataList.stream().distinct().collect(Collectors.toList());
System.out.println(JSON.toJSONString(transform));
//["1","2","3"]

9、sorted

用于对流中的数据排序。

ArrayList<String> dataList = Lists.newArrayList("1", "3", "4", "2", "3");
List<String> transform = dataList.stream()
    .sorted(
      Comparator.comparingInt(Integer::parseInt)
    )
    .collect(Collectors.toList());
System.out.println(JSON.toJSONString(transform));
//["1","2","3","3","4"]

最终型操作

10、count

统计元素的个数，不会自动去重。

ArrayList<String> dataList = Lists.newArrayList("1", "3", "4", "2", "3");
long count = dataList.stream().count();
System.out.println(count);
//5

11、max

匹配元素最大值并返回。

ArrayList<String> dataList = Lists.newArrayList("1", "3", "4", "2", "3");
String max  = dataList.stream().max(
    Comparator.comparing(Integer::parseInt)
  ).get();
System.out.println(max);
//4

12、min

匹配元素最小值并返回。

ArrayList<String> dataList = Lists.newArrayList("1", "3", "4", "2", "3");
String min  = dataList.stream().min(
    Comparator.comparing(Integer::parseInt)
  ).get();
System.out.println(min);
//1

13、findFirst

找到第一个匹配的元素后立即返回。

ArrayList<String> dataList = Lists.newArrayList("1", "3", "4", "2", "3");
String first  = dataList.stream().findFirst().get();
System.out.println(first);
//1

14、findAny

找到任何匹配的元素就返回。如果用在一个串行流中，跟findFirst效果一样。如果用在并行流中，就会比较高效。

int asInt = IntStream.range(1, 10).parallel().findAny().getAsInt();
System.out.println(asInt);
//6

15、anyMatch

用于判断是否有符合匹配条件的元素。

ArrayList<String> dataList = Lists.newArrayList("1", "3", "4", "2", "3");
boolean match  = dataList.stream().anyMatch(
    data -> data.equals("3")
  );
System.out.println(match);
//true

16、allMatch

用于判断是否所有元素都符合匹配条件。

ArrayList<String> dataList = Lists.newArrayList("1", "3", "4", "2", "3");
boolean match  = dataList.stream().allMatch(
      data -> data.equals("3")
   );
System.out.println(match);
//false

17、noneMatch

用于判断是否所有元素都不符合匹配条件。

ArrayList<String> dataList = Lists.newArrayList("1", "3", "4", "2", "3");
boolean match  = dataList.stream().noneMatch(
    data -> data.equals("3")
);
System.out.println(match);
//false

18、collect

将流转换为指定的类型，比如List转换为Set。

ArrayList<String> dataList = Lists.newArrayList("1", "3", "4", "2", "3");
Set<String> collect = dataList.stream().collect(Collectors.toSet());
System.out.println(collect);
//[1, 2, 3, 4]

19、reduce

将元素合并起来，得到一个新值。

int reduce = IntStream.range(0, 10).reduce(0, (v1, v2) -> v1 + v2);
System.out.println(reduce);//45

20、toArray

将流转换为数组。

ArrayList<String> dataList = Lists.newArrayList("1", "3", "4", "2", "3");
Object[] collect = dataList.stream().toArray();
System.out.println(JSON.toJSONString(collect));
//["1","3","4","2","3"]

21、iterator

将流转换为一个迭代器。

ArrayList<String> dataList = Lists.newArrayList("1", "3", "4", "2", "3");
Iterator<String> iterator = dataList.stream().iterator();
while (iterator.hasNext()) {
  System.out.println(iterator.next());
}

22、foreach

对流中的元素逐个遍历。

ArrayList<String> dataList = Lists.newArrayList("1", "3", "4", "2", "3");
dataList.stream().forEach(
    data -> System.out.println(data)
);
//等同于
dataList.forEach(data-> System.out.println(data));