jdk8 lambda常用方法【循环-过滤-排序-拼接-转map-数据分块-数据分组-统计函数-字段赋值】

最新推荐文章于 2021-10-19 11:58:47 发布

kermit.liu

最新推荐文章于 2021-10-19 11:58:47 发布

阅读量3.8k

点赞数

分类专栏： Java基础文章标签： lambda Java

本文链接：https://blog.csdn.net/kermit_liu/article/details/90169952

版权

Java基础专栏收录该内容

6 篇文章 0 订阅

订阅专栏

package com.learn.stream.lambda;

import com.alibaba.fastjson.JSON;
import com.google.common.collect.Sets;
import com.learn.bean.CouponInfo;
import com.learn.utils.LambdaUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.junit.Before;
import org.junit.Test;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @author kermit.liu on 2018/10/11
 */
@Slf4j
public class LambdaTest {

    private List<CouponInfo> couponInfoList;

    private List<String> strList;

    private List<Integer> intList;

    @Before
    public void init() {
        CouponInfo couponInfo1 = new CouponInfo(123L, 10001, "5元现金券", 1);
        CouponInfo couponInfo2 = new CouponInfo(124L, 10001, "10元现金券",1);
        CouponInfo couponInfo3 = new CouponInfo(125L, 10002, "全场9折",2);
        CouponInfo couponInfo4 = new CouponInfo(126L, 10002, "全场8折", 2);
        CouponInfo couponInfo5 = new CouponInfo(127L, 10003, "全场7折", 2);

        couponInfoList = new ArrayList<>();
        couponInfoList.add(couponInfo1);
        couponInfoList.add(couponInfo2);
        couponInfoList.add(couponInfo3);
        couponInfoList.add(couponInfo4);
        couponInfoList.add(couponInfo5);

        couponInfoList = new ArrayList<>();
        couponInfoList.add(couponInfo1);
        couponInfoList.add(couponInfo2);
        couponInfoList.add(couponInfo3);
        couponInfoList.add(couponInfo4);
        couponInfoList.add(couponInfo5);

        strList = Arrays.asList(new String[]{"A", "S", "D", "F", "X", "C", "Y", "H", "", null});

        intList = Arrays.asList(new Integer[]{1, 2, 3, 4, 5, 6, 6, 2, 3});

    }

    /**
     * 迭代 forEach
     */
    @Test
    public void testForEach() {
        strList.stream().forEach(System.out::println);
        strList.stream().forEach(e -> System.out.print(e));
        System.out.println();
        strList.forEach(System.out::print);
    }

    /**
     * 过滤 filter
     */
    @Test
    public void testFilter() {
        List<String> list = strList.stream().filter(x -> StringUtils.isNotBlank(x)).collect(Collectors.toList());
        System.out.println(list);

        List<String> list1 = strList.stream().filter(StringUtils::isNotBlank).collect(Collectors.toList());
        System.out.println(list1);

        List<Integer> list2 = intList.stream().distinct().collect(Collectors.toList());
        System.out.println(list2);

        List<CouponInfo> list3 = couponInfoList.stream().filter(x -> x.getMerchantId() != 10001).collect(Collectors.toList());
        System.out.println(list3);

        List<CouponInfo> collect = couponInfoList.stream().filter(LambdaUtil.distinctByKey(CouponInfo::getCouponType)).collect(Collectors.toList());
        System.out.println(collect);
        List<Integer> collect1 = couponInfoList.stream().filter(LambdaUtil.distinctByKey(CouponInfo::getCouponType)).map(CouponInfo::getCouponType).collect(Collectors.toList());
        System.out.println(collect1);
        List<Integer> CouponList = couponInfoList.stream().map(CouponInfo::getCouponType).collect(Collectors.toList());
        System.out.println(CouponList);
        HashSet<Integer> set = Sets.newHashSet(CouponList);
        System.out.println(set);


    }

    /**
     * limit
     */
    @Test
    public void testLimit() {
        List<String> list = strList.stream().limit(3).collect(Collectors.toList());
        System.out.println(list);
    }

    /**
     * 排序  sorted
     */
    @Test
    public void testSorted() {
        List<Integer> list = intList.stream().sorted().collect(Collectors.toList());
        System.out.println(list);
        //  倒序
        List<Integer> list2 = intList.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
        System.out.println(list2);

        List<String> list3 = strList.stream().sorted(Comparator.nullsLast(Comparator.naturalOrder())).collect(Collectors.toList());
        List<String> list4 = strList.stream().sorted(Comparator.nullsLast(Comparator.reverseOrder())).collect(Collectors.toList());
        System.out.println(list3);
        System.out.println(list4);

        List<CouponInfo> list5 = couponInfoList.stream().sorted(Comparator.comparing(CouponInfo::getId)).collect(Collectors.toList());
        List<CouponInfo> list6 = couponInfoList.stream().sorted(Comparator.comparing(CouponInfo::getId).reversed()).collect(Collectors.toList());
        List<Long> list51 = list5.stream().map(e -> e.getId()).collect(Collectors.toList());
        List<Long> list61 = list6.stream().map(e -> e.getId()).collect(Collectors.toList());
        System.out.println(list51);
        System.out.println(list61);
    }

