java-lambda-常用方法总结汇总
1、获取对象集合中的一个字段生成新的集合，【List<BeanA> 转 List<Long>，List<BeanA> 转 Set<Long>，List<BeanA> 转 String】
| //查询结果 List<MnsBusinessMessageVO> list = businessMessageMapper.list(query); //对象集合 转 Long集合 List<Long> userList = list.stream().map(head -> {return head.getCreateUserId();}).collect(Collectors.toList()); List<Long> teacherIdList = conflictData.stream().distinct().collect(Collectors.mapping(item -> item.getTeacherId(), Collectors.toList())); //对象集合 转 id,id,id,id字符串 String ids = list.stream().map(e->getCreateUserId()).collect(Collectors.joining(",")); String ids = param.getStudentIdList().stream().map(String::valueOf).collect(Collectors.joining(","))
//Long集合 转 Long数组 Long[] userIds = userList.toArray(new Long[userList.size()]); Long[] userIds = userList.stream().toArray(Long[]::new);
List<Long>result=Arrays.stream(str.split(",\\s*")).map(Long::parseLong)//将每个字符串转换成长整型 .collect(Collectors.toList());
|
|
| //对象集合 转 Long集合 List<Long> userList = list.stream().map(MnsBusinessMessageVO::getCreateUserId).collect(Collectors.toList()); //对象集合的多个字段合并成一个集合 List<Long> ids = modelList.stream().flatMap(item -> Stream.of(item.getCreateUserId(), item.getUpdateUserId())).filter(Objects::nonNull).distinct().collect(Collectors.toList());
//对象集合 转 Long集合 List<Long> userList = list.stream().map(e->getCreateUserId()).collect(Collectors.toList());
//对象集合 转 Long set集合 Set<Long> userSet = list.stream().map(MnsBusinessMessageVO::getCreateUserId).collect(Collectors.toSet());
|
2、获取对象集合中的（一个或者某个字段）生成新的对象集合 【List<BeanA> 转 List<BeanB>】
| //查询结果 List<MnsVO> list = businessMessageMapper.list(query); //List<MnsVO> 转 List<Mns> //Mns需要有多参构造函数 List<Mns> newObjList = list.stream().map(e -> new Mns(e.getId(),e.getBusinessName(),e.getBusinessCode())).collect(Collectors.toList());
|
3、toMap【List<obj> 转 map<Long,obj> 、map<Long,String> 】
| /** * List<obj> 转 map<Long,obj> * 使用Collectors.toMap的时候，如果有可以重复会报错，所以需要加(k1, k2) -> k1 * (k1, k2) -> k1 表示，如果有重复的key,则用新的 k1替换旧的 K2 * Function.identity()也可以写成user -> user */
Map<Long, User> maps = userList.stream().collect(Collectors.toMap(User::getId, Function.identity(), (key1, key2) -> key2)); //List<obj> 转map<Long,String> Map<Long, String> maps = userList.stream().collect(Collectors.toMap(User::getId, User::getAge, (key1, key2) -> key2)); |
4、对象集合深拷贝
| //深拷贝（对象地址不同） List<StartUpTimeIntervalVO> sourceList = new ArrayList<>(); List<StartUpTimeIntervalVO> copyList = sourceList.stream().map(e -> { StartUpTimeIntervalVO copy = new StartUpTimeIntervalVO(); BeanUtils.copyProperties(e, copy); return copy; }).collect(Collectors.toList()); |
5、skip()跟limit()实现分页
| List<EverydayStartupVO> resultList = allList.stream().skip(pageSize * (pageNum - 1)).limit(pageSize).collect(Collectors.toList()); |
6、groupingBy分组【List<Obj> 转 Map<Long,List<Obj>>】
//在Java8之前List<UserInfo> originUserInfoList = new ArrayList<>(); originUserInfoList.add(new UserInfo(1L, "吴半杯", 18,"深圳")); originUserInfoList.add(new UserInfo(3L, "吴半半", 26,"湛江")); originUserInfoList.add(new UserInfo(2L, "吴半桶", 27,"深圳")); Map<String, List<UserInfo>> result = new HashMap<>(); for (UserInfo userInfo : originUserInfoList) { String city = userInfo.getCity(); List<UserInfo> userInfos = result.get(city); if (userInfos == null) { userInfos = new ArrayList<>(); result.put(city, userInfos); } userInfos.add(userInfo); } |
| Map<Long, List<CalculateVO>> calculateMap = calculateList.stream().collect(Collectors.groupingBy(CalculateVO::getEquipmentId)); |
报错：java.lang.UnsupportedOperationException: null，calculateMap中的集合无法做add操作，变更为
| Map<Long, List<CalculateVO>> calculateMap = calculateList.stream() .collect(Collectors.groupingBy(CalculateVO::getEquipmentId,Collectors.toCollection(ArrayList::new)))); |
【Map<Long,List<Obj>> 转List<Obj> 】
| Map<Long, List<String>> listMap = new HashMap<>(); listMap.put(1L, Arrays.asList("a", "b", "c")); listMap.put(2L, Arrays.asList("d", "e", "f")); listMap.put(3L, Arrays.asList("g", "h", "i")); //转换 List<String> streamResult = listMap.values().stream().flatMap(Collection::stream).collect(Collectors.toList()); |
【Map<Long,Obj>转List<Obj>】
| List<SportsTypeStatisticalVO> itemList = itemMap.entrySet().stream() .map(entry -> entry.getValue()) .collect(Collectors.toList());
|
7、sorted+Comparator排序
| List<UserInfo> userInfoList = new ArrayList<>(); userInfoList.add(new UserInfo(1L, "吴半杯", 18)); userInfoList.add(new UserInfo(3L, "吴半", 26)); userInfoList.add(new UserInfo(2L, "吴", 27)); /** * sorted + Comparator.comparing 排序列表， */ //根据用户年龄升序排序 userInfoList = userInfoList.stream().sorted(Comparator.comparing(UserInfo::getAge)).collect(Collectors.toList()); //根据创建时间的毫秒值排序升序 userInfoList = userInfoList.stream().sorted(Comparator.comparing(s->s.getCreateTime().getTime())).collect(Collectors.toList())
userInfoList.forEach(a -> System.out.println(a.toString())); /** * 如果想降序排序，则可以使用加reversed() */ System.out.println("开始降序排序"); userInfoList = userInfoList.stream().sorted(Comparator.comparing(UserInfo::getAge).reversed()).collect(Collectors.toList()); userInfoList.forEach(a -> System.out.println(a.toString())); //运行结果 UserInfo{userId=1, userName='吴半杯', age=18} UserInfo{userId=3, userName='吴半', age=26} UserInfo{userId=2, userName='吴', age=27} 开始降序排序 UserInfo{userId=2, userName='吴', age=27} UserInfo{userId=3, userName='吴半', age=26} UserInfo{userId=1, userName='吴半杯', age=18} |
多个字段排序
年龄降序，班级降序
| //方法1：先对年龄进行升序，升序结果进行反转，再对班级进行降序 userList = userList.stream().sorted(Comparator.comparing(User::getAge).reversed().thenComparing(User::getClassNo, Comparator.reverseOrder())).collect(Collectors.toList()); //方法2：直接对年龄进行降序，再对班级进行降序 userList = userList.stream().sorted(Comparator.comparing(User::getAge, Comparator.reverseOrder()).thenComparing(User::getClassNo,Comparator.reverseOrder())).collect(Collectors.toList()); //方式3：先对年龄进行升序，再对班级进行升序，最后对结果进行反转 userList = userList.stream().sorted(Comparator.comparing(User::getAge).thenComparing(User::getClassNo).reversed()).collect(Collectors.toList()); |
年龄升序，班级降序
| //方法1：先对年龄进行升序，升序结果进行反转，再进行班级升序，结果进行反转(有点绕，年龄被排了三次升-降-升) userList = userList.stream().sorted(Comparator.comparing(User::getAge).reversed().thenComparing(User::getClassNo).reversed()).collect(Collectors.toList()); //方法2：直接对年龄进行升序，再对班级进行降序 userList = userList.stream().sorted(Comparator.comparing(User::getAge).thenComparing(User::getClassNo, Comparator.reverseOrder())).collect(Collectors.toList()); //单纯的反转排序 list=list.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList()); |
如果只进行单个字段的升序降序排列，我们使用reversed() 或者 Comparator.reverseOrder() 都可以
如果要进行多个字段的升序降序排列，我们还是使用 Comparator.reverseOrder() 会更优雅、更好理解一些
reversed()：是对排序结果进行反转
Comparator.reverseOrder()：是排序值的降序排序
8、distinct可以去除重复的元素:
| List<String> list = Arrays.asList("A", "B", "F", "A", "C"); List<String> temp = list.stream().distinct().collect(Collectors.toList()); |
9、findFirst 返回第一个元素（ifPresent判断类对象是否存在）
| List<String> list = Arrays.asList("A", "B", "F", "A", "C"); list.stream().findFirst().ifPresent(System.out::println); |
10、 anyMatch是否至少匹配一个元素
anyMatch 检查流是否包含至少一个满足给定谓词的元素。
| Stream<String> stream = Stream.of("A", "B", "C", "D"); boolean match = stream.anyMatch(s -> s.contains("C")); System.out.println(match); //输出 true |
11、allMatch 匹配所有元素
allMatch 检查流是否所有都满足给定谓词的元素。
| Stream<String> stream = Stream.of("A", "B", "C", "D"); boolean match = stream.allMatch(s -> s.contains("C")); System.out.println(match); //输出 false |
12、foreach 遍历list，遍历map
| /** * forEach 遍历集合List列表 */ List<String> userNameList = Arrays.asList("吴半杯", "吴半", "吴"); userNameList.forEach(item->{System.out.println(item);});
/** * forEach 遍历集合Map */ HashMap<String, String> hashMap = new HashMap<>(); hashMap.put("博客", "吴半杯"); hashMap.put("职业", "吴半"); hashMap.put("昵称", "捡瓶子的小男孩"); hashMap.forEach((k, v) -> System.out.println(k + ":\t" + v)); //运行结果 捡田螺的小男孩 程序员田螺 捡瓶子的小男孩 职业: 程序员田螺 公众号: 捡田螺的小男孩 昵称: 捡瓶子的小男孩 |
13、 Max，Min最大最小
使用lambda流求最大，最小值
| List<UserInfo> userInfoList = new ArrayList<>(); userInfoList.add(new UserInfo(1L, "吴半杯", 18)); userInfoList.add(new UserInfo(3L, "吴半", 26)); userInfoList.add(new UserInfo(2L, "吴", 27)); 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)); //运行结果 max age user:UserInfo{userId=2, userName='程序员田螺', age=27} min age user:UserInfo{userId=1, userName='捡田螺的小男孩', age=18} 一般count()表示获取流数据元素总数。 List<UserInfo> userInfoList = new ArrayList<>(); userInfoList.add(new UserInfo(1L, "吴半杯", 18)); userInfoList.add(new UserInfo(3L, "吴半", 26)); userInfoList.add(new UserInfo(2L, "吴", 27)); long count = userInfoList.stream().filter(user -> user.getAge() > 18).count(); System.out.println("大于18岁的用户:" + count); //输出 大于18岁的用户:2 |
14、map转换
map方法可以帮我们做元素转换，比如一个元素所有字母转化为大写，又或者把获取一个元素对象的某个属性，demo如下：
| List<String> list = Arrays.asList("jay", "tianluo"); //转化为大写 List<String> upperCaselist = list.stream().map(String::toUpperCase).collect(Collectors.toList()); upperCaselist.forEach(System.out::println); Reduce可以合并流的元素，并生成一个值 int sum = Stream.of(1, 2, 3, 4).reduce(0, (a, b) -> a + b); System.out.println(sum); //peek()方法是一个中间Stream操作，有时候我们可以使用peek来打印日志。 List<String> result = Stream.of("吴半杯", "吴半", "吴") .filter(a -> a.contains("吴")) .peek(a -> System.out.println("关注:" + a)).collect(Collectors.toList()); System.out.println(result); |
15、filter()过滤
从数组集合中，过滤掉不符合条件的元素，留下符合条件的元素。
| List<UserInfo> userInfoList = new ArrayList<>(); userInfoList.add(new UserInfo(1L, "吴半杯", 18)); userInfoList.add(new UserInfo(2L, "吴半", 27)); userInfoList.add(new UserInfo(3L, "吴", 26));
/** * filter 过滤，留下超过18岁的用户 */ List<UserInfo> userInfoResultList = userInfoList.stream().filter(user -> user.getAge() > 18).collect(Collectors.toList());
userInfoResultList.forEach(a -> System.out.println(a.getUserName()));
|