Java8 : Lambda

原创 已于 2023-05-05 00:37:42 修改 · 2.5k 阅读 · 7 ·
CC 4.0 BY-SA版权
文章发表1周内为内容优化高峰期，后续会根据认知迭代继续做完善补充。
文章标签：

#java

于 2020-02-18 20:44:21 首次发布
本文详细介绍Java中各种集合处理技巧，包括List、Map、Set的转换、排序、去重及Lambda表达式的高效应用。涵盖List转Map、Map排序、List排序、Lambda结合匿名内部类、类型转换、判空处理等内容。

文章目录

常用

```public static void main(String[] args) {
        String str = "123";
        str.length();
        System.out.println(str.length());

        List<Integer> l = Lists.newArrayList();
        l.add(3);
        l.add(1);
        l.add(2);
        l.size();
        System.out.println(l.size());

        String[] array = new String[2];
        String[] array2 = new String[]{"1","2"};
        System.out.println(array.length);

        System.out.println(str.substring(1,2));
        l=l.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
        System.out.println(l);
        l=l.stream().sorted().collect(Collectors.toList());
        System.out.println(l);

        HashMap<Integer,Integer> mao = new LinkedHashMap<>();
        mao.put(3,3);
        mao.put(1,1);
        mao.put(2,2);
        HashMap<Integer,Integer> mao2 = new LinkedHashMap<>();
        HashMap<Integer,Integer> mao3 = new LinkedHashMap<>();

        mao.entrySet().stream().sorted(Map.Entry.<Integer, Integer>comparingByKey().reversed())
                .forEachOrdered(e -> mao2.put(e.getKey(), e.getValue()));
        mao.entrySet().stream().sorted(Map.Entry.<Integer, Integer>comparingByKey())
                .forEachOrdered(e -> mao3.put(e.getKey(), e.getValue()));
        System.out.println(mao);
        System.out.println(mao2);
        System.out.println(mao3);

    }
#### 比较全的
[比较全的lambda](https://zhuanlan.zhihu.com/p/164348735)
#### 多个 List 合并
flatMap
```java
List<String[]> list = Lists.newArrayList();
        list.add(new String[]{"1","2","4"});
        list.add(new String[]{"4","5","6"});
        List r = ListUtils.emptyIfNull(list)
                .stream()
                .flatMap(Arrays::stream)
                .distinct()//去重
                .collect(Collectors.toList());
        System.out.println(JsonUtils.toJson(r));//["1","2","4","5","6"]
