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
As explained in Why does Stream<T> not implement Iterable<T>?, an Iterable bears the expectation to be able to provide an Iterator more than once, which a Stream can’t fulfill. So while you can create an Iterable out of a Stream for an ad-hoc use, you have to be careful about whether attempts to iterate it … Read more
If this happens repeatedly, you may create a generic utility method handling the problem of constructing an object given one property value: public static <T,V> Function<V,T> create( Supplier<? extends T> constructor, BiConsumer<? super T, ? super V> setter) { return v -> { T t=constructor.get(); setter.accept(t, v); return t; }; } Then you may use … Read more
Map<Boolean, List<Integer>> partitioned = set.stream().collect(Collectors.partitioningBy(x -> x%2 == 0)); The elements in partitioned.get(true) are even; the elements in partitioned.get(false) are odd. Unlike doing this using groupingBy, it is guaranteed that both true and false lists will be present in the map even if they are empty. (Not documented in Java 8, but it was true; … Read more
A Stream supports several operations and these operations are divided into intermediate and terminal operations. The distinction between this operations is that an intermediate operation is lazy while a terminal operation is not. When you invoke an intermediate operation on a stream, the operation is not executed immediately. It is executed only when a terminal … 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
As far as I know, the streams API does not support asynchronous event processing. Sounds like you want something like Reactive Extensions for .NET, and there is a Java port of it called RxJava, created by Netflix. RxJava supports many of the same high-level operations as Java 8 streams (such as map and filter) and … Read more
Since the current state of the issue is quite the opposite of the earlier statements made here, it should be noted, that there is now an explicit statement by Brian Goetz about the back-propagation of the unordered characteristic past a skip operation is considered a bug. It’s also stated that it is now considered to … Read more
You can grab the stream of the map’s entry set, then map each entry to the string representation you want, joining them in a single string using Collectors.joining(CharSequence delimiter). import static java.util.stream.Collectors.joining; String s = attributes.entrySet() .stream() .map(e -> e.getKey()+”=”+e.getValue()) .collect(joining(“&”)); But since the entry’s toString() already output its content in the format key=value, you … Read more
You simply don’t know the specific type created by that factory method (it guarantees to return Set, nothing else). The only reliable way is to actually control what happens, by ending the stream operation with … collect( Collectors.toCollection( LinkedHashSet::new ) );