Ufdjrw

I have a List of Prices and PriceGroups.

static class PriceGroup 
 String priceName;
 String priceGroup;


static class Price 
 String priceName;
 Integer price;

Below is some sample data, and an implementation I wrote finding the lowest Price for each PriceGroup. Any suggestions how I could refactor this to utilize streams to join this data?

List<PriceGroup> priceGroups = Arrays.asList(
 new PriceGroup("F1", "Friends"),
 new PriceGroup("F2", "Friends"),
 new PriceGroup("O1", "Others"),
 new PriceGroup("O2", "Others"));

List<Price> prices = Arrays.asList(
 new Price("F1", 100),
 new Price("F2", 150),
 new Price("O1", 250),
 new Price("O2", 300));

public Map<String, Integer> getBestPrices(List<PriceGroup> priceGroups, List<Price> prices) 

 Map<String, Integer> bestPrice = new HashMap<String, Integer>(); 
 for (PriceGroup priceGroup : priceGroups) 
 if (bestPrice.get(priceGroup.priceGroup) == null) 
 bestPrice.put(priceGroup.priceGroup, 10000000);
 

 for (Price price : prices) 
 if (price.priceName.equals(priceGroup.priceName)) 
 bestPrice.put(priceGroup.priceGroup, Math.min(price.price, bestPrice.get(priceGroup.priceGroup)));
 
 
 

 return bestPrice;

For the given data, my function should return a map with:

F1 => 100

O1 => 250

To get 2 lists joined you could consider to create dedicated object:

class Joined {
 String priceGroup;
 String priceName;
 Integer price;
 ...

Then, using flatMap you can join priceGroups to prices on priceName field and group by priceGroup:

Map<String, Optional<Joined>> map = priceGroups.stream()
 .flatMap(group -> prices.stream()
 .filter(p -> p.getPriceName().equals(group.getPriceName()))
 .map(p -> new Joined(group.getPriceGroup(), group.getPriceName(), p.getPrice())))
 .collect(groupingBy(Joined::getPriceGroup, minBy(Comparator.comparing(Joined::getPrice))));

Now getting values from map you can print expected result:

for (Optional<Joined> value : map.values()) 
 value.ifPresent(joined -> System.out.println(joined.getPriceName() + " " + joined.getPrice()));
 

// O1 250
// F1 100

First: I think @Ruslan's answer is what you should use.

But you mentioned that the return has to be Map<String, Integer> and that the String should be the F1 instead of Friends. So I tried to get it all in one go and got this abomination of a function:

public static Map<String, Integer> getBestPricesV2(List<PriceGroup> priceGroups, List<Price> prices) 
 final String unknownPriceName = "Unkown price name";

 return prices.stream().collect(Collectors.groupingBy(
 // map the price name the priceGroup name
 price -> priceGroups.stream()
 .filter(priceGroup -> priceGroup.getPriceName().equals(price.getPriceName()))
 .findFirst()
 .map(PriceGroup::getPriceGroup)
 .orElse(unknownPriceName), 
 Collectors.minBy(Comparator.comparing(Price::getPrice))))
 .entrySet()
 .stream()
 // extract the Optional<Price> to the price value
 .collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().orElse(new Price(unknownPriceName, -1)).getPrice()));

You can simply avoid using a join class for this operation and perform it as :

public Map<String, Integer> getBestPrices(List<PriceGroup> priceGroups, List<Price> prices) 
// create a map of priceName to minimum price value using list of prices
 Map<String, Integer> minPrice = prices.stream()
 .collect(Collectors.groupingBy(Price::getPriceName,
 Collectors.reducing(0, Price::getPrice,
 BinaryOperator.minBy(Comparator.naturalOrder()))));

// use the map above to fill in the best prices map with values present or default
 return priceGroups.stream()
 .collect(Collectors.toMap(PriceGroup::getPriceGroup,
 priceGroup ->
 minPrice.getOrDefault(priceGroup.getPriceName(), 10000000)));