Map 转 List
List<Demo> results = Lists.newArrayList();
results.addAll(ListUtils.emptyIfNull(
                    MapUtils.emptyIfNull(tmp).entrySet()
                            .stream()
                            .filter(Objects::nonNull)
                            .map(item ->
                                    new Demo(String.valueOf(item.getKey())
                                            , String.valueOf(item.getValue())))
                            .collect(Collectors.toList()))
List 去重复
.distinct()
.collect(Collectors.toList());
join拼接为完整字符串

其它 lamada 用法

String str= List.stream().mapToInt(Strudent::getM).collect(Collectors.joining(";")
AtomicReference 和 foreach 结合
//重点是这一行
AtomicReference<StringBuilder> aaa = new AtomicReference<StringBuilder>();
        ListUtils.emptyIfNull(demoList)
                .stream()
                .forEach(item -> {
                    if (Objects.isNull(aaa.get())) {
                        aaa.set(new StringBuilder("111"));
                    } else {
                        aaa.get().append("、" + "222");
                    }
                   
                });
排序&连续排序
字符串转list
String str = "111,222,333";
List<Long> list =
                Arrays.stream(str.split(","))
                        .filter(StringUtils::isNotBlank)
                        .map(Long::valueOf)
                        .collect(Collectors.toList());
Map 排序、反转reversed、最大最小值

import lombok.experimental.UtilityClass;

import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;

/**
 * @Title: Map 排序加反转
 * @Description:
 * @Copyright: Copyright(c)2022
 * @Company: bestcxx
 * @Author: wujie
 * @Version: v1.0
 * @Date:2022-11-30
 * @Updatedby:
 */
@UtilityClass
public class MathMaxForMap {
    public static void main(String[] args) {
        Map<Integer,Integer> map1 = new HashMap();
        map1.put(1,2);
        map1.put(4,9);
        map1.put(2,4);
        map1.put(5,2);
        map1.put(3,1);
        //方式1 升序
        Map.Entry m1 = getByMinKey(map1);
        System.out.println(String.format("%s key:%d value:%d","getByMinKey",m1.getKey(),m1.getValue()));
        //方式2 升序
        Map.Entry m11 = getByMinKey2(map1);
        System.out.println(String.format("%s key:%d value:%d","getByMinKey2",m11.getKey(),m11.getValue()));
        //方式3 升序
        Map.Entry m111 = getByMinKey3(map1);
        System.out.println(String.format("%s key:%d value:%d","getByMinKey3",m111.getKey(),m111.getValue()));

        //其他方式参考 getMinKey
        Map.Entry m2 = getByMinValue(map1);
        System.out.println(String.format("%s key:%d value:%d","getByMinValue",m2.getKey(),m2.getValue()));

        //Map reversed 方式1 降序
        Map.Entry m3 = getByMaxKey(map1);
        System.out.println(String.format("%s key:%d value:%d","getByMaxKey",m3.getKey(),m3.getValue()));

        //Map reversed 方式2 降序
        Map.Entry m33 = getByMaxKey2(map1);
        System.out.println(String.format("%s key:%d value:%d","getByMaxKey2",m33.getKey(),m33.getValue()));

    }

    public Map.Entry getByMinKey(Map<Integer,Integer> map1){
        return map1.entrySet().stream()
                .sorted(Comparator.comparing(Map.Entry::getKey))
                .findFirst().orElse(null);
    }
    public Map.Entry getByMinKey2(Map<Integer,Integer> map1){
        return map1.entrySet().stream()
                .sorted(Map.Entry.comparingByKey(
                        Comparator.comparing(Integer::intValue))
                ).limit(1).findFirst().orElse(null);
    }
    public Map.Entry getByMinKey3(Map<Integer,Integer> map1){
        return map1.entrySet().stream()
                .sorted(Map.Entry.comparingByKey()
                ).findFirst().orElse(null);
    }
    public Map.Entry getByMaxKey(Map<Integer,Integer> map1){
        return map1.entrySet().stream()
                .sorted(Map.Entry.comparingByKey(Comparator.comparing(Integer::intValue).reversed())
                ).findFirst().orElse(null);
    }
    public Map.Entry getByMaxKey2(Map<Integer,Integer> map1){
        return map1.entrySet().stream()
                .sorted(Map.Entry.comparingByKey(Comparator.reverseOrder())
                ).findFirst().orElse(null);
    }

    public Map.Entry getByMinValue(Map<Integer,Integer> map1){
        return map1.entrySet().stream()
                .sorted(Comparator.comparing(Map.Entry::getValue))
                .findFirst().orElse(null);
    }

}
List 排序、反转reversed、最大最小值
import com.google.common.collect.Lists;

import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

import lombok.experimental.UtilityClass;
import org.apache.commons.collections4.ListUtils;

/**
 * @Title:List 排序加反转
 * @Description:
 * @Copyright: Copyright(c)2022
 * @Company: bestcxx
 * @Author: wujie
 * @Version: v1.0
 * @Date:2022-11-30
 * @Updatedby:
 */
@UtilityClass
public class MathMaxForList {
    public static void main(String[] args) {
        List<Integer> list1 = Lists.newArrayList(1,2,2,3,45,6,7,7,7);
        System.out.println(getMin(list1));
        System.out.println(getMax(list1));
        System.out.println(getMax2(list1));
        System.out.println(getMinByTopN(list1,3));
        System.out.println(getMinByTopDistinctN(list1,3));

    }
    public Integer getMin(List<Integer> list1){
        return ListUtils.emptyIfNull(list1)
                .stream()
                .sorted(Comparator.comparing(Integer::intValue)).findFirst().orElse(null);
    }
    public Integer getMax(List<Integer> list1){
        return ListUtils.emptyIfNull(list1)
                .stream()
                .sorted(Comparator.reverseOrder()).findFirst().orElse(null);
    }
    public Integer getMax2(List<Integer> list1){
        return ListUtils.emptyIfNull(list1)
                .stream()
                .sorted(Comparator.comparing(Integer::intValue).reversed())
        .findFirst().orElse(null);

    }

    public List<Integer> getMinByTopN(List<Integer> list1,long topN){
        return ListUtils.emptyIfNull(list1)
                .stream()
                .sorted(Comparator.comparing(Integer::intValue))
                .limit(topN).collect(Collectors.toList());
    }

    public List<Integer> getMinByTopDistinctN(List<Integer> list1,long topN){
        return ListUtils.emptyIfNull(list1)
                .stream()
                .sorted(Comparator.comparing(Integer::intValue))
                .distinct()
                .limit(topN).collect(Collectors.toList());
    }
}
排序后获取 前 N 个值
public List<Integer> getMinByTopN(List<Integer> list1,long topN){
        return ListUtils.emptyIfNull(list1)
                .stream()
                .sorted(Comparator.comparing(Integer::intValue))
                .limit(topN).collect(Collectors.toList());
    }
去重
public List<Integer> getMinByTopDistinctN(List<Integer> list1,long topN){
        return ListUtils.emptyIfNull(list1)
                .stream()
                .sorted(Comparator.comparing(Integer::intValue))
                .distinct()
                .limit(topN).collect(Collectors.toList());
    }
连续多组条件排序
list.stream().sorted(Comparator.comparing(Student::getTotalScore).thenComparing(Student::getMathScore).reversed());
常用方法整合
package com.bestcxx.study.demo.application;

import java.util.*;

import com.alibaba.fastjson.JSON;
import com.google.common.collect.Lists;
import org.apache.commons.collections4.ListUtils;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

/**
 * @Author: bestcxx
 * @Version: v1.0
 * @Updatedby:
 */
public class Del2 {

    /**
     * List< DemoUser> -> List< String>
     *
     * @param sourceList
     * @return
     */
    public static List<String> entityListToList(List<DemoEntity> sourceList) {
        return ListUtils.emptyIfNull(sourceList)
                .stream()
                .filter(Objects::nonNull)
                .filter(item -> Objects.nonNull(item.getName()))
                .map(DemoEntity::getName)
                .collect(Collectors.toList());
    }
    /**
     * List< DemoUser> -> List< String>
     *
     * @param sourceList
     * @return
     */
    public static List<String> entityListToListMapping(List<DemoEntity> sourceList) {
        return ListUtils.emptyIfNull(sourceList)
                .stream()
                .filter(Objects::nonNull)
                .filter(item -> Objects.nonNull(item.getName()))
                .collect(Collectors.mapping(DemoEntity::getName,Collectors.toList()));
        //功能和 .map 类似
    }

    /**
     * List< DemoUser> -> Set< String>
     *
     * @param sourceList
     * @return
     */
    public static Set<String> entityListToSet(List<DemoEntity> sourceList) {
        return ListUtils.emptyIfNull(sourceList)
                .stream()
                .filter(Objects::nonNull)
                .filter(item -> Objects.nonNull(item.getName()))
                .map(DemoEntity::getName)
                .collect(Collectors.toSet());
    }

    /**
     * List< DemoUser> -> Set< String>
     *
     * @param sourceList
     * @return
     */
    public static TreeSet<String> entityListToTreeSet(List<DemoEntity> sourceList) {
        return ListUtils.emptyIfNull(sourceList)
                .stream()
                .filter(Objects::nonNull)
                .filter(item -> Objects.nonNull(item.getName()))
                .map(DemoEntity::getName)
                .collect(Collectors.toCollection(TreeSet::new));
    }

    /**
     * List< DemoUser> -> Map< Long, DemoEntity>
     *
     * @param demoUserList
     * @return (k1, k2)-> k1 解决重复键的问题，这个参数可选,这里不考虑
     */
    public static Map<Long, DemoEntity> entityListToMapWithOutDuplicateKey(List<DemoEntity> demoUserList) {
        return ListUtils.emptyIfNull(demoUserList).stream()
                .filter(Objects::nonNull)
                .filter(item -> Objects.nonNull(item.getId()))
                .collect(Collectors.toMap(DemoEntity::getId, Function.identity()));
    }

    /**
     * List< DemoUser> -> Map< Long, DemoEntity>
     *
     * @param demoUserList
     * @return (k1, k2)-> k1 解决重复键的问题，这个参数可选
     */
    public static Map<Long, DemoEntity> entityListToMapWithDuplicateKey(List<DemoEntity> demoUserList) {
        return ListUtils.emptyIfNull(demoUserList).stream()
                .filter(Objects::nonNull)
                .filter(item -> Objects.nonNull(item.getId()))
                .collect(Collectors.toMap(DemoEntity::getId, Function.identity(), (k1, k2) -> k1));
    }

    /**
     * List< DemoUser> -> Map< Long, DemoEntity>
     *
     * @param demoUserList
     * @return BinaryOperator.maxBy(Comparator.comparing ( DemoEntity : : getGrade))) key 重复时，取getGrade最大的那个
     */
    public static Map<Long, DemoEntity> entityListToMaxGradeMapWithDuplicateKey(List<DemoEntity> demoUserList) {
        return ListUtils.emptyIfNull(demoUserList).stream()
                .filter(Objects::nonNull)
                .filter(item -> Objects.nonNull(item.getId()))
                .collect(Collectors.toMap(DemoEntity::getId, Function.identity(),
                        BinaryOperator.maxBy(Comparator.comparing(DemoEntity::getGrade))));
    }

    /**
     * List< DemoUser> -> Map< Long, String>
     *
     * @param demoUserList
     * @return (k1, k2)-> k1 解决重复键的问题，这个参数可选
     */
    public static Map<Long, String> entityListToStringMapWithDuplicateKey(List<DemoEntity> demoUserList) {
        return ListUtils.emptyIfNull(demoUserList).stream()
                .filter(Objects::nonNull)
                .filter(item -> Objects.nonNull(item.getId()))
                .collect(Collectors.toMap(DemoEntity::getId, DemoEntity::getName, (k1, k2) -> k1));
    }

    /**
     * 遍历输出 List< DemoEntity> Name
     *
     * @param demoUserList
     */
    public static void entityPrintName(List<DemoEntity> demoUserList) {
        ListUtils.emptyIfNull(demoUserList).stream()
                .filter(Objects::nonNull)
                .forEach(item -> System.out.println(item.getName()));
    }

    /**
     * List< DemoEntity> -> name1,name2,name3
     *
     * @param demoUserList
     * @return
     */
    public static String entityJoinedName(List<DemoEntity> demoUserList) {
        return ListUtils.emptyIfNull(demoUserList)
                .stream()
                .filter(Objects::nonNull)
                .map(DemoEntity::getName)
                .collect(Collectors.joining());
    }
    /**
     * List< DemoEntity> -> name1,name2,name3
     *
     * @param demoUserList
     * @return
     */
    public static String entityJoinedName2(List<DemoEntity> demoUserList) {
        return ListUtils.emptyIfNull(demoUserList)
                .stream()
                .filter(Objects::nonNull)
                .map(DemoEntity::getName)
                .collect(Collectors.joining());
    }
    /**
     * List< DemoEntity> -> name1,name2,name3
     *
     * @param demoUserList
     * @return
     */
    public static String entityJoinedName3(List<DemoEntity> demoUserList) {
        return ListUtils.emptyIfNull(demoUserList)
                .stream()
                .filter(Objects::nonNull)
                .map(DemoEntity::getName)
                .collect(Collectors.joining("-间隔-","左开始[","]右结束"));
    }

    /**
     * 求和
     *
     * @param demoUserList
     * @return Stream.of(0.3, 0.3, 0.4).mapToDouble(Double : : doubleValue).summaryStatistics().getAverage()
     */
    public static int entitySumAge(List<DemoEntity> demoUserList) {
        return ListUtils.emptyIfNull(demoUserList)
                .stream()
                .filter(Objects::nonNull)
                .collect(Collectors.summingInt(DemoEntity::getAge));
    }
//求和
 public static void main(String[] args) {
        List<Integer> list = Lists.newArrayList(1,2,3);
        System.out.println(list.stream().reduce((pre,after)->pre+after).get());

        List<String> list2 = Lists.newArrayList("1","2","3");
        System.out.println(list2.stream().mapToInt(Integer::valueOf).sum());

        int a = list.size();
        String[] array = new String[]{"1","2","3"};
        int b = array.length;

        String str = "aaa";
        int c = str.length();
    }

    /**
     * 求最大值
     *
     * @param demoUserList
     * @return Stream.of(0.3, 0.3, 0.4).mapToDouble(Double : : doubleValue).summaryStatistics().getAverage()
     */
    public static Long entityMaxAge(List<DemoEntity> demoUserList) {
        return ListUtils.emptyIfNull(demoUserList)
                .stream()
                .filter(Objects::nonNull)
                .collect(Collectors.summarizingLong(DemoEntity::getAge)).getMax();
    }

    /**
     * List< DemoEntity> -> Map< Integer, List< DemoEntity>>
     *
     * @param demoUserList
     * @return
     */
    public static Map<Integer, List<DemoEntity>> demoEntityGroupByGrade(List<DemoEntity> demoUserList) {
        return ListUtils.emptyIfNull(demoUserList)
                .stream()
                .filter(Objects::nonNull)
                .collect(Collectors.groupingBy(DemoEntity::getGrade, Collectors.toList()));
        // 此处等同于 .collect(Collectors.groupingBy(DemoEntity::getGrade));
    }
    /**
     * List< DemoEntity> -> Map< Integer, DemoEntity>
     *
     * @param demoUserList
     * @return
     * collectingAndThen 支持对获取到的 list 进行再次处理
     */
    public static Map<Long, DemoEntity> demoEntityMapGroupById(List<DemoEntity> demoUserList) {
        return ListUtils.emptyIfNull(demoUserList)
                .stream()
                .filter(Objects::nonNull)
                .collect(Collectors.groupingBy(DemoEntity::getId,
                        Collectors.collectingAndThen(Collectors.toList(),list->list.get(0))));
        // 根据id分类，然后每组取第一条,比对 List toMap:entityListToStringMapWithDuplicateKey
    }

    /**
     * List< DemoEntity> -> Map< Integer, List< DemoEntity>>
     *
     * @param demoUserList
     * @return
     */
    public static ConcurrentMap<Integer, List<DemoEntity>> demoEntityConcurrentMapGroupByGrade(List<DemoEntity> demoUserList) {
        return ListUtils.emptyIfNull(demoUserList)
                .stream()
                .filter(Objects::nonNull)
                .collect(Collectors.groupingByConcurrent(DemoEntity::getGrade, Collectors.toList()));
        // 此处等同于 .collect(Collectors.groupingBy(DemoEntity::getGrade));
    }

    /**
     * List< DemoEntity> -> Map< Integer, Set< DemoEntity>>
     *
     * @param demoUserList
     * @return
     */
    public static Map<Integer, Set<DemoEntity>> demoEntityToSetGroupByGrade(List<DemoEntity> demoUserList) {
        return ListUtils.emptyIfNull(demoUserList)
                .stream()
                .filter(Objects::nonNull)
                .collect(Collectors.groupingBy(DemoEntity::getGrade, Collectors.toSet()));
    }

    /**
     * List< DemoEntity> -> Map< Integer, Integer>
     *
     * @param demoUserList
     * @return
     */
    public static Map<Integer, Integer> ageSumGroupByGrade(List<DemoEntity> demoUserList) {
        return ListUtils.emptyIfNull(demoUserList)
                .stream()
                .filter(Objects::nonNull)
                .collect(Collectors.groupingBy(DemoEntity::getGrade, Collectors.summingInt(DemoEntity::getAge)));
    }

    /**
     * 根据判定条件分组 true/false 两组
     *
     * @param demoUserList
     * @return
     */
    public static Map<Boolean, List<DemoEntity>> demoEntityGroupByPassOrFail(List<DemoEntity> demoUserList) {

        return ListUtils.emptyIfNull(demoUserList)
                .stream()
                .filter(Objects::nonNull)
                .collect(Collectors.partitioningBy(item -> item.getGrade() > 1));
    }

    /**
     * 获取处理结果的总数
     *
     * @param demoUserList
     * @return 此时，也可以考虑 summaryStatistics()
     */
    public static Long getCountGrade(List<DemoEntity> demoUserList) {
        return ListUtils.emptyIfNull(demoUserList)
                .stream()
                .filter(Objects::nonNull)
                .filter(item -> item.grade > 1)
                .collect(Collectors.counting());
    }

    /**
     * 获取处理结果的总数
     *
     * @param demoUserList
     * @return 此时，也可以考虑 summaryStatistics()
     */
    public static Double getAverageAge(List<DemoEntity> demoUserList) {
        return ListUtils.emptyIfNull(demoUserList)
                .stream()
                .filter(Objects::nonNull)
                .filter(item -> item.grade > 1)
                .collect(Collectors.averagingLong(item -> (long) item.getAge()));
    }

    /**
     * List< DemoEntity> demoUserList -> MaxAge DemoEntity
     *
     * @param demoUserList
     * @return
     */
    public static Optional<DemoEntity> getMaxAgeEntity(List<DemoEntity> demoUserList) {
        return ListUtils.emptyIfNull(demoUserList)
                .stream()
                .filter(Objects::nonNull)
                .collect(Collectors.maxBy(Comparator.comparing(DemoEntity::getAge)));

    }

    /**
     * List< DemoEntity> demoUserList -> MinAge DemoEntity
     *
     * @param demoUserList
     * @return
     */
    public static Optional<DemoEntity> getMinAgeEntity(List<DemoEntity> demoUserList) {
        return ListUtils.emptyIfNull(demoUserList)
                .stream()
                .filter(Objects::nonNull)
                .collect(Collectors.minBy(Comparator.comparing(DemoEntity::getAge)));

    }

    /**
     * 求和
     * @param demoUserList
     */
    public static void testReducing(List<DemoEntity> demoUserList){
        System.out.println(demoUserList.stream().map(DemoEntity::getAge).collect(Collectors.reducing(Integer::sum)));
    }



    public static void main(String[] args) {

        DemoEntity d1 = new DemoEntity();
        d1.setAge(1);
        d1.setId(1L);
        d1.setName("name1");
        d1.setGrade(1);

        DemoEntity d2 = new DemoEntity();
        d2.setAge(2);
        d2.setId(2L);
        d2.setName("name2");
        d2.setGrade(1);

        DemoEntity d3 = new DemoEntity();
        d3.setAge(3);
        d3.setId(3L);
        d3.setName("name3");
        d3.setGrade(2);

        DemoEntity d4 = new DemoEntity();
        d4.setAge(4);
        d4.setId(3L);
        d4.setName("name4");
        d4.setGrade(4);


        List<DemoEntity> list = Lists.newArrayList(d1, d2, d3, d4);
        System.out.println(JSON.toJSONString(entityListToListMapping(list)));

    }

    public static DemoEntity getDemoEntity() {
        DemoEntity d1 = new DemoEntity();
        d1.setAge(1);
        d1.setId(1L);
        d1.setName("name1");
        d1.setGrade(1);
        return d1;
    }

    private static class DemoEntity {
        private Long id;
        private String name;
        private int age;
        private int grade;

        public Long getId() {
            return id;
        }

        public void setId(Long id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public int getGrade() {
            return grade;
        }

        public void setGrade(int grade) {
            this.grade = grade;
        }

        @Override
        public String toString() {
            return "DemoEntity{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    ", grade=" + grade +
                    '}';
        }
    }
}
final 修饰变量

lamada 表达式内部处理外部变量必须使用final修饰，jdk1.8会默认修饰，jdk1.7必须显示修饰。
原因是lamada表达式是通过匿名内部类通过构造函数传入变量的。

toMap Function.identity()返回自身
//Function.identity() 就会返回 User 实体
Map<Long, User> idMap = messageAccounts.stream().collect(Collectors.toMap(User::getId, Function.identity()));
forEach 的简单写法
public static void main(String[] args) {
        List list = Lists.newArrayList(1, 2, 3, 4);
        list.forEach(item -> {
            System.out.print(item + " ");
        });
        //当逻辑比较简单，可以采取简化写法
        list.forEach(item -> System.out.print(item + " "));
    }
forEach 以return 实现 continue,没有 break

forEach 以return 实现 continue,没有 break

List<Integer> list = Lists.newArrayList(1,2,3);
        List<Integer> list2 = Lists.newArrayList();
        list.forEach(item->{
            if(item==2){
                return;
            }
            list2.add(item);
        });
        System.out.println(JSON.toJSONString(list2));
        //输出 [1,3]
lamada 结合匿名内部类—— ()->{}

如果匿名内部类还需要传递参数，那么就()->{}写入入参 (a,b)->{} 或者 (a)->{}
在()作为实例化对象，{}里写接口方法的实现，所以此时需要对接口提出一些要求

/**
     * lamada 匿名内部类 用法
     */
    @Test
    public void test1(){
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("你好");
            }
        });
        thread.start();

        //lamada 使用()-> 取代匿名内部类声明
        Thread thread2 = new Thread(()-> { System.out.println("你好");});
        thread2.start();
    }

