TIP

本文主要是介绍 lambda表达式-使用案例总结 。

• Java8 Lambda 使用案例总结
• 一、演示示例
• 1.遍历
• 2.去重
• 3.获取对象中的某个参数为一个新的List
• 4.获取对象中的某个参数为一个新的Map
• 5.过滤器
• 6.排序
• 7.分组
• 8.以对象中的两个值，组成Map
  • 这里有个坑
• 9.将列表用特定字符串拼接成String
• 1.1.forEach(v ->{ })
• 1.2.forEachOrdered(v ->{ })
• 2.1.map()
• 2.2.peek()
• 3.collect()
• 4.sorted()
• 5.filter()
• 6.limit()
• 7.count()
• 8.toArray()
• 9.max()\.min()
• 10.reduce()
• 11.distinct()
• 12..anyMatch()\.allMatch()\.noneMatch()
• 13.findFirst()
• 14.Collectors
• 1.1.get()
• 1.2.orElse()
• 2.isPresent()
• 参考文章

Java8 Lambda 使用案例总结

一、演示示例

1.遍历

List<Integer> integerList = new ArrayList<>();
integerList.add(1);
integerList.add(2);
integerList.add(3);
integerList.stream().forEach(integer -> {
	System.out.println(integer);  // 1,2,3
});
7

2.去重

List<Integer> integerList = new ArrayList<>();
integerList.add(1);
integerList.add(1);
integerList.add(3);
integerList = integerList.stream().distinct().collect(Collectors.toList());
integerList.stream().forEach(integer -> {
	System.out.println(integer);  // 1,3
});

3.获取对象中的某个参数为一个新的List

List<UserInfo> userInfos = new ArrayList<>();
userInfos.add(UserInfo.builder().uid("1").build());
userInfos.add(UserInfo.builder().uid("2").build());
userInfos.add(UserInfo.builder().uid("3").build());
List<String> uidList = userInfos.stream().map(UserInfo::getUid).collect(Collectors.toList());
uidList.stream().forEach(uid -> {
	System.out.println(uid);  // 1,2,3
});

4.获取对象中的某个参数为一个新的Map

List<UserInfo> userInfos = new ArrayList<>();
userInfos.add(UserInfo.builder().uid("1").build());
userInfos.add(UserInfo.builder().uid("2").build());
userInfos.add(UserInfo.builder().uid("3").build());
Map<String, String> uidMap = userInfos.stream().map(UserInfo::getUid).collect(Collectors.toMap(String::toString, String::toString));
uidMap.forEach((key, value) -> {
	System.out.println(key + ":" + value);
});
//1:1
//2:2
//3:3

5.过滤器

List<UserInfo> userInfos = new ArrayList<>();
userInfos.add(UserInfo.builder().uid("1").build());
userInfos.add(UserInfo.builder().uid("2").build());
userInfos.add(UserInfo.builder().uid("3").build());
List<UserInfo> userInfoList = userInfos.stream().
		// 过滤操作
		filter(userInfo -> userInfo.getUid().equals("1")).
		// 对象重组
		map(userInfo -> UserInfo.builder().uid(userInfo.getUid()).build()).
	    //收集结果
		collect(Collectors.toList());
// 1

6.排序

List<UserInfo> userInfos = new ArrayList<>();
userInfos.add(UserInfo.builder().uid("1").username("1").build());
userInfos.add(UserInfo.builder().uid("2").username("1").build());
userInfos.add(UserInfo.builder().uid("3").username("1").build());
userInfos.add(UserInfo.builder().uid("1").username("2").build());
userInfos.stream()
		// 排序(可设置第二排序规则.thenComparing())    reversed:翻转
		.sorted(Comparator.comparing(UserInfo::getUid).reversed())
		.collect(Collectors.toList())
		.forEach(userInfo -> {
			System.out.println(userInfo.getUid());  // 3,2,1,1
		});


userInfos.stream()
		  // 排序:先根据uid正向排序,再反排,相同uid再根据username正向排序
         .sorted(Comparator.comparing(UserInfo::getUid).reversed().thenComparing(UserInfo::getUsername))
		 .collect(Collectors.toList())
		 .forEach(userInfo -> {
		    System.out.println(userInfo.getUid()+"+"+userInfo.getUsername());
            // 3+1
			// 2+1
			// 1+1
			// 1+2
		 });

7.分组

