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
First off, there is no need for the combiner to be executed in a non-parallel stream since there is nothing to combine. Secondly, your issue stems from using String::new and String.concat. The accumulator is supposed to modify the first argument by combining the second argument with it but since strings in Java are immutable your … Read more
By definition foreach loop requires an Iterable to be passed in. It can be achieved with anonymous class: for (String s : new Iterable<String>() { @Override public Iterator<String> iterator() { return stream.iterator(); } }) { writer.append(s); } This can be simplified with lambda because Iterable is a functional interface: for (String s : (Iterable<String>) () … Read more
You can use an AtomicInteger as a mutable final counter. public void test() throws IOException { // Make sure the writer closes. try (FileWriter writer = new FileWriter(“OutFile.txt”) ) { // Use AtomicInteger as a mutable line count. final AtomicInteger count = new AtomicInteger(); // Make sure the stream closes. try (Stream<String> lines = Files.lines(Paths.get(“InFile.txt”))) … Read more
To answer the second part of your question, if you want to avoid the exception when the list is empty and return some double value, use orElse instead of getAsDouble: return weightChanges.stream() .mapToDouble(WeightChange::getValue) .average() .orElse(Double.NaN);
First of all, Streams are not meant to achieve these kind of tasks (as opposed to a classic data structure). If you know already how many elements your stream will be processing you might go with the following option, which is, I repeat, not the goal of streams. Stream<MyData> myStream = readData(); final AtomicInteger loader … Read more
My similar question got marked as duplicate, but here is the helper methods I’ve used to avoid some of the boilerplate: public static <T> Stream<T> stream(Iterable<T> in) { return StreamSupport.stream(in.spliterator(), false); } public static <T> Stream<T> parallelStream(Iterable<T> in) { return StreamSupport.stream(in.spliterator(), true); }
Like it was explained in @RealSkeptic comment Predicate can return only two results: true and false. This means you would be able to split your data only in two groups. What you need is some kind of Function which will allow you to determine some common result for elements which should be grouped together. In … Read more
This will incur an overhead of creating a set but it’s simple and will work correctly even if you forget to distinct() the stream first. static<T> Collector<T,?,Optional<T>> singleOrEmpty() { return Collectors.collectingAndThen( Collectors.toSet(), set -> set.size() == 1 ? set.stream().findAny() : Optional.empty() ); }
You’re using @SuppressWarnings(“resource”) which presumably suppresses a warning about an unclosed resource. This isn’t one of the warnings emitted by javac. Web searches seem to indicate that Eclipse issues warnings if an AutoCloseable is left unclosed. This is a reasonable warning according to the Java 7 specification that introduced AutoCloseable: A resource that must be … Read more