结果
// 你好
// 你好

lamada rudece 用法：对集合进行累加操作

reduce 可以用于 集合便利操作，比如求求和

/**
     *  lamada reduce 连续便利操作
     */
    @Test
    public void test2(){
        List<Integer> list = Arrays.asList(1,2,3,4);
        // reduce((A值,B值) -> 函数)
        int sum = list.stream().reduce((preValue,nextValue) -> preValue + nextValue).get();
        System.out.println("sum="+sum);
    }

结果

sum=10

我们可以结合 map ，获得更复杂的功能
将结合中实体的某一个属性进行集中处理

@Test
    public void test3(){
        List<User> list = Lists.newArrayList(new User(1),new User(2),new User(3),new User(4));
        int ageSum = list.stream().map(User::getAge).reduce((preAge,nextAge)->preAge+nextAge).get();
        System.out.println("他们的年龄和="+ageSum);
    }

结果输出：

他们的年龄和=10
Java 线程安全的时间函数 LocalDate

用法直接查看 时间工具类
https://blog.youkuaiyun.com/bestcxx/article/details/84635754

判空
CollectionUtils.isNotEmpty(元素) 包含null,size=0等多种情况

Optional.ofNullable(ADTO.getName()).orElse(null)
获取集合长度
CollectionUtils.size(list);
List 拆分方法

