如何在Java8流API中编写此循环

我对Java8非常陌生，想重写一些代码

有没有办法写得更漂亮一些

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

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

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

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

结果应该是：

您的保留单位：
\#\#30倍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());
    }`

UnitAmountPerson.java

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

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

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;
    }
}

---

您可以拥有以下功能：

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
          ));

映射所有需求=
person.getUnitAmounts（）
.stream（）
.flatMap（个人->
unitAmountPerson.getUnit（）
.getRequirements（）
.stream（）
.map（r->newAbstractMap.SimpleEntry（unitAmountPerson.getAmount（），r））
)
.collect（collector.toMap）(
e->e.getValue（）.getUnit（），
e->e.getKey（）*e.getValue（）.getAmount（），
整数：：和
));

此代码在单位金额上创建一个

流

。对于其中的每一个，我们都需要存储其数量和需求列表；为此，我们将流平面映射到

流

，其中键是该单位金额的金额，值是平面映射的需求。由于API中没有内置元组，因此我们必须使用像

AbstractMap.SimpleEntry

这样的临时数据持有者来保存这两个值

---

最后，该流被收集到一个

映射图

，其中键是需求的单位，值是单位金额和需求金额的乘积。如果存在重复的值，则会对这些值进行求和。

您可以使用以下内容：

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
          ));

映射所有需求=
person.getUnitAmounts（）
.stream（）
.flatMap（个人->
unitAmountPerson.getUnit（）
.getRequirements（）
.stream（）
.map（r->newAbstractMap.SimpleEntry（unitAmountPerson.getAmount（），r））
)
.collect（collector.toMap）(
e->e.getValue（）.getUnit（），
e->e.getKey（）*e.getValue（）.getAmount（），
整数：：和
));

此代码在单位金额上创建一个

流

。对于其中的每一个，我们都需要存储其数量和需求列表；为此，我们将流平面映射到

流

，其中键是该单位金额的金额，值是平面映射的需求。由于API中没有内置元组，因此我们必须使用像

AbstractMap.SimpleEntry

这样的临时数据持有者来保存这两个值

---

最后，该流被收集到一个

映射图

，其中键是需求的单位，值是单位金额和需求金额的乘积。如果存在重复值，则将值相加。

就像一个符咒。尽管我真的不得不为这件事绞尽脑汁；）就像一个符咒。尽管我真的不得不为这件事绞尽脑汁；）

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
          ));