Java Streams: Organize a collection into a map and select smallest key

Question

I'm pretty sure this is not possible in one line, but I just wanted to check:

List<WidgetItem> selectedItems = null;
Map<Integer, List<WidgetItem>> itemsByStockAvailable = WidgetItems.stream()
     .collect(Collectors.groupingBy(WidgetItem::getAvailableStock));
selectedItems = itemsByStockAvailable.get(
     itemsByStockAvailable.keySet().stream().sorted().findFirst().get());

Basically I'm collecting all widget items into a map where the key is the availableStock quantity and the value is a list of all widgets that have that quantity (since multiple widgets might have the same value). Once I have that map, I would want to select the map's value that corresponds to the smallest key. The intermediate step of creating a Map isn't necessary, it's just the only way I could think of to do this.

Tunaki · Accepted Answer · 2016-03-19T23:22:39.413

6

It appears what you want is to keep all the widget items that were grouped with the lowest available stock. In that case, you can collect the grouped data into a TreeMap to ensure the ordering based on increasing values of the stock and retrieve the first entry with firstEntry()

List<WidgetItem> selectedItems = 
    widgetItems.stream()
               .collect(Collectors.groupingBy(
                  WidgetItem::getAvailableStock,
                  TreeMap::new,
                  Collectors.toList()
               ))
               .firstEntry()
               .getValue();

The advantage is that it is done is one-pass over the initial list.

edited Mar 19 '16 at 23:22

answered Mar 19 '16 at 23:19

Tunaki

132,869
46
340
423

Ah- TreeMap. I forgot about that Class as it's been a while since I had to use it. Thanks! – IcedDante Mar 19 '16 at 23:22
3

If you prefer to cram everything into one stream, you could also do `Collectors.collectingAndThen(Collectors.groupingBy(...), x -> x.firstEntry().getValue())` – user140547 Mar 20 '16 at 11:46

score 2 · Answer 2 · edited May 23 '17 at 12:07

Essentially you want to get all the input elements which are minimal according to the custom comparator Comparator.comparingInt(WidgetItem::getAvailableStock). In general this problem could be solved without necessity to store everything into the intermediate map creating unnecessary garbage. Also it could be solved in single pass. Some interesting solutions already present in this question. For example, you may use the collector implemented by Stuart Marks:

List<WidgetItem> selectedItems = widgetItems.stream()
           .collect(maxList(
               Comparator.comparingInt(WidgetItem::getAvailableStock).reversed()));

Such collectors are readily available in my StreamEx library. The best suitable in your case is MoreCollectors.minAll(Comparator):

List<WidgetItem> selectedItems = widgetItems.stream()
           .collect(MoreCollectors.minAll(
               Comparator.comparingInt(WidgetItem::getAvailableStock)));

JB Nizet · Answer 3 · 2016-03-19T23:19:54.883

You can find the smallest key in a first pass and then get all the items having that smallest key:

widgetItems.stream()
           .map(WidgetItem::getAvailableStock)
           .min(Comparator.naturalOrder())
           .map(min -> 
               widgetItems.stream()
                          .filter(item -> item.getAvailableStock().equals(min))
                          .collect(toList()))
           .orElse(Collections.emptyList());

score 1 · Answer 4 · answered Mar 19 '16 at 23:19

If you want to avoid creating the intermediate map, you can first determine the smallest stock value, filter by that value and collect to list.

int minStock = widgetItems.stream()
    .mapToInt(WidgetItem::getAvailableStock)
    .min()
    .getAsInt();  // or throw if list is empty

List<WidgetItem> selectItems = widgetItems.stream()
    .filter(w -> minStock == w.getAvailableStock())
    .collect(toList());

Also, do not use sorted().findFirst() to find the min value of a stream. Use min instead.

score 0 · Answer 5 · answered Mar 20 '16 at 01:33

I would collect the data into a NavigableMap, which involves only a small change to your original code:

List<WidgetItem> selectedItems = null;
NavigableMap<Integer, List<WidgetItem>> itemsByStockAvailable =
    WidgetItems.stream()
        .collect(Collectors.groupingBy(WidgetItem::getAvailableStock,
            TreeMap::new, Collectors.toList()));
selectedItems = itemsByStockAvailable.firstEntry().getValue();

Java Streams: Organize a collection into a map and select smallest key

5 Answers5