简记Java8 Lambda表达式的使用

package com.king.lambda;

import com.alibaba.fastjson.JSONObject;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import org.springframework.util.Assert;

import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @Description
 * @Author HHJ
 * @Date 2019-05-15 11:00
 */
@Data
@Builder
@Accessors(chain = true)
@NoArgsConstructor
@AllArgsConstructor
class EntityDTO {
    Integer id;
    Integer age;
    String name;
    BigDecimal weight;

    public EntityDTO(String name1) {
        name = name1;
    }
}

@Data
class AA{
Integer age;
}
public class LambdaTest {

     public static Integer test2(Function<Integer, Integer> s) {
        return s.apply(3);
    }

    public static Integer test3(Function<AA, Integer> s) {
        AA aa = new AA();
        return s.apply(aa);
    }

    public static void main(String[] args) {
        //Lambda最简单的写法
        Integer apply = test2((Integer a) -> {
            Integer i = a;
            return i;
        });
        Integer apply3 = test3((AA a) -> a.getAge());
        Integer apply4 = test3((a) -> a.getAge());
        Integer apply5 = test3(a -> a.getAge());

        System.out.println(apply);
        System.out.println(apply3);
        System.out.println(apply4);
        System.out.println(apply5);

        List<EntityDTO> dtoList = Arrays.asList(new EntityDTO("1"), new EntityDTO("3"), new EntityDTO("1"), new EntityDTO("4"));
        List<String> nameList = dtoList.stream().map(p -> p.getName()).collect(Collectors.toList());
        Assert.isTrue(nameList.size() == 4);
        //set 去重.
        Set<String> nameSet = dtoList.stream().map(p -> p.getName()).collect(Collectors.toSet());
        Assert.isTrue(nameSet.size() == 3);

        EntityDTO dto = new EntityDTO(1, 1, "king1", BigDecimal.valueOf(1));
        EntityDTO dto1 = new EntityDTO(2, 2, "king2", BigDecimal.valueOf(10));
        EntityDTO dto2 = new EntityDTO(3, 3, "king3", BigDecimal.valueOf(10));
        EntityDTO dto3 = new EntityDTO(20, 20, "king20", BigDecimal.valueOf(20));


        //此时顺序是乱的
        List<EntityDTO> dataList = Arrays.asList(dto, dto2, dto1, dto3);
        System.out.println("原始数据:" + dataList.toString());
        //filter 进行筛选
        List<EntityDTO> filterList = dataList
                .stream()
                .filter(p -> (p.getId() > 1))
                .collect(Collectors.toList());
        System.out.println("filter进行Id>1筛选出来的filterList:" + JSONObject.toJSONString(filterList.toString()));
        System.out.println();
        //filter 进行筛选出来的Map
        Map<Integer, EntityDTO> filterMap = dataList
                .stream()
                .filter(p -> (p.getWeight().compareTo(BigDecimal.valueOf(10)) == 0))
                .collect(Collectors.toMap(EntityDTO::getAge, m -> m, (key1, key2) -> key2));
        System.out.println("filter进行Weight=20筛选出来的filterMap:" + JSONObject.toJSONString(filterMap.toString()));
        //去重
        List<EntityDTO> distinctList = filterList
                .stream()
                .distinct()
                .collect(Collectors.toList());

        //返回前 n 个元素
        List<EntityDTO> limitList = filterList
                .stream()
                .limit(3)
                .collect(Collectors.toList());

        //去除前 n 个元素
        List<EntityDTO> skipList = filterList
                .stream()
                .skip(0)
                .collect(Collectors.toList());

        //是否存在一个 person 对象的 age 等于 20：
        boolean bool = skipList.stream().anyMatch(p -> p.getAge().equals(20));
        Assert.isTrue(bool);

        //获取其中一个属性的列表
        List<Integer> ageList = distinctList
                .stream()
                .map(p -> Integer.valueOf(p.getAge()))
                .collect(Collectors.toList());

        //总和
        int ageSum = ageList.stream().reduce(0, Integer::sum);
        Assert.isTrue(ageSum == 25);


        List<EntityDTO> dataList2 = Arrays.asList(dto2, dto1, dto3);
        BigDecimal totalWeight = dataList2.stream().map(EntityDTO::getWeight).reduce(BigDecimal.ZERO, BigDecimal::add);
        System.out.println("年龄分别:" + ageList.toString() + "---年龄总和:" + ageSum + "---体重总和:" + totalWeight.intValue());

        //对原集合进行操作
        //reduce 第一个参数 0 代表起始值为 new EntityDTO()，  (p1, p2) ->  a为上一个值,b 下一个新值
        EntityDTO reduceDTO = distinctList.stream()
                .reduce(new EntityDTO(), (p1, p2) -> {
                    if (p1.getId() == null) {
                        return p2;
                    }
                    if (p1.getId() < p2.getId()) {
                        return p2;
                    }
                    return p1;
                });
        System.out.println("Id最大的对象:" + reduceDTO.toString());

        //对原集合进行排序
        List<EntityDTO> sortedList = distinctList.stream()
                .sorted((p1, p2) -> (int) (p1.getId() - p2.getId()))
                .collect(Collectors.toList());
        System.out.println("================下面是原始数据排序后=====================");
        sortedList.stream().forEach(System.out::println);
        //进行升序
        List<EntityDTO> sortedAscList = distinctList.stream().sorted(Comparator.comparing(EntityDTO::getId)).collect(Collectors.toList());
        //进行降序
        List<EntityDTO> sortedReversedList = distinctList.stream().sorted(Comparator.comparing(EntityDTO::getId).reversed()).collect(Collectors.toList());

        List<EntityDTO> list = new ArrayList<>();
        list.add(EntityDTO.builder().id(2).age(2).name("2").build());
        list.add(EntityDTO.builder().id(1).age(1).name("1").build());
        list.add(EntityDTO.builder().id(6).age(6).name("6").build());
        list.add(EntityDTO.builder().id(21).age(21).name("21").build());
        list.add(EntityDTO.builder().id(55).age(55).name("55").build());
        list.add(EntityDTO.builder().id(3).age(3).name("3").build());
        System.out.println("================排序前:");
        list.forEach(System.out::println);

        //下列三种情况userId为空时.会null异常
        //Collections.sort(list, (e1, e2) -> e1.getUserId() - e2.getUserId());
        //Collections.sort(list, Comparator.comparingInt(DeviceTokenVo::getUserId));
        //Collections.sort(list, Comparator.comparingInt(DeviceTokenVo::getUserId).reversed());

        //解决上述null异常问题
        Collections.sort(list, (e1, e2) -> (e1.getId() != null ? e1.getId() : 0) - (e2.getId() != null ? e2.getId() : 0));
        System.out.println("================排序后:");
        list.forEach(System.out::println);

        //删除元素
        list.removeIf(p -> p.getId() == null);

        System.out.println("================删除元素后:");
        list.forEach(System.out::println);

        Collections.reverse(list);

        System.out.println("================collectTest=====================");

        collectTest(sortedList);
    }

