我有两个集合，一个仓库 ID 列表和一个小部件集合。小部件以不同的数量存在于多个仓库中:

List<Long> warehouseIds;
List<Widget> widgets;

这是一个类定义的例子:

public class Widget {
    public Collection<Stock> getStocks();
}

public class Stock {
    public Long getWarehouseId();
    public Integer getQuantity();
}

我想使用Streams API创建一个Map，其中仓库ID是键，值是特定仓库中数量最少的Widget列表。因为多个小部件可能具有相同的数量，所以我们返回一个列表。

例如，仓库 111 有 5 个Widget A，5 个Widget B ，以及 8 的 Widget C。

仓库 222 有 0 个小部件 A，5 个小部件 B，以及 5 的 Widget C 返回的 map 将包含以下条目:

111 => ['WidgetA', 'WidgetB']

222 => ['WidgetA']

使用键开始设置 Map 似乎很容易，但我不知道如何构造下游缩减:

warehouseIds.stream().collect(Collectors.groupingBy(
    Function::Identity,
    HashMap::new,
    ???...

我认为我遇到的问题是根据库存仓库 Id 减少 Widget，并且不知道如何返回 Collector 来创建这个 Widget 列表。以下是我目前如何获取特定仓库中库存最少的小部件列表(由 someWarehouseId 表示):

widgets.stream().collect(Collectors.groupingBy(
    (Widget w)->
        w.getStocks()
        //for a specific warehouse
        .stream().filter(stock->stock.getWarehouseId()==someWarehouseId)
        //Get the quantity of stocks for a widget
        .collect(Collectors.summingInt(Stock::getQuantity)),
    //Use a tree map so the keys are sorted
    TreeMap::new,
    //Get the first entry
    Collectors.toList())).firstEntry().getValue();

在仓库列表中使用 forEach 将其分成两个任务会使这项工作变得容易，但我想知道我是否可以在“单行”中完成此任务。

最佳答案

为了解决这个问题，我们需要使用比使用 TreeMap 更合适的方法。选择具有最小数量的值。

考虑以下方法:

• 我们制作一个 Stream<Widget>我们最初的小部件。我们需要对每个小部件的库存进行一些处理，但我们还需要保留小部件。让我们flatMap那Stream<Widget>进入Stream<Map.Entry<Stock, Widget>> :新的 Stream 将由每个 Stock 组成我们有它对应的Widget .
• 我们过滤这些元素只保留 Map.Entry<Stock, Widget>其中股票有 warehouseId包含在 warehouseIds列表。
• 现在，我们需要根据 warehouseId 对该流进行分组每个 Stock .所以我们使用 Collectors.groupingBy(classifier, downstream) 分类器返回 warehouseId 的位置.
• 下游收集器收集归类到相同键的元素。在这种情况下，对于 Map.Entry<Stock, Widget>被分类为相同的元素 warehouseId ，我们只需要保留库存数量最少的那些。没有内置的收集器，让我们使用 MoreCollectors.minAll(comparator, downstream) 来自 StreamEx图书馆。如果您不想使用该库，我已将其代码提取到此答案中并将使用它。
• 比较器简单地比较 Map.Entry<Stock, Widget> 中每只股票的数量.这确保我们将在固定的 warehouseId 内保留数量最少的元素。 .下游收集器用于减少收集到的元素。在这种情况下，我们只想保留小部件，所以我们使用 Collectors.mapping(mapper, downstream) 映射器从 Map.Entry<Stock, Widget> 返回小部件的位置下游收集器收集到列表中 Collectors.toList() .

示例代码:

Map<Long, List<Widget>> map =
    widgets.stream()
           .flatMap(w -> w.getStocks().stream().map(s -> new AbstractMap.SimpleEntry<>(s, w)))
           .filter(e -> warehouseIds.contains(e.getKey().getWarehouseId()))
           .collect(Collectors.groupingBy(
              e -> e.getKey().getWarehouseId(),
              minAll(
                Comparator.comparingInt(e -> e.getKey().getQuantity()), 
                Collectors.mapping(e -> e.getValue(), Collectors.toList())
              )
           ));

具有以下 minAll Collection 家:

public static <T, A, D> Collector<T, ?, D> minAll(Comparator<? super T> comparator, Collector<T, A, D> downstream) {
    return maxAll(comparator.reversed(), downstream);
}

public static <T, A, D> Collector<T, ?, D> maxAll(Comparator<? super T> comparator, Collector<? super T, A, D> downstream) {

    final class PairBox<U, V> {
        public U a;
        public V b;
        PairBox(U a, V b) {
            this.a = a;
            this.b = b;
        }
    }

    Supplier<A> downstreamSupplier = downstream.supplier();
    BiConsumer<A, ? super T> downstreamAccumulator = downstream.accumulator();
    BinaryOperator<A> downstreamCombiner = downstream.combiner();
    Supplier<PairBox<A, T>> supplier = () -> new PairBox<>(downstreamSupplier.get(), null);
    BiConsumer<PairBox<A, T>, T> accumulator = (acc, t) -> {
        if (acc.b == null) {
            downstreamAccumulator.accept(acc.a, t);
            acc.b = t;
        } else {
            int cmp = comparator.compare(t, acc.b);
            if (cmp > 0) {
                acc.a = downstreamSupplier.get();
                acc.b = t;
            }
            if (cmp >= 0)
                downstreamAccumulator.accept(acc.a, t);
        }
    };
    BinaryOperator<PairBox<A, T>> combiner = (acc1, acc2) -> {
        if (acc2.b == null) {
            return acc1;
        }
        if (acc1.b == null) {
            return acc2;
        }
        int cmp = comparator.compare(acc1.b, acc2.b);
        if (cmp > 0) {
            return acc1;
        }
        if (cmp < 0) {
            return acc2;
        }
        acc1.a = downstreamCombiner.apply(acc1.a, acc2.a);
        return acc1;
    };
    Function<PairBox<A, T>, D> finisher = acc -> downstream.finisher().apply(acc.a);
    return Collector.of(supplier, accumulator, combiner, finisher);
}

关于Java 流 : Combining two collections into a map，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/36136336/