I have some recollections from the early design of the Streams API that might shed some light on the design rationale. Back in 2012, we were adding lambdas to the language, and we wanted a collections-oriented or “bulk data” set of operations, programmed using lambdas, that would facilitate parallelism. The idea of lazily chaining operations … Read more
You can adapt the solution you linked in How to sort ArrayList<Long> in Java in decreasing order? by wrapping it in a lambda: .sorted((f1, f2) -> Long.compare(f2.lastModified(), f1.lastModified()) note that f2 is the first argument of Long.compare, not the second, so the result will be reversed.
One simple way is to append your list items in a StringBuilder List<Integer> list = new ArrayList<>(); list.add(1); list.add(2); list.add(3); StringBuilder b = new StringBuilder(); list.forEach(b::append); System.out.println(b); you can also try: String s = list.stream().map(e -> e.toString()).reduce(“”, String::concat); Explanation: map converts Integer stream to String stream, then its reduced as concatenation of all the elements. … Read more
This was not an omission; there was detailed discussion on the EG list in June of 2013. The definitive discussion of the Expert Group is rooted at this thread. While it seemed “obvious” (even to the Expert Group, initially) that stream() seemed to make sense on Iterable, the fact that Iterable was so general became … Read more
Map<String, String> x; Map<String, Integer> y = x.entrySet().stream() .collect(Collectors.toMap( e -> e.getKey(), e -> Integer.parseInt(e.getValue()) )); It’s not quite as nice as the list code. You can’t construct new Map.Entrys in a map() call so the work is mixed into the collect() call.
Java 9 Optional.stream has been added to JDK 9. This enables you to do the following, without the need of any helper method: Optional<Other> result = things.stream() .map(this::resolve) .flatMap(Optional::stream) .findFirst(); Java 8 Yes, this was a small hole in the API, in that it’s somewhat inconvenient to turn an Optional<T> into a zero-or-one length Stream<T>. … Read more
Sure. .orElseThrow(() -> new MyException(someArgument))
People have already asked the same on the mailing list ☺. The main reason is Iterable also has a re-iterable semantic, while Stream is not. I think the main reason is that Iterable implies reusability, whereas Stream is something that can only be used once — more like an Iterator. If Stream extended Iterable then … Read more
Create a custom Collector public static <T> Collector<T, ?, T> toSingleton() { return Collectors.collectingAndThen( Collectors.toList(), list -> { if (list.size() != 1) { throw new IllegalStateException(); } return list.get(0); } ); } We use Collectors.collectingAndThen to construct our desired Collector by Collecting our objects in a List with the Collectors.toList() collector. Applying an extra finisher … Read more
The code that has to be executed for both alternatives is so similar that you can’t predict a result reliably. The underlying object structure might differ but that’s no challenge to the hotspot optimizer. So it depends on other surrounding conditions which will yield to a faster execution, if there is any difference. Combining two … Read more