List对象 拆分为10个一组

 List<List<String>> partions = Lists.partition(List对象,10);
直接调用方法 类::方法

如果在本类，可直接用 this

 List list=Lists.newArrayList();
        list.forEach(item->类.方法1(item.getName));
        list.forEach(item->类.方法2(item));
        list.forEach(类::方法2);
类型转化 —— 其实就是调用方法 map(class::方法名)=map(item->item.方法名())

String::valueOf 表示 类.方法 ,自动将本对象放进去，用户类型转化或者 filter 中
比如本类则可以用 this::方法 进行过滤，方法要返回 true 或 false

List<String> itemReceiver=Lists.newArrayList();
//方法一：String转Integer 其实是在 map里调用 Integer.valueOf("")
itemReceiver.stream().map(Integer::valueOf).collect(Collectors.toList())
itemReceiver.stream().map(item->item.valueOf()).collect(Collectors.toList())
//方法二：String转Integer 其实是遍历调用 Integer.parseInt("")
Lists.transform(itemReceiver,Integer::parseInt)
//方法三 list 转 map
public Map<Long, String> getIdNameMap(List<Account> accounts) {
    return accounts.stream().collect(Collectors.toMap(Account::getId, Account::getUsername));
}
flatMap

合并多个List为一个List

@Test
    public void testk(){
        Map<Integer,List<Integer>> map  = Maps.newHashMap();
        map.put(1,Lists.newArrayList(1,2,3));
        map.put(2,Lists.newArrayList(4,5,6));
        map.put(3,Lists.newArrayList(7,8,9));
        List list = map.values().stream().flatMap(Collection::stream).collect(Collectors.toList());
        System.out.println(list);

    }
    //[1, 2, 3, 4, 5, 6, 7, 8, 9]
