Stream分組

一、Stream分組求和

/**
 * 求和
 */
public void sum(){
    List dataList = getDataList();
    Map<String, Double> map = dataList.stream().collect(Collectors.groupingBy(Data::getType, Collectors.summingDouble(Data::getValue)));
}

Stream分組求和可以用來對List進行分組後求和操作，例如對於以下數據：

List<Data> dataList = Arrays.asList(
        new Data("A", 1),
        new Data("B", 2),
        new Data("A", 3),
        new Data("B", 4),
        new Data("C", 5)
);

按照Data對象的type屬性進行分組，再對value屬性求和，可以得到如下結果：

Map<String, Double> result = {
    "A": 4.0,
    "B": 6.0,
    "C": 5.0
}

二、Stream分組前十

/**
 * 分組前十
 */
public void top(){
    List dataList = getDataList();
    Map<String, List<Data>> groups = dataList.stream().collect(Collectors.groupingBy(Data::getType));
    Map<String, List<Data>> result = new HashMap<>();
    groups.forEach((k, v) -> {
        List<Data> top = v.stream()
            .sorted(Comparator.comparing(Data::getValue).reversed())
            .limit(10)
            .collect(Collectors.toList());
        result.put(k, top);
    });
}

Stream分組前十可以用來對List進行分組後取出每組的前十個數據，例如對於以下數據：

List<Data> dataList = Arrays.asList(
        new Data("A", 1),
        new Data("B", 2),
        new Data("A", 3),
        new Data("B", 4),
        new Data("C", 5)
);

按照Data對象的type屬性進行分組，再對value屬性進行降序排序，取出前十個數據，可以得到如下結果：

Map<String, List<Data>> result = {
    "A": [{type: "A", value: 3}, {type: "A", value: 1}],
    "B": [{type: "B", value: 4}, {type: "B", value: 2}],
    "C": [{type: "C", value: 5}]
}

三、Stream分組拼接

/**
 * 字元串拼接
 */
public void join(){
    List<Data> dataList = getDataList();
    Map<String, String> result = dataList.stream().collect(Collectors.groupingBy(Data::getType, Collectors.mapping(Data::getName, Collectors.joining(","))));
}

Stream分組拼接可以用來對List進行分組後將某個屬性值拼接成一個字元串，例如對於以下數據：

List<Data> dataList = Arrays.asList(
        new Data("A", 1, "A1"),
        new Data("B", 2, "B1"),
        new Data("A", 3, "A2"),
        new Data("B", 4, "B2"),
        new Data("C", 5, "C1")
);

按照Data對象的type屬性進行分組，再對name屬性進行拼接，可以得到如下結果：

Map<String, String> result = {
    "A": "A1,A2",
    "B": "B1,B2",
    "C": "C1"
}

四、Map轉List Stream

/**
 * Map轉List
 */
public void mapToList(){
    Map<String, List<Data>> map = getMap();
    List<Data> result = map.entrySet()
        .stream()
        .flatMap(entry -> entry.getValue().stream().peek(data -> data.setType(entry.getKey())))
        .collect(Collectors.toList());
}

Map轉List Stream可以用來將Map轉換為List，同時給List添加一些額外的屬性，例如對於以下數據：

Map<String, List<Data>> map = {
    "A": [{value: 1}, {value: 2}],
    "B": [{value: 3}, {value: 4}]
}

將Map轉換為List，並且在List中添加type屬性，可以得到如下結果：

List<Data> result = [{type: "A", value: 1}, {type: "A", value: 2}, {type: "B", value: 3}, {type: "B", value: 4}]

五、Stream分組List

/**
 * 分組List
 */
public void groupList(){
    List<Data> dataList = getDataList();
    Map<String, List<Data>> result = dataList.stream().collect(Collectors.groupingBy(Data::getType));
}

Stream分組List可以用來對List進行分組操作，例如對於以下數據：

List<Data> dataList = Arrays.asList(
        new Data("A", 1),
        new Data("B", 2),
        new Data("A", 3),
        new Data("B", 4),
        new Data("C", 5)
);

按照Data對象的type屬性進行分組，可以得到如下結果：

Map<String, List<Data>> result = {
    "A": [{type: "A", value: 1}, {type: "A", value: 3}],
    "B": [{type: "B", value: 2}, {type: "B", value: 4}],
    "C": [{type: "C", value: 5}]
}

六、Stream分組並排序

/**
 * 分組排序
 */