Collectors`除了作为收集器使用(`Collectors.toList()` \ `Collectors.toSet()`)等。还可以用作数据分组，如`Collectors.groupingBy()
List<UserInfo> userInfos = new ArrayList<>();
userInfos.add(UserInfo.builder().uid("1").username("1").build());
userInfos.add(UserInfo.builder().uid("2").username("1").build());
userInfos.add(UserInfo.builder().uid("1").username("1").build());
userInfos.add(UserInfo.builder().uid("1").username("2").build());
// 单条件分组
Map<String, List<UserInfo>> collect = userInfos.stream().collect(Collectors.groupingBy(UserInfo::getUsername));
collect.forEach((key, value) -> {
	System.out.print(key);
	System.out.print("->");
	System.out.println(value.size());
});
// 多条件分组
Map<List<String>, List<UserInfo>> collect1 = userInfos.stream().collect(Collectors.groupingBy(v -> Arrays.asList(v.getUid(), v.getUsername()), Collectors.toList()));
collect1.forEach((key, value) -> {
	System.out.print(key);
	System.out.print("->");
	System.out.println(value.size());
});
19

8.以对象中的两个值，组成Map

List<UserInfo> userInfos = new ArrayList<>();
userInfos.add(UserInfo.builder().uid("1").username("n1").build());
userInfos.add(UserInfo.builder().uid("2").username("n1").build());
userInfos.add(UserInfo.builder().uid("1").username("n1").build());
userInfos.add(UserInfo.builder().uid("1").username("n2").build());

Map<String, String> collect = userInfos.stream()
  .collect(Collectors.toMap(UserInfo::getUid, UserInfo::getUsername));
// 输出Map为  (1,1)
9

这里有个坑

1.Key重复时

解决方法一，覆盖

当key重复时，该方法默认会抛出IllegalStateException：Duplicate key异常。 可以设置为重复Key时，覆盖。

Map<String, String> collect = userInfos.stream()
                .collect(Collectors.toMap(UserInfo::getUid, UserInfo::getUsername, (oldValue, newValue) -> newValue));
// 输出
// 1 -> n2
// 2 -> n1    

解决方法二，拼接

Map<String, String> collect = userInfos.stream()
                .collect(Collectors.toMap(UserInfo::getUid, UserInfo::getUsername, (oldValue, newValue) -> oldValue + "," + newValue));

collect.forEach((k, v) -> {
	System.out.println(k + " -> " + v);
});
// 输出
// 1 -> n1,n1,n2
// 2 -> n1     
9

2.Value为空

解决方法一

Map<String, Object> collect = userInfos.stream()
                .collect(Collectors.toMap(UserInfo::getUid, v -> Optional.ofNullable(v.getUsername())));
//输出
1 -> Optional.empty
2 -> Optional[n1]

解决方法二(该方法会自动覆盖)

Map<String, Object> collect = userInfos.stream()
                .collect(HashMap::new,
                        (n, v) -> n.put(v.getUid(), v.getUsername()), HashMap::putAll);
//输出
//1 -> null
//2 -> n1

9.将列表用特定字符串拼接成String

List<UserInfo> userInfos = new ArrayList<>();
userInfos.add(UserInfo.builder().uid("1").username("n1").build());
userInfos.add(UserInfo.builder().uid("2").username("n1").build());
userInfos.add(UserInfo.builder().uid("1").username("n1").build());
userInfos.add(UserInfo.builder().uid("1").username("n2").build());
String collect = userInfos.stream().map(UserInfo::getUsername).collect(Collectors.joining(","));
System.out.println(collect);
// n1,n1,n1,n2

二、方法总结

1.1.forEach(v ->{ })

遍历，的顺序不一定（并行流处理、效率更高）

1.2.forEachOrdered(v ->{ })

遍历，的顺序严格按照元素顺序（效率更低）

2.1.map()

可以看做是一个“处理器”，可以对list中的对象做一些操作，然后return任意类型，最后得到这个任意类型的list。 如，获取对象中的uid为一个list

List<UserInfo> userInfos = new ArrayList<>();
userInfos.add(UserInfo.builder().uid("1").build());
userInfos.add(UserInfo.builder().uid("2").build());
userInfos.add(UserInfo.builder().uid("3").build());
// 两种写法
List<String> uidList = userInfos.stream().map(UserInfo::getUid).collect(Collectors.toList());
List<String> uidList1 = userInfos.stream().map(userInfo -> {return userInfo.getUid();}).collect(Collectors.toList());
uidList.stream().forEach(uid -> {
	System.out.println(uid);  // 1,2,3
});
910

2.2.peek()

功能与.map()类似，不过，不会改变list的对象，一般作为中间操作或调式Lambda，查看当前list的属性使用。 如：

List<UserInfo> userInfos = new ArrayList<>();
userInfos.add(UserInfo.builder().uid("1").username("1").build());
userInfos.add(UserInfo.builder().uid("2").username("1").build());
userInfos.add(UserInfo.builder().uid("1").username("1").build());
userInfos.add(UserInfo.builder().uid("1").username("2").build());
userInfos.stream().peek(System.out::println).forEach(userInfo -> {
	System.out.println(userInfo.getUid());
});