Map 和 filter 的应用场景的区别

Map 适用于所有对现有集合修改并保留所有值的场景

.stream().map(类::方法名)
.stream().map(item-> item.方法名())
.stream().map(item->{
	if(item.getA>2){
		item.setA(2);
	}
	return item;
})

filter 适用于仅保留一部分数据的场景

//如果处理Map<Long,List<String>>
List<Long> demoList = parentMap.values().stream().filter(item->{
            int size = item.size();
            item.retainAll(Lists.newArrayList(1L,2L,3L));
            return listSource.size() != size;
        }).flatMap(Collection::stream).collect(Collectors.toList());
类型转化的过程中增加 过滤
import com.alibaba.fastjson.JSON;
import com.google.common.collect.Maps;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Test {
    public static void main(String[] args) {

        Map<String,Long> map= Maps.newHashMap();
        map.put("a",1L);
        map.put("b",null);
        map.put("b",0L);

        List<String> list=map.values().stream().filter(item->(item!=null&&item>0)).map(String::valueOf).collect(Collectors.toList());
        System.out.println(JSON.toJSONString(list));
    }
}
String 转 set

“111,222,333” 转 [“111”,“222”,“333”]

import com.alibaba.fastjson.JSON;
import com.google.common.collect.Sets;

import java.util.Set;


