java - 如何在 Java 8 Stream API 中编写此循环

Question

我对 Java 8 还很陌生，想要重写一些代码。

有什么想法可以把这个写得更漂亮吗？

这个想法是，一个人有许多单位。一个单元有很多要求。我们想要收集每个单位的所有需求，并将它们乘以该人拥有的数量。最后，我们希望输出每个不同单位的名称和金额。

数据示例:人“a”
- 拥有单位“u1”10次
- 拥有单位“u2”15次

单位u1
- 需要单位“u2”3次
- 需要单元“u3”1次

单位u2
- 需要单位“u3”3次

结果应该是:
您预留的单位:
\#\# 30x u2
\#\# 55x u3

Java 7 中的代码如下所示:

    System.out.println("Your reserved Units: ");
    final Map<Unit, Integer> allRequirements = new HashMap<Unit, Integer>();
    // for each unit that is assigned to the person
    for (UnitAmountPerson unitAmountPerson : person.getUnitAmounts()) {

        // go through each unit that is a requirement for this unit
        for (UnitAmountRequirements requirements : unitAmountPerson.getUnit().getRequirements()) {

            // calculate the amount of requirements
            final Unit requiredUnit = requirements.getUnit();
            final int requiredAmount = unitAmountPerson.getAmount() * requirements.getAmount();

            if (!allRequirements.containsKey(requiredUnit)) {
                allRequirements.put(requiredUnit, 0);
            }

            allRequirements.put(requiredUnit, allRequirements.get(requiredUnit) + requiredAmount);
        }
    }

    for (Entry<Unit, Integer> entry : allRequirements.entrySet()) {
        System.out.println("## " + entry.getValue() + "x " + entry.getKey());
    }`

实体看起来像这样:
Person.java

public class Person{)
    private Set<UnitAmountPerson> unitAmounts = new HashSet<UnitAmountPerson>();

    public Set<UnitAmountPerson> getUnitAmounts() {
        return unitAmounts;
    }
}

Unit.java

public class Unit {
    private String name;

    private Set<UnitAmount> unitAmounts = new HashSet<UnitAmount>();

    private Set<UnitAmountRequirements> requirements = new HashSet<UnitAmountRequirements>();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Set<UnitAmountRequirements> getRequirements() {
        return requirements;
    }

    public Set<UnitAmount> getUnitAmounts() {
        return unitAmounts;
    }
}

UnitAmount.java

public class UnitAmount {
    private Unit unit;
    private int amount;

    public Unit getUnit() {
        return unit;
    }

    public void setUnit(Unit unit) {
        this.unit = unit;
    }

    public int getAmount() {
        return amount;
    }

    public void setAmount(int amount) {
        this.amount = amount;
    }
}

UnitAmountPerson.java

public class UnitAmountPerson extends UnitAmount {
    private Person owner;

    public Person getOwner() {
        return owner;
    }

    public void setOwner(Person owner) {
        this.owner = owner;
    }
}

UnitAmountRequirement.java

public class UnitAmountRequirements extends UnitAmount {
    private Unit owner;

    public Unit getOwner() {
        return owner;
    }

    public void setOwner(Unit owner) {
        this.owner = owner;
    }
}

Answer 1

您可以拥有以下内容:

Map<Unit, Integer> allRequirements = 
    person.getUnitAmounts()
          .stream()
          .flatMap(unitAmountPerson -> 
             unitAmountPerson.getUnit()
                             .getRequirements()
                             .stream()
                             .map(r -> new AbstractMap.SimpleEntry<>(unitAmountPerson.getAmount(), r))
          )
          .collect(Collectors.toMap(
             e -> e.getValue().getUnit(),
             e -> e.getKey() * e.getValue().getAmount(),
             Integer::sum
          ));

这段代码创建了一个Stream超过单位金额。对于每一个，我们都需要存储它的数量和它的需求列表；为此，我们将流平面映射到 Stream<Map.Entry>其中键是该单位金额的金额，值是平面映射的需求。我们必须求助于使用像AbstractMap.SimpleEntry这样的临时数据持有者。保存这两个值，因为 API 中没有内置元组。

最后，这个流被收集到 Map其中键是需求的单位，值是单位数量和需求数量的乘积。如果存在重复值，则会将这些值相加。