This method was introduced from Java 9. Here we have two overload methods delayedExecutor(), the first method has the following syntax:
|
1 |
static Executor delayedExecutor(long delay, TimeUnit unit) |
This method returns an Executor object from the default Executor object that the CompletableFuture object uses to execute the task, after the delay.… Read More
This method was introduced from Java 9.
|
1 |
CompletableFuture<T> completeOnTimeout(T value, long timeout, TimeUnit unit) |
This method is used to: if after a timeout period our task is still unfinished, instead of throwing out the TimeoutException exception like the orTimeout() method, our code will return the value that we passed in this method.… Read More
This method was introduced from Java 9.
|
1 |
CompletableFuture<T> orTimeout(long timeout, TimeUnit unit) |
This method is used to specify that if our task does not complete within a certain period of time, the program will stop and be TimeoutException. In the following example, I want to calculate the sum of… Read More
This method was introduced from Java 9. This method is similar to the ifPresent() method which I introduced in this tutorial, but here is a difference since we have one more Runnable parameter, so that in-case if the Optional object is empty, the object of the… Read More
This method is supported since Java 9. This method is used to create a new Stream object from an Optional object in Java. If the Optional object contains a value, this method will return the Stream object containing that value, otherwise, it returns an empty… Read More
In Java 8, the iterate() method has been introduced and it has only two parameters and will help us to create an infinite stream. Content:
|
1 |
public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f) |
Example:
|
1 2 3 4 5 6 7 8 9 10 |
package com.huongdanjava.javastream; import java.util.stream.Stream; public class Example { public static void main(String[] args) { Stream.iterate(1, i -> i + 1).forEach(System.out::println); } } |
When running the above example, you will see that a Stream object contains endless numbers beginning at… Read More
This method was added from Java 9.
|
1 |
static<T> Stream<T> ofNullable(T t) |
This method will return the Stream object of an element in case this element is not null; if it is null, it returns an empty Stream. Example:
|
1 2 3 4 5 6 7 8 9 10 11 |
package com.huongdanjava.javaexample; import java.util.stream.Stream; public class Example { public static void main(String[] args) { String s = null; Stream.ofNullable(s).forEach(System.out::println); } } |
When you run the above code, it will print… Read More
This method was added from Java 9.
|
1 |
default Stream<T> dropWhile(Predicate<? super T> predicate) |
This method also has the parameter Predicate interface and its function is the opposite of the takeWhile() method. This method also passes each element in your Stream object from left to right and ignores all elements that… Read More
This method was added from Java 9.
|
1 |
default Stream<T> takeWhile(Predicate<? super T> predicate) |
The parameter of this method is the Predicate interface and this method takes the elements in your Stream object from left to right, until the condition of the Predicate object is no longer fulfilled. Example:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
package com.huongdanjava.javastream; import java.util.stream.Stream; public class Example { public static void main(String[] args) { Stream.of(1,2,3,4,5,6,7,8,9,10) .takeWhile(i -> i < 5) .forEach(System.out::println); } } |
In… Read More
Reactive Streams are a concept that defines the mechanism for handling streams asynchronously with non-blocking back pressure. Back pressure here, we can understand that there is too much work to do at the same time, then it should lead to overload. Non-blocking back pressure means… Read More
