【Java8】常用lambda表达式

交集 并集 差集

交集（listA ∩ ListB）：
List<Person> listC = listA.stream().filter(item -> listB.contains(item)).collect(Collectors.toList());
listC中的元素有：属性name值为 aa, bb, cc 的对象。
 
并集（listA ∪ listB）:
//先合体
listA.addAll(listB);
//再去重
List<Person> listC = listA.stream().distinct().collect(Collectors.toList());
listC中的元素有：属性name值为 aa, bb, cc ,dd的对象。
 
差集（listA - listB）:
List<Person> listC = listA.stream().filter(item -> !listB.contains(item)).collect(Collectors.toList());
listC中的元素有：属性name值为 dd的对象。

List集合的过滤之lambda表达式

stmtList = stmtList.stream().filter(stmt -> !(stmt instanceof OracleInsertStatement) && stmt.getParent() == null).collect(Collectors.toList());

lambda表达式将List对象某个字段转换以逗号分隔的String类型

// 获取 users 集合中的 id 集合
List<Long> ids = users.stream().map(User::getId).collect(Collectors.toList());
System.out.println("ids: " + ids);
System.out.println();

// 获取 users 集合中的 id 集合并转为字符串, 通过 , 拼接p
String idsTxt = users.stream().map(User::getId).map(String::valueOf).collect(Collectors.joining(","));
System.out.println("idsTxt: " + idsTxt);
System.out.println();

List<String> names = users.stream().map(User::getName).collect(Collectors.toList());
System.out.println("names: " + names);

分组功能

Collection<List<CheckTaskAndCompanyBindEntity>> collect2 = checkTaskAndCompanyBindByList.stream().
filter(s -> s.getTaskType() == 2).collect(Collectors.groupingBy(CheckTaskAndCompanyBindEntity::getCompanyId)).values();

排序功能

//升序 123
List.sort(Comparator.comparing(CheckBjwaInputResp::getCheckNum));
//降序 321
List.sort(Comparator.comparing(CheckBjwaInputResp::getCheckNum).reversed());

Map相关操作

// 获取map第一个元素
Optional<Object> first = map.values().stream().findFirst();
String s = first.get().toString();

// 循环map
cloumMap.forEach((k, v) -> {
    System.out.println("k:" + k + ",v:" + v);
});

filter 过滤

/**
 * filter 过滤，留下超过20岁的用户
 */
List<UserInfo> userInfoResultList = userInfoList.stream().filter(user -> user.getAge() > 20).collect(Collectors.toList());
userInfoResultList.forEach(a -> System.out.println(a.getUserName()));

forEach 遍历

List.forEach(System.out::println);

Map.forEach((k, v) -> System.out.println(k + ":\t" + v));

groupingBy分组

Map<String, List<UserInfo>> result = originUserInfoList.stream()
.collect(Collectors.groupingBy(UserInfo::getCity));

sorted+Comparator排序

/**
 *  sorted + Comparator.comparing 排序列表，
 */
userInfoList = userInfoList.stream().sorted(Comparator.comparing(UserInfo::getAge)).collect(Collectors.toList());
userInfoList.forEach(a -> System.out.println(a.toString()));

System.out.println("开始降序排序");

/**
 * 如果想降序排序，则可以使用加reversed()
 */
userInfoList = userInfoList.stream().sorted(Comparator.comparing(UserInfo::getAge).reversed()).collect(Collectors.toList());
userInfoList.forEach(a -> System.out.println(a.toString()));

distinct去除重复的元素

List<String> list = Arrays.asList("A", "B", "F", "A", "C");
List<String> temp = list.stream().distinct().collect(Collectors.toList());
temp.forEach(System.out::println);

map 转换

List<String> list = Arrays.asList("jay", "tianluo");
//转化为大写
List<String> upperCaselist = list.stream().map(String::toUpperCase).collect(Collectors.toList());
upperCaselist.forEach(System.out::println);

Max，Min 最大最小

Optional<UserInfo> maxAgeUserInfoOpt = userInfoList.stream().max(Comparator.comparing(UserInfo::getAge));
maxAgeUserInfoOpt.ifPresent(userInfo -> System.out.println("max age user:" + userInfo));

Optional<UserInfo> minAgeUserInfoOpt = userInfoList.stream().min(Comparator.comparing(UserInfo::getAge));
minAgeUserInfoOpt.ifPresent(userInfo -> System.out.println("min age user:" + userInfo));

count 统计

 long count = userInfoList.stream().filter(user -> user.getAge() > 18).count();
System.out.println("大于20岁的用户:" + count);