    /**
     * 测试collect
     *
     * @param list
     */
    public static void collectTest(List<EntityDTO> list) {


        Set<String> setList = list.stream()
                .map(EntityDTO::getName)
                .collect(Collectors.toSet());
//转Map key重复时,后面的value覆盖前面的value
        Map<String, Integer> nameMap = list.stream()
                .collect(Collectors.toMap(EntityDTO::getName, EntityDTO::getId, (key1, key2) -> key2));

        Map<String, String> keyMap = list.stream()
                .collect(Collectors.toMap(p -> "这是键:" + p.getName(), value -> "这是值:" + value));

        for (Map.Entry<String, String> entry : keyMap.entrySet()) {
            System.out.println("key=" + entry.getKey() + ",value=" + entry.getValue());
        }
//分组
        Map<Boolean, List<EntityDTO>> groupingMap = list.stream()
                .collect(Collectors.groupingBy(p -> "king".equalsIgnoreCase(p.getName())));
        System.out.println("分组:" + groupingMap.toString());
//相同名字合并
        Map<String, Integer> saveDTOListMap = list.stream().collect(Collectors.groupingBy(
                EntityDTO::getName, Collectors.summingInt(EntityDTO::getAge)));
        System.out.println("相同名字分组并求和年龄:" + saveDTOListMap.toString());
//组装
        String joiningStr = list.stream()
                .map(p -> p.getName())
                .collect(Collectors.joining(",", "{", "}"));
        System.out.println("组装:" + joiningStr);

        System.out.println("--------------reducing-----------------------");
        List<String> intList = Stream.of("1", "2", "3").collect(
                Collectors.reducing(new ArrayList<String>(), x -> {
                    System.out.println("x=" + x);
                    return Arrays.asList(x + "king", "10086");
                }, (y, z) -> {

                    System.out.println(y.toString() + "---" + z.toString());
                    y.addAll(z);
                    return y;
                }));
        System.out.println("--------------打印-----------------------");
        System.out.println(intList.toString());
        System.out.println("--------------去重-----------------------");
        System.out.println(intList.stream().distinct().collect(Collectors.toList()));
    }
}