public class Del {
    public static void main(String[] args) {
        String str="111,222,333";
        Set set = Sets.newHashSet(str.split(","));
        System.out.println(JSON.toJSONString(set));
    }
}
遍历、简单写法
Lists.newArrayList().forEach(item->{
     System.out.println(item);
 });
 Maps.newHashMap().forEach((k,v)->{
     System.out.println(k+":"+v);
 });
//集合
List<DemoDTO> demoDTOs = Lists.newArrayList(new DemoDTO(),new DemoDTO());
List<DemoDTO> filterDemoDTOS =  ListUtils.emptyIfNull(demoDTOs).stream()
                .filter(Objects::nonNull)
                .filter(item-> (1==1).collect(Collectors.toList());

public static void main(String[] args) {
        List list = Lists.newArrayList(1, 2, 3, 4);
        list.forEach(item -> {
            System.out.print(item + " ");
        });
        //当逻辑比较简单，可以采取简化写法
        list.forEach(item -> System.out.print(item + " "));
    }
List\Set 集合、判空
 @Test
    public void test2(){
        Integer a = 1;
        //true
        System.out.println(Objects.nonNull(a));
        //false
        System.out.println(Objects.isNull(a));
        
        //空的话就抛空指针
        //1
        System.out.println(Objects.requireNonNull(a,"不可为空"));

        List list = Collections.emptyList();
        //true
        System.out.println(CollectionUtils.isEmpty(list));
        

    }
Map 判空
MapUtils.isNotEmpty(Demomap);
//可以避免空指针
MapUtils.emptyIfNull(Demomap);
List、Set 和 Map 判空
package com.sankuai.mdp.wujie31.study;

import com.dianping.pigeon.util.CollectionUtils;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import org.apache.commons.collections.MapUtils;

import java.util.List;
import java.util.Map;
import java.util.Set;

public class Del3 {
    public static void main(String[] args) {
        List list = Lists.newArrayList();
        System.out.println(CollectionUtils.isEmpty(list));//true
        Set set = Sets.newHashSet();
        System.out.println(CollectionUtils.isEmpty(set));//true
        Map map = Maps.newHashMap();
        System.out.println(MapUtils.isEmpty(map));///true
    }
}

Map 的处理集合(List转Map,多个Map合并)

List转Map-List实体(看公用代码)
List转Map-List实体-结合groupBy分类本身(看公用代码)
List转Map-List实体-结合groupBy分类 Set(看公用代码)
List转Map-List实体-结合groupBy分类子属性(看公用代码)
合并多个Map(看公用代码)
合并俩Map(看公用代码)
(Map 公用代码)
import java.util.List;
import java.util.Set;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import lombok.experimental.UtilityClass;
import org.apache.commons.collections4.ListUtils;
import org.apache.commons.collections4.MapUtils;

import java.util.Map;
import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @Title:Map 相关工具类
 * @Description:比如 List<Entity> 转 Map；Map本身的过滤，多个Map合并为一个
 * @Copyright: Copyright(c)2022
 * @Company: bestcxx
 * @Author: wujie
 * @Date:2022-12-02
 * @Updatedby:
 */
@UtilityClass
public class DiyMapUtils {

    /**
     * List转Map-List实体
     *
     * @param list
     * @return
     */
    public Map<String, String> listToMap(List<Map.Entry<String, String>> list) {
        return ListUtils.emptyIfNull(list)
                .stream()
                .filter(Objects::nonNull)
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (x, y) -> x));
    }

    /**
     * List转Map-List实体-结合groupBy分类本身
     *
     * @param list
     * @return
     */
    public Map<String, List<Map.Entry<String, String>>> listToMapWithGroupIdentity(List<Map.Entry<String, String>> list) {
        return ListUtils.emptyIfNull(list)
                .stream()
                .filter(Objects::nonNull)
                .collect(Collectors.groupingBy(item -> item.getKey(), Collectors.mapping(Function.identity(), Collectors.toList())));
    }

    /**
     * List转Map-List实体-结合groupBy分类 Set
     *
     * @param list
     * @return
     */
    public Map<String, Set<Map.Entry<String, String>>> listToMapWithGroupSet(List<Map.Entry<String, String>> list) {
        return ListUtils.emptyIfNull(list)
                .stream()
                .filter(Objects::nonNull)
                .collect(Collectors.groupingBy(item -> item.getKey(),
                        Collectors.mapping(Function.identity(), Collectors.toSet())));
    }

    /**
     * List转Map-List实体-结合groupBy分类子属性
     *
     * @param list
     * @return
     */
    public Map<String, List<String>> listToMapWithGroupValue(List<Map.Entry<String, String>> list) {
        return ListUtils.emptyIfNull(list)
                .stream()
                .filter(Objects::nonNull)
                .collect(
                        Collectors.groupingBy(item -> item.getKey(), Collectors.mapping(item -> item.getValue()
                                , Collectors.toList())));
    }


    /**
     * 合并俩Map
     *
     * @param a
     * @param b
     * @return
     */
    public Map<String, String> mergeTwoMap(Map<String, String> a, Map<String, String> b) {
        return Stream.concat(MapUtils.emptyIfNull(a).entrySet().stream()
                , MapUtils.emptyIfNull(b).entrySet().stream())
                .filter(item->Objects.nonNull(item.getValue()))
                .collect(Collectors.toMap(
                                Map.Entry::getKey,
                                Map.Entry::getValue,
                                (v1, v2) -> v1));
    }

    /**
     * 合并多个Map
     *
     * @param list
     * @return
     */
    public Map<String, String> mergeListMapToMaps(List<Map<String, String>> list) {
        return ListUtils.emptyIfNull(list)
                .stream()
                .filter(Objects::nonNull)
                .flatMap(item -> item.entrySet().stream())
                .filter(item->Objects.nonNull(item.getValue()))
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (v1, v2) -> v1));
    }

    public static void main(String[] args) {
        Map<String, String> a = Maps.newHashMap();
        a.put("a1", null);
        a.put("a2", "a2");
        a.put(null, "a2");
        Map<String, String> b = Maps.newHashMap();
        b.put("a1", "b1");
        b.put("b2", "b2");
        b.put(null, "b2");
        Map<String, String> c = null;
        Map<String, String> d = Maps.newHashMap();
        System.out.println(mergeTwoMap(a, b));
        System.out.println(mergeListMapToMaps(Lists.newArrayList(a,b,c,d)));
    }
}

