如何在Java 8中迭代列表并将其中的值分组

Question

我需要一些帮助，在一个月内找到低费用和高费用。我有一个费用列表，其中费用类别具有以下值。您能否指导我如何对它们进行分组以获得Java-8中的预期输出？提前谢谢你的帮助。

Expenses
type:Grocercies
kind:fruits
value:20
date:09/15/2020

Expenses
type:Grocercies
kind:vegetables
value:20
date:09/01/2020

Expenses
type:Grocercies
kind:fruits,pulses
value:10
date:09/25/2020

Expenses
type:Grocercies
kind:fruits,milk
value:18
date:09/23/2020

Expenses
type:Grocercies
kind:vegetables,pulses
value:15
date:09/10/2020

Combined Rates
Fruits,Pulses : 30
Vegetables,pulses : 35
Fruits,milk : 38

预期产出

Low expense : Fruits,Pulses 
High Expense : Fruits,milk

我尝试按类型（杂货）进行分组，即Map




Answer 1

我尝试了以下方法。我不确定这是一个有效的方法。有没有其他方法可以实现它？

public static void main（String[]args）{List expenses=prepareBastostA（）；Map

private static List<ExpenseOutput> calculateValue(Map<String, List<Expenses>> expensesOfAllKinds,
        Entry<String, List<Expenses>> expenseOfAKind) {
    List<Expenses> expenseOfAKindOfGrocery = expenseOfAKind.getValue();
    List<Expenses> expensesOfOtherKinds = expensesOfAllKinds.entrySet().stream()
            .filter(expenseOfDifferentKind -> !expenseOfDifferentKind.equals(expenseOfAKind))
            .map(expenseOfDifferentKind -> expenseOfDifferentKind.getValue())
            .flatMap(expenseOfDifferentKind -> expenseOfDifferentKind.stream()).collect(Collectors.toList());
    return expenseOfAKindOfGrocery.stream()
            .map(oneKindOfExpense -> mapAppropriateKindAndAddValue(oneKindOfExpense, expensesOfOtherKinds))
            .flatMap(x -> x.stream()).collect(Collectors.toList());
}

private static List<ExpenseOutput> mapAppropriateKindAndAddValue(Expenses expenseOfAKind,
        List<Expenses> expensesOfOtherKinds) {
    return expensesOfOtherKinds.stream()
            .filter(expenseOfOtherKind -> checkWhetherTheyHaveSameKind(expenseOfOtherKind, expenseOfAKind))
            .map(expenseOfOtherKind -> addValueIfSameKindExists(expenseOfOtherKind, expenseOfAKind))
            .collect(Collectors.toList());
}

private static boolean checkWhetherTheyHaveSameKind(Expenses expenseOfOtherKind, Expenses expenseOfAKind) {
    List<String> expenseOfAKindList = Arrays.asList(expenseOfAKind.getKind().split(","));
    List<String> expenseOfOtherKindList = Arrays.asList(expenseOfOtherKind.getKind().split(","));
    return expenseOfOtherKindList.stream().allMatch(expense -> expenseOfAKindList.contains(expense));
}

private static ExpenseOutput addValueIfSameKindExists(Expenses expenseOfOtherKind, Expenses expenseOfAKind) {
    ExpenseOutput output = new ExpenseOutput();
    output.setValue(expenseOfOtherKind.getValue() + expenseOfAKind.getValue());
    List<String> expenseOfAKindList = new ArrayList<>(Arrays.asList(expenseOfAKind.getKind().split(",")));
    List<String> expenseOfOtherKindList = new ArrayList<>(Arrays.asList(expenseOfOtherKind.getKind().split(",")));
    expenseOfOtherKindList.addAll(expenseOfAKindList);
    Set<String> finalKind = expenseOfOtherKindList.stream().collect(Collectors.toSet());
    output.setKind(String.join(",", finalKind));
    return output;
}