This is a bug in JDK 9 – from issue #8193856: takeWhile is incorrectly assuming that an upstream operation supports and honors cancellation, which unfortunately is not the case for flatMap. Explanation If the stream is ordered, takeWhile should show the expected behavior. This is not entirely the case in your code because you use … Read more
The first thing you have to understand is that code like try (Connection connection = dataSource.getConnection()) { … try (PreparedStatement pSt = connection.prepareStatement(sql)) { … return stream; } } does not work as by the time you leave the try blocks, the resources are closed while the processing of the Stream hasn’t even started. The … Read more
You could use Optional : Optional.ofNullable(collection).orElse(Collections.emptySet()).stream()… I chose Collections.emptySet() arbitrarily as the default value in case collection is null. This will result in the stream() method call producing an empty Stream if collection is null. Example : Collection<Integer> collection = Arrays.asList (1,2,3); System.out.println (Optional.ofNullable(collection).orElse(Collections.emptySet()).stream().count ()); collection = null; System.out.println (Optional.ofNullable(collection).orElse(Collections.emptySet()).stream().count ()); Output: 3 0 Alternately, … Read more
Is there some way to squeeze autoboxing in to make this shorter? Yes, there is. You can simply write: double sum = vals.stream().mapToDouble(d->d).sum(); This makes the unboxing implicit but, of course, does not add to efficiency. Since the List is boxed, unboxing is unavoidable. An alternative approach would be: double sum = vals.stream().reduce(0.0, Double::sum); It … Read more
If restricted with Java-8, you can do this: Stream<String> texts = optional.map(Stream::of).orElseGet(Stream::empty);
It is not possible to duplicate a stream in this way. However, you can avoid the code duplication by moving the common part into a method or lambda expression. Supplier<IntStream> supplier = () -> IntStream.range(1, 100).filter(n -> n % 2 == 0); supplier.get().filter(…); supplier.get().filter(…);
Simply translating the “old for loop way” into streams: private Map<String, String> mapConfig(Map<String, Integer> input, String prefix) { int subLength = prefix.length(); return input.entrySet().stream() .collect(Collectors.toMap( entry -> entry.getKey().substring(subLength), entry -> AttributeType.GetByName(entry.getValue()))); }
If you wanna create new list, use Stream.map method: List<Fruit> newList = fruits.stream() .map(f -> new Fruit(f.getId(), f.getName() + “s”, f.getCountry())) .collect(Collectors.toList()) If you wanna modify current list, use Collection.forEach: fruits.forEach(f -> f.setName(f.getName() + “s”))
Elegance is in the eye of the beholder. If you don’t mind using a stateful function in groupingBy, you can do this: AtomicInteger counter = new AtomicInteger(); stream.collect(groupingBy(x->counter.getAndIncrement()/chunkSize)) .values() .forEach(database::flushChunk); This doesn’t win any performance or memory usage points over your original solution because it will still materialize the entire stream before doing anything. If … Read more
Do a reduction that simply returns the current value: Stream<T> stream; T last = stream.reduce((a, b) -> b).orElse(null);