public void sort(){
    List<Data> dataList = getDataList();
    Map<String, List<Data>> result = dataList.stream()
        .collect(Collectors.groupingBy(Data::getType, Collectors.collectingAndThen(Collectors.toList(), list -> {
            list.sort(Comparator.comparingDouble(Data::getValue));
            return list;
        })));
}

Stream分組並排序可以用來對List進行分組後再按照某個屬性進行排序，例如對於以下數據：

List<Data> dataList = Arrays.asList(
        new Data("A", 1),
        new Data("B", 2),
        new Data("A", 3),
        new Data("B", 4),
        new Data("C", 5)
);

按照Data對象的type屬性進行分組，再按照value屬性進行升序排序，可以得到如下結果：

Map<String, List<Data>> result = {
    "A": [{type: "A", value: 1}, {type: "A", value: 3}],
    "B": [{type: "B", value: 2}, {type: "B", value: 4}],
    "C": [{type: "C", value: 5}]
}

七、Stream分組計數

/**
 * 統計數量
 */
public void count(){
    List<Data> dataList = getDataList();
    Map<String, Long> result = dataList.stream().collect(Collectors.groupingBy(Data::getType, Collectors.counting()));
}

Stream分組計數可以用來對List進行分組後統計每組數量，例如對於以下數據：

List<Data> dataList = Arrays.asList(
        new Data("A", 1),
        new Data("B", 2),
        new Data("A", 3),
        new Data("B", 4),
        new Data("C", 5)
);

按照Data對象的type屬性進行分組，統計每組數據的數量，可以得到如下結果：

Map<String, Long> result = {
    "A": 2,
    "B": 2,
    "C": 1
}

八、Stream分組統計數量

/**
 * 統計數量
 */
public void count(){
    List<Data> dataList = getDataList();
    Map<String, Integer> result = dataList.stream()
        .collect(Collectors.groupingBy(Data::getType, Collectors.summingInt(Data::getValue)));
}

Stream分組統計數量可以用來對List進行分組後統計每組數據的數量並且可以針對每個數量屬性進行求和，例如對於以下數據：

List<Data> dataList = Arrays.asList(
        new Data("A", 1),
        new Data("B", 2),
        new Data("A", 3),
        new Data("B", 4),
        new Data("C", 5)
);

按照Data對象的type屬性進行分組，統計每組數據的數量並且對value屬性求和，可以得到如下結果：

Map<String, Integer> result = {
    "A": 4,
    "B": 6,
    "C": 5
}

九、Stream分組求和BigDecimal

/**
 * BigDecimal求和
 */
public void bigDecimalSumming(){
    List<Data> dataList = getDataList();
    Map<String, BigDecimal> result = dataList.stream()
            .collect(Collectors.groupingBy(Data::getType, Collectors.mapping(Data::getValue, Collectors.reducing(BigDecimal.ZERO, BigDecimal::add))));
}

Stream分組求和BigDecimal可以用來對List進行分組後對某個BigDecimal屬性進行求和，例如對於以下數據：

List<Data> dataList = Arrays.asList(
        new Data("A", new BigDecimal(1)),
        new Data("B", new BigDecimal(2)),
        new Data("A", new BigDecimal(3)),
        new Data("B", new BigDecimal(4)),
        new Data("C", new BigDecimal(5))
);

按照Data對象的type屬性進行分組，再對value屬性進行BigDecimal求和，可以得到如下結果：

Map<String, BigDecimal> result = {
    "A": new BigDecimal(4),
    "B": new BigDecimal(6),
    "C": new BigDecimal(5)
}

十、Stream分組後對List處理選取

/**
 * 分組取值
 */
public void groupSample(){
    List<Data> dataList = getDataList();
    int size = 2;
    Map<String, List<String>> result = dataList.stream().collect(Collectors.groupingBy(Data::getType, Collectors.collectingAndThen(Collectors.toList(), list -> {
        Collections.shuffle(list);
        return list.stream().limit(size).map(Data::getName).collect(Collectors.toList());
    })));
}

Stream分組後對List處理選取可以用來對List進行分組後從每組中隨機選取一些數據，例如對於以下數據：

List<Data> dataList = Arrays.asList(
        new Data("A", 1, "A1"),
        new Data("B", 2, "B1"),
        new Data("A", 3, "A2"),
        new Data("B", 4, "B2"),
        new Data("C", 5)
);

按照Data對象的type屬性進行分組，再對List進行隨機排序後選取前2個，可以得到如下結果：

Map<String, List<String>> result = {
    "A": ["A2", "A1"],
    "B": ["B2", "B1"],
    "C": ["C1"]
}