记录 lambda 使用 持续更新

groupingBy()

分组，可以使List<Bean> 根据bean中的一个或者多个字段分组返回Map<Object,List<Object>>类型
根据javaBean中的某个字段分组

@Data
class Mark{
	private String questionId;
	private String markContent;
	private String targetId;
}
//分组
Map<String, List<Mark>> markMap = 
						marks.stream().collect(
							Collectors.groupingBy(Mark::getQuestionId));

根据javaBean中的某个字段对另一字段进行分组

@Data
class Question{
	private Integer bigId;
	private Integer smallId;
}

//一个bigId可能对应多个smallId 对其进行分组 使k-v为bigId -> List<SmallId>

Map<Integer,List<Integer>> map = questions.stream().collect(
	Collectors.groupingBy(
		Question::getBigId,
		Collectors.mappings(Question::getSmallId,Collectiors.toList())
	)
);

Optional 使用

Optional是一个容器对象，可以包含也可以不包含非null值。Optional在Java 8中引入，目的是解决 NullPointerExceptions的问题。本质上，Optional是一个包装器类，其中包含对其他对象的引用。在这种情况下，对象只是指向内存位置的指针，并且也可以指向任何内容。从其它角度看，Optional提供一种类型级解决方案来表示可选值而不是空引用。
例：
有三个实体类层级关联

class Test {
    private Integer id;
    private Test02 test02;

    public Integer getId() {
        return id;
    }

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

    public Test02 getTest02() {
        return test02;
    }

    public void setTest02(Test02 test02) {
        this.test02 = test02;
    }
}

class Test02 {
    private Test03 test03;

    public Test03 getTest03() {
        return test03;
    }

    public void setTest03(Test03 test03) {
        this.test03 = test03;
    }
}

class Test03 {
    private Map<String, Double> map;

    public Map<String, Double> getMap() {
        return map;
    }

    public void setMap(Map<String, Double> map) {
        this.map = map;
    }
}

当要从Test类中获取Test03中的map的值时
常用做法：

Double number = test.getTest02().getTest03().getMap().get("number");

但是这样会有空指针异常，通常改进方法就是if嵌套去判断，但是，这嵌套多了之后会是代码非常的乱，所以，使用Optional对象改进代码

Double number1 = Optional.ofNullable(test)
                .map(Test::getTest02)
                .map(Test02::getTest03)
                .map(Test03::getMap)
                .map(m -> m.get("number"))
                .orElse(-1d);
System.out.println(number1);
//也可以对空指针异常进行处理
Double number1 = Optional.ofNullable(test)
                .map(Test::getTest02)
                .map(Test02::getTest03)
                .map(Test03::getMap)
                .map(m -> m.get("number"))
                .orElseGet(() ->{
                    System.out.println("空指针异常处理");
                    return -1d;
                });
//也可以自定义异常抛出
Double number1 = Optional.ofNullable(test)
                .map(Test::getTest02)
                .map(Test02::getTest03)
                .map(Test03::getMap)
                .map(m -> m.get("number"))
                .orElseThrow(() -> {
                    System.out.println("抛出空指针异常");

                    return new Exception("空指针异常");
                });