Collectors 用法

Collectors 的 24 种用法

List1 是否 完全包含 List2
@Test
    public void testl(){
        List<Integer> all = Lists.newArrayList(1,2,3,4,5);
        List<Integer> sub = Lists.newArrayList(1,2,3);
        boolean result = org.apache.commons.collections4.CollectionUtils.isSubCollection(sub,all);
        System.out.println(result);
    }
嵌套List的处理
  • 第一 List< DemoA> demoAList = Lists.newArrayList(null,null,null); demoAList 用CollectionUtils.isEmpty(demoAList) 判断为 null，所以我们不考虑这种特殊情况
private static class DemoA{
        private List<DemoB> demoBList;

        public List<DemoB> getDemoBList() {
            return demoBList;
        }

        public void setDemoBList(List<DemoB> demoBList) {
            this.demoBList = demoBList;
        }
    }

    private static class DemoB{

    }

    @Test
    public void testn() {
        //List<DemoA> demoAList = Lists.newArrayList(new DemoA(), new DemoA(), new DemoA());
        List<DemoA> demoAList = Lists.newArrayList(null,null,null);
        System.out.println(CollectionUtils.isEmpty(demoAList));
        DemoA demoA  = demoAList.stream().filter(Objects::nonNull).findFirst().orElse(null);
        if(Objects.nonNull(demoA)){
            System.out.println(demoA.getDemoBList());
        }
    }

BackUp

必备的maven依赖

<!-- ListUtils.emptyIfNull(集合) -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-collections4</artifactId>
			<version>4.4</version>
		</dependency>

		<!-- BooleanUtils.isTrue(null) -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.12.0</version>
		</dependency>

更多内容

其他

字符串

  • 非空，且是数字
if (StringUtils.isBlank(str) || !NumberUtils.isNumber(str)) {
                   return;
               }
