天天看点
返回

Java8之22个lambda表达式用法入门示例超简单，这还不会你就out了

作者：程序员拾山

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

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

Java8之22个lambda表达式用法入门示例超简单，这还不会你就out了

中间型操作

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"]
Java8之22个lambda表达式用法入门示例超简单，这还不会你就out了

最终型操作

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));

#头条创作挑战赛#

我是@程序员拾山，欢迎关注我，期待与大家一起学习成长，也感谢您的点赞和关注。

lambda表达式 入门示例 lambda JAVA8 lamb
上一篇: GQ向来是懂红毯的？张嘉倪惊艳田曦薇成焦点，连文案小编也抢戏？
下一篇: 在国外最大艺术平台上，画师们掀起了一场反AI的赛博游行

继续阅读