    /**
     * 拼接字符串 joining
     */
    @Test
    public void testJoining() {
        String collectStr = couponInfoList.stream().map(CouponInfo::getCouponName).collect(Collectors.joining(",", "[", "]"));
        System.out.println(collectStr.getClass().getName() + ":" + collectStr);
        List<String> collectList = couponInfoList.stream().map(CouponInfo::getCouponName).collect(Collectors.toList());
        System.out.println(collectList.getClass().getName() + ":" + collectList);
        System.out.println("StringUtils.join() : " + StringUtils.join(collectList, ","));
    }

    /**
     * map
     * 对每个元素进行处理，相当于MapReduce中的map阶段
     * Collectors.mapping()类似
     */
    @Test
    public void testMap() {
        List<Integer> list = intList.stream().map(e -> 2 * e).collect(Collectors.toList());
        System.out.println(list);
    }

    /**
     * 转成Map<K,V>
     * <p>
     * 特别注意，key不能重复，如果重复的话默认会报错，可以指定key重复的时候怎么处理
     * <p>
     * 例如：Map<String, Student> studentIdToStudent = students.stream().collect(toMap(Student::getId, Functions.identity());
     */
    @Test
    public void testToMap() {
        // 因为ID不重复，所以这里这么写没问题；但如果key换成CouponInfo::getMerchantId就有问题了
        // java.lang.IllegalStateException: Duplicate key
        Map<Long, CouponInfo> map = couponInfoList.stream().collect(Collectors.toMap(CouponInfo::getId, Function.identity()));

        //  这里重复的处理方式就是用后者覆盖前者
        Map<Integer, CouponInfo> map2 = couponInfoList.stream().collect(Collectors.toMap(CouponInfo::getMerchantId, Function.identity(), (c1, c2) -> c2));
        Map<Integer, CouponInfo> map3 = couponInfoList.stream().collect(Collectors.toMap(CouponInfo::getMerchantId, Function.identity(), (c1, c2) -> (c1.getId() > c2.getId() ? c2 : c1)));
        System.out.println(map);
        System.out.println(map2);
        System.out.println(map3);
    }

    /**
     * 数据分块 partitioningBy 分解成两个集合
     */
    @Test
    public void testPartitioningBy() {
        Map<Boolean, List<CouponInfo>> collectListMap = couponInfoList.stream().filter(couponInfo -> null != couponInfo.getCouponType()).collect(Collectors.partitioningBy(couponInfo -> couponInfo.getCouponType() == 1));
        System.out.println(collectListMap.get(true));
        System.out.println(collectListMap.get(false));
    }

    /**
     * 数据分组 groupingBy
     */
    @Test
    public void testGroupBy() {
        Map<Integer, List<CouponInfo>> map = couponInfoList.stream().collect(Collectors.groupingBy(CouponInfo::getMerchantId));
        // 组合收集器 <MerchantId, count>
        Map<Integer, Long> map2 = couponInfoList.stream().collect(Collectors.groupingBy(CouponInfo::getMerchantId, Collectors.counting()));
        // 组合收集器 <MerchantId, couponNameSet>
        Map<Integer, Set<String>> map3 = couponInfoList.stream().collect(Collectors.groupingBy(CouponInfo::getMerchantId, Collectors.mapping(CouponInfo::getCouponName, Collectors.toSet())));
        System.out.println(map);
        System.out.println(map2);
        System.out.println(map3);
    }

    /**
     * 数值统计 Max Min Average Sum
     */
    @Test
    public void testSum() {
        IntSummaryStatistics summaryStatistics = intList.stream().mapToInt(x -> x).summaryStatistics();
        System.out.println(summaryStatistics.getMax());
        System.out.println(summaryStatistics.getMin());
        System.out.println(summaryStatistics.getAverage());
        System.out.println(summaryStatistics.getSum());
    }

    /**
     * 给某个字段赋值
     */
    @Test
    public void testPeek() {
        List<CouponInfo> peelCouponInfoList = couponInfoList.stream().peek(couponInfo -> couponInfo.setCouponName("peekCoupon")).collect(Collectors.toList());
        log.info(JSON.toJSONString(peelCouponInfoList));
    }

}

工具类【LambdaUtil】

package com.learn.utils;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;

/**
 * @author kermit.liu on 2018/9/21
 */
public class LambdaUtil {

    /**
     * 配合lambda中的filter 根据对象中的某个属性去重
     *
     * @param keyExtractor 类名::getXXX
     * @param <T>          泛型
     * @return 对象
     */
    public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
        Map<Object, Boolean> concurrentHashMap = new ConcurrentHashMap<>(16);
        return t -> concurrentHashMap.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }
}