The documentation for groupingBy() says: Implementation Requirements: This produces a result similar to: groupingBy(classifier, toList()); The documentation for toList() says: Returns: a Collector which collects all the input elements into a List, in encounter order So, to answer your question, as long as your stream has a defined encounter order, you’re guaranteed to get ordered … Read more
You can make use of the Collectors.filtering API introduced since Java-9 for this: Map<String, List<Employee>> output = list.stream() .collect(Collectors.groupingBy(Employee::getDepartment, Collectors.filtering(e -> e.getSalary() > 2000, Collectors.toList()))); Important from the API note : The filtering() collectors are most useful when used in a multi-level reduction, such as downstream of a groupingBy or partitioningBy. A filtering collector differs … Read more
Actually it was originally designed similarly to what you propose. See the early implementation in project lambda repository (makeResult is now supplier). It was later updated to the current design. I believe, the rationale of such update is to simplify collector combinators. I did not find any specific discussion on this topic, but my guess … Read more
Recall that the goal of stream flags (ORDERED, SORTED, SIZED, DISTINCT) is to enable operations to avoid doing unnecessary work. Examples of optimizations that involve stream flags are: If we know the stream is already sorted, then sorted() is a no-op; If we know the size of the stream, we can pre-allocate a correct-sized array … Read more
It’s the type inference that doesn’t get it right. If you provide the type argument explicitly it works as expected: List<? extends Number> wildCardList = Arrays.asList(1, 2, 3D); wildCardList.stream().collect(Collectors.<Number, Integer, Number>toMap( number -> Integer.valueOf(number.intValue()), number -> number)); This is a known javac bug: Inference should not map capture variables to their upper bounds. The status, … Read more
TLDR : To collect into a Map that contains a single value by key (Map<MyKey,MyObject>), use Collectors.toMap(). To collect into a Map that contains multiple values by key (Map<MyKey, List<MyObject>>), use Collectors.groupingBy(). Collectors.toMap() By writing : chargePoints.stream().collect(Collectors.toMap(Point::getParentId, c -> c)); The returned object will have the Map<Long,Point> type. Look at the Collectors.toMap() function that you … Read more
You could have the following: public Map<Integer, List<String>> getMap(List<String> strings) { return strings.stream().collect( Collectors.groupingBy(String::length, HashMap::new, Collectors.toCollection(ArrayList::new)) ); } The collector groupingBy(classifier, mapFactory, downstream) can be used to specify which type of map is wanted, by passing it a supplier of the wanted map for the mapFactory. Then, the downstream collector, which is used to collect … Read more
Actually, you need to use Collectors.toMap here instead of Collectors.groupingBy: Map<String, Valuta> map = getValute().stream() .collect(Collectors.toMap(Valuta::getCodice, Function.identity())); groupingBy is used to group elements of a Stream based on a grouping function. 2 Stream elements that will have the same result with the grouping function will be collected into a List by default. toMap will collect … Read more
You can use the groupingBy method to manage aggregation, for example: public static void main(String[] args) { List<String> list = Arrays.asList(“A”, “B”, “C”, “D”, “A”); Map<String, List<String>> map = list.stream().collect(Collectors.groupingBy(Function.identity())); } If you want more flexibility (for example to map the value and return a Set instead of a List) you can always use the … Read more
One difference is that Stream.toList() provides a List implementation that is immutable (type ImmutableCollections.ListN that cannot be added to or sorted) similar to that provided by List.of() and in contrast to the mutable (can be changed and sorted) ArrayList provided by Stream.collect(Collectors.toList()). Demo: import java.util.stream.Stream; import java.util.List; public class Main { public static void main(String[] … Read more