// 输出结果：
UserInfo(uid=1, username=1)
1
UserInfo(uid=2, username=1)
2
UserInfo(uid=1, username=1)
1
UserInfo(uid=1, username=2)
1

可以看到，每个参数在执行forEach()中的方法前，都先执行了.peek()中的方法。 这样，既可以在.peek()中查看每个元素的动态，又可以在.peek()中做一些对象处理操作。 但是要注意，与.map()不同的是，.peek()不是链式调用的终结，不能单独使用。后面必须要跟收集器，遍历器等。 userInfos.stream().peek(System.out::println);这样是不会有输出的。

3.collect()

收集器，可将结果收集为List或Map，如:.collect(Collectors.toList())

4.sorted()

排序，可接受函数式参数.sorted(Comparator.comparing(UserInfo::getUid))

一般参数.sorted((v1, v2) -> {return v1.getUid().compareTo(v2.getUid());})

不做复杂处理的情况下，推荐使用第一种。

5.filter()

过滤器，接受一个布尔条件，如过滤uid为1的对象，.filter(userInfo -> userInfo.getUid().equals("1"))

6.limit()

接受一个Long类型，获取list中的前几项。如，获取前两项userInfos.stream().limit(2).collect(Collectors.toList())

7.count()

获取list的大小

8.toArray()

转化list为Object数组Object[] objects = userInfos.stream().toArray();

9.max()\.min()

根据条件获取最大值\最小值，接受参数与3.sorted()一致

如，获取uid最小的对象

UserInfo userInfo = userInfos.stream().min(Comparator.comparing(UserInfo::getUid)).get();

10.reduce()

根据给定算法计算，返回结果

如，计算一个1,2,3,4的合。

List<Integer> integerList = new ArrayList<>();
integerList.add(1);
integerList.add(2);
integerList.add(3);
integerList.add(4);
// 两种写法, 两种参数
Integer reduce1 = integerList.stream().reduce((v1, v2) -> v1 + v2);
// 这里传了两个参数，第一个参数是一个默认值，最后结果会加上这个值，可以不传
Integer reduce2 = integerList.stream().reduce(1, (v1, v2) -> v1 + v2);
Integer reduce3 = integerList.stream().reduce(1, Integer::sum);
System.out.println(reduce1); // 10
System.out.println(reduce2); // 11
System.out.println(reduce3); // 11

11.distinct()

去掉重复的对象

userInfos.stream().distinct().forEach(userInfo -> {
   System.out.println(userInfo.getUid() + "+" + userInfo.getUsername());
});
123

12..anyMatch()\.allMatch()\.noneMatch()

anyMatch表示，判断的条件里，任意一个元素成功，返回true

allMatch表示，判断条件里的元素，所有的都是，返回true

noneMatch跟allMatch相反，判断条件里的元素，所有的都不是，返回true

如，

List<Integer> strs = Arrays.asList(1, 2, 1, 4, 1);
boolean a = strs.stream().anyMatch(str -> str.equals(1));
boolean b = strs.stream().allMatch(str -> str.equals(2));
boolean c = strs.stream().noneMatch(str -> str.equals(3));
System.out.println(a);// true
System.out.println(b);// false
System.out.println(c);// true

13.findFirst()

获取当前list中的第一个对象，如

UserInfo userInfo = userInfos.stream().findFirst().get();
1

14.Collectors

Collectors`除了作为收集器使用(`Collectors.toList()` \ `Collectors.toSet()`)等。还可以用作数据分组，如`Collectors.groupingBy()
List<UserInfo> userInfos = new ArrayList<>();
userInfos.add(UserInfo.builder().uid("1").username("1").build());
userInfos.add(UserInfo.builder().uid("2").username("1").build());
userInfos.add(UserInfo.builder().uid("1").username("1").build());
userInfos.add(UserInfo.builder().uid("1").username("2").build());

Map<String, List<UserInfo>> collect = userInfos.stream().collect(Collectors.groupingBy(UserInfo::getUsername));
collect.forEach((key, value) -> {
	System.out.print(key);
	System.out.print("->");
	System.out.println(value.size());
});
Map<List<String>, List<UserInfo>> collect1 = userInfos.stream().collect(Collectors.groupingBy(v -> Arrays.asList(v.getUid(), v.getUsername()), Collectors.toList()));
collect1.forEach((key, value) -> {
	System.out.print(key);
	System.out.print("->");
	System.out.println(value.size());
});

三、单体操作

.findFirst()`取出的对象并不能直接使用，还需要使用单体操作，如:`.get()\.orElse()

1.1.get()

获取其中的元素

1.2.orElse()

与.get()类似，不过可以设置一个默认值，当对象为空时，返回默认值

如Stream.of("one", "two", "three", "four").findFirst().orElse("five");

2.isPresent()

返回布尔值，判断对象是否为空。

参考文章

• https://blog.csdn.net/litongzero/article/details/104060955