java8：lambda级联表达式(Cascading)或柯里化(Currying)原理简化详解
ice-wee的专栏
07-29 957
lambda ：级联表达式（Cascading lambdas）或柯里化(Currying)。 柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数且返回结果的新函数的技术。这个技术由 Christopher Strachey 以逻辑学家 Haskell Curry 命名的，尽管它是 Moses Schnfinkel 和 Gottlob Frege 发明的。 举个简单的例子： Function<Integer, Predi.
Java 特性： Lambda 表达式(第 1 季)
06-09
Lambda 表达式是 java 8 的新特性，本质是一个函数式接口（ functional interface ）的实现类的实例，Lambda 表达式从匿名类发展而来。函数式接口只有一个抽象方法，为了实现这个抽象方法，我们要为之创建匿名实现类...
关于JAVA代码性能优化一点记录
dansam的专栏
07-02 826
写在前面 性能优化是一个包含很广有深度的知识，相对于自己浅显有限的经验实在有点难度。这里只是记录自己工作中一点常见的问题。 正文 性能说明：代码执行的通常主要瓶颈在第三方上（即其它的地方执行速度），例如磁盘IO 和 网络 IO，由于网络IO，取决于网络条件，更是有很大不确定性如延迟，所以通常如果优化代码速度，首要考虑的就是这一方面。 常见例子：在 循环里 里调用数据库查询或更改，这个是最常见的，因...
java8 泛型 null 报错_Java8 lambda表达式
weixin_42344395的博客
02-16 591
Java8 lambda表达式java8中最大的变化就是引入了lambda表达式，一种紧凑的传递行为的方式，这也是本书剩下部分所要讨论的内容，让我们进入其中吧。编写第一个lambda表达式swing是一个平台无关的gui库，在该库中，有很多常见的习惯，比如为了知道用户点点击了什么，注册一个事件监听器，这个事件监听器可以执行一些操作响应用户的输入。button.addActionListener(n...
java lambda表达式详解
qq_40751327的博客
05-08 4057
java lambda表达式详解 一、为什么要引入lambda表达式？ java是一门纯面向对象的语言，如果我们需要传递某个可以复用的代码块，我们必须将代码块逻辑抽离到对象中。比如在调用Arrays.sort实现数组排序时，如果有compare代码块逻辑，我们必须将其抽离到Comparator接口中，并传入Arrays.sort: class MyComparator implements Comparator<Integer>{ public int compare(Integer i1
hadoop使用中的几个小细节
千里之行,始于足下
02-13 3139
<br />最近在hadoop实际使用中有以下几个小细节分享: i=m5M]Ef  <br />1 中文问题 KKrLF?rc  <br />    从url中解析出中文,但hadoop中打印出来仍是乱码?我们曾经以为hadoop是不支持中文的，后来经过查看源代码，发现hadoop仅仅是不支持以gbk格式输出中文而己。<br />    这是TextOutputFormat.class中的代码，hadoop默认的输出都是继承自FileOutputFormat来的，FileOutputFormat的两
常用的 Lambda 表达式解析
laker的博客
07-08 591
常用的 Lambda 表达式解析 filter Filter 为过滤的意思，只要满足 Filter 表达式的数据就可以留下来，不满足的数据被过滤掉。 List<String> stringList = list.stream() .filter(s -> s.equals("faker")) // 只保留等于 faker的 .collect(Collectors.toList()); // 构造返回结果为 list // 结果为：faker map map 方法可以让我们
Lambda表达式：简介、语法和用法
沉淀所学，分享所思，让热爱与成长同行。商务记录AI实战经验，助力开发者快速成长。 热爱AI，希望做出有影响力的技术成果。 技术点亮生活，分享连接价值与机会。 专注AI落地实战，陪你走好技术每一步。
04-14 1万+
Lambda表达式是一种匿名函数，它主要用于表示简单的行为或代码块，并可以在需要时传递到其他函数中。Lambda表达式可以看作是一个函数式接口的实例，它由三个部分组成：参数列表、箭头符号和表达式体。");在这个示例中，Lambda表达式包含一个空参数列表，箭头符号"->"和一个输出"Hello, World!"的表达式体。它可以通过调用Lambda表达式的函数式接口来执行。
Java8：Lambda表达式增强版Comparator和排序
12-22
　在这篇教程里，我们将要去了解下即将到来的JDK 8（译注，现在JDK 8已经发布了）中的Lambda表达式——特别是怎样使用它来编写Comparator和对集合（Collection）进行排序。 　这篇文章是Baeldung上的“Java ——...
aws-lambda-java11:AWS Lambda中的Java 11与Java 8的比较
05-26
Java 8： ： Java 11： ： 功能变更 Java 11中有几种新的语言功能，其中某些功能可能对AWS Lambda用例有利。 尤其： 性能增强（尽管此处的测试没有明显差异） 新的Http库： : Java 9+的一个主要功能是模块...
探索Java 8的新世界：Lambda表达式全解析
最新发布
07-16
### Java 8 中 Lambda 表达式的全解析 #### 引言 Java 8 自发布以来，便成为了 Java 发展史上的一大里程碑。这次版本更新带来了众多重要的新特性，其中最引人注目的当属 Lambda 表达式。这一功能不仅为 Java ...
EF里使用lambda表达式时，如果数据为null情况下，读取字段会报错。（解决办法）
qq_37213281的博客
01-11 1529
使用lambda获取某个字段的值时，数据为null的情况会直接报错，在最后加上?.value 和?? 就可以解决了
java8使用lambda表达式过滤为null的值
qq_59125846的博客
09-07 1543
可选的东西真的是返回类型不做逻辑......但真的既不在这里也不在那里。在这个特殊的例子中，我认为将它放入一个过滤器并进行两次检查。我想基于使用Java 8的一些参数来过滤此列表。这将清除你的空对象。要完全回答手头的问题，请返回具有名称的汽车列表，并以。
ConcurrentModificationException: null ArrayList$ArrayListSpliterator.forEach
weixin_38689747的博客
09-09 1113
问题： 报错 ConcurrentModificationException: null ArrayList$ArrayListSpliterator.forEach Caused by: java.lang.NullPointerException: null at com.iptv.bigdata.cache.RegionListCache.lambda$null$4(RegionListCache.java:155) ~[classes/:na] at java.util.ArrayList$Ar
jdk8 lambda过滤集合中对象为空的数据
热门推荐
Zxdth的博客
08-12 1万+
Set<Long> ids = feeList.stream() .filter(s ->Objects.nonNull(s.getBill()))； 相关参考https://www.javaroad.cn/articles/2342
lamuda表达式 list移除空元素_java Map删除值为null的元素 lamada表达式一行代码就搞定...
weixin_39594457的博客
01-27 1699
由于map在使用foreach循环中删除元素的话会报空指针异常,只能采用迭代器的方式删除元素,写好代码后编译器竟然意外的提示我将代码改成lamada表达式,瞬间代码精简,idea牛逼!map.entrySet().removeIf(entry -> entry.getValue() == null);普通删除map空值Map params=new HashMap<>();para...
Lombok 表达式
woshigantiancheng的博客
07-25 1254
https://github.com/biezhi/learn-java8/tree/master/java8-lambda Lombok表达式源码: git clone git@github.com:biezhi/learn-java8.git ambda 表达式 命令式和函数式 命令式编程：命令“机器”如何去做事情(how)，这样不管你想要的是什么(what)，它都会按照你的命令实现。声明式编程：告诉“机器”你想要的是什么(what)，让机器想出如何去做(how)。 什么是函数式编程？ 每.
lambda表达式中奇怪的NullPointerException异常
samuBO的博客
12-02 3924
/** * 此时为空指针异常NPE，而不是NumberFormatException */ public class LamError { @Test public void test1() { A a1 = new A(); a1.setId(null); a1.setName(null); A a2 = new A(); a2.setId(2L); a2.setName("1"); .
Lambda的Optional处理null值
hw120219的博客
09-02 1446
探索Java 8：Lambda表达式与闭包实战
1. **Chapter 1: Java8: It’s a Whole New Java** - 这一章介绍了Java 8的整体变化，强调Lambda表达式如何改变了Java的编程范式，让Java开发者可以采用更加现代化的编程风格。 2. **Chapter 2: Understanding ...
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值