JavaScript is disabled on your browser.
Skip navigation links
io.reactivex.rxjava3.parallel

Class ParallelFlowable<T>

  • Type Parameters:
    T - the value type

    public abstract class ParallelFlowable<T>
extends Object
    Abstract base class for parallel publishing of events signaled to an array of Subscribers.

    Use from(Publisher) to start processing a regular Publisher in 'rails'. Use runOn(Scheduler) to introduce where each 'rail' should run on thread-vise. Use sequential() to merge the sources back into a single Flowable.

    History: 2.0.5 - experimental; 2.1 - beta

    Since:
    2.2

    • Constructor Detail

      • ParallelFlowable

        public ParallelFlowable()

    • Method Detail

      • subscribe

        @BackpressureSupport(value=SPECIAL)
 @SchedulerSupport(value="none")
public abstract void subscribe(@NonNull Subscriber<? super T>[] subscribers)
        Subscribes an array of Subscribers to this ParallelFlowable and triggers the execution chain for all 'rails'.
        Backpressure:
        The backpressure behavior/expectation is determined by the supplied Subscriber.
        Scheduler:
        subscribe does not operate by default on a particular Scheduler.
        Parameters:
        subscribers - the subscribers array to run in parallel, the number of items must be equal to the parallelism level of this ParallelFlowable
        Throws:
        NullPointerException - if subscribers is null
        See Also:
        parallelism()

      • parallelism

        @CheckReturnValue
public abstract int parallelism()
        Returns the number of expected parallel Subscribers.
        Returns:
        the number of expected parallel Subscribers

      • validate

        protected final boolean validate(@NonNull Subscriber<?>[] subscribers)
        Validates the number of subscribers and returns true if their number matches the parallelism level of this ParallelFlowable.
        Parameters:
        subscribers - the array of Subscribers
        Returns:
        true if the number of subscribers equals to the parallelism level
        Throws:
        NullPointerException - if subscribers is null
        IllegalArgumentException - if subscribers.length is different from parallelism()

      • from

        @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static <T> @NonNull ParallelFlowable<T> from(@NonNull Publisher<? extends T> source,
 int parallelism,
 int prefetch)
        Take a Publisher and prepare to consume it on parallelism number of 'rails' , possibly ordered and round-robin fashion and use custom prefetch amount and queue for dealing with the source Publisher's values.
        Backpressure:
        The operator honors the backpressure of the parallel rails and requests the prefetch amount from the upstream, followed by 75% of that amount requested after every 75% received.
        Scheduler:
        from does not operate by default on a particular Scheduler.
        Type Parameters:
        T - the value type
        Parameters:
        source - the source Publisher
        parallelism - the number of parallel rails
        prefetch - the number of values to prefetch from the source the source until there is a rail ready to process it.
        Returns:
        the new ParallelFlowable instance
        Throws:
        NullPointerException - if source is null
        IllegalArgumentException - if parallelism or prefetch is non-positive

      • runOn

        @CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="custom")
public final @NonNull ParallelFlowable<T> runOn(@NonNull Scheduler scheduler)
        Specifies where each 'rail' will observe its incoming values, specified via a Scheduler, with no work-stealing and default prefetch amount.

        This operator uses the default prefetch size returned by Flowable.bufferSize().

        The operator will call Scheduler.createWorker() as many times as this ParallelFlowable's parallelism level is.

        No assumptions are made about the Scheduler's parallelism level, if the Scheduler's parallelism level is lower than the ParallelFlowable's, some rails may end up on the same thread/worker.

        This operator doesn't require the Scheduler to be trampolining as it does its own built-in trampolining logic.

        Backpressure:
        The operator honors the backpressure of the parallel rails and requests Flowable.bufferSize() amount from the upstream, followed by 75% of that amount requested after every 75% received.
        Scheduler:
        runOn drains the upstream rails on the specified Scheduler's Workers.
        Parameters:
        scheduler - the scheduler to use
        Returns:
        the new ParallelFlowable instance
        Throws:
        NullPointerException - if scheduler is null

      • runOn

        @CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="custom")
public final @NonNull ParallelFlowable<T> runOn(@NonNull Scheduler scheduler,
 int prefetch)
        Specifies where each 'rail' will observe its incoming values, specified via a Scheduler, with possibly work-stealing and a given prefetch amount.

        This operator uses the default prefetch size returned by Flowable.bufferSize().

        The operator will call Scheduler.createWorker() as many times as this ParallelFlowable's parallelism level is.

        No assumptions are made about the Scheduler's parallelism level, if the Scheduler's parallelism level is lower than the ParallelFlowable's, some rails may end up on the same thread/worker.

        This operator doesn't require the Scheduler to be trampolining as it does its own built-in trampolining logic.

        Backpressure:
        The operator honors the backpressure of the parallel rails and requests the prefetch amount from the upstream, followed by 75% of that amount requested after every 75% received.
        Scheduler:
        runOn drains the upstream rails on the specified Scheduler's Workers.
        Parameters:
        scheduler - the scheduler to use that rail's worker has run out of work.
        prefetch - the number of values to request on each 'rail' from the source
        Returns:
        the new ParallelFlowable instance
        Throws:
        NullPointerException - if scheduler is null
        IllegalArgumentException - if prefetch is non-positive

      • reduce

        @CheckReturnValue
 @NonNull
 @BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public final <R> @NonNull ParallelFlowable<R> reduce(@NonNull Supplier<R> initialSupplier,
 @NonNull BiFunction<R,? super T,R> reducer)
        Reduces all values within a 'rail' to a single value (with a possibly different type) via a reducer function that is initialized on each rail from an initialSupplier value.

        Note that the same mapper function may be called from multiple threads concurrently.

        Backpressure:
        The operator honors backpressure from the downstream rails and consumes the upstream rails in an unbounded manner (requesting Long.MAX_VALUE).
        Scheduler:
        reduce does not operate by default on a particular Scheduler.
        Type Parameters:
        R - the reduced output type
        Parameters:
        initialSupplier - the supplier for the initial value
        reducer - the function to reduce a previous output of reduce (or the initial value supplied) with a current source value.
        Returns:
        the new ParallelFlowable instance
        Throws:
        NullPointerException - if initialSupplier or reducer is null

      • sequentialDelayError

        @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
 @CheckReturnValue
 @NonNull
public final @NonNull Flowable<T> sequentialDelayError()
        Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Flowable sequence, running with a default prefetch value for the rails and delaying errors from all rails till all terminate.

        This operator uses the default prefetch size returned by Flowable.bufferSize().

        Backpressure:
        The operator honors backpressure from the downstream and requests Flowable.bufferSize() amount from each rail, then requests from each rail 75% of this amount after 75% received.
        Scheduler:
        sequentialDelayError does not operate by default on a particular Scheduler.

        History: 2.0.7 - experimental

        Returns:
        the new Flowable instance
        Since:
        2.2
        See Also:
        sequentialDelayError(int), sequential()

      • sequentialDelayError

        @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
 @CheckReturnValue
 @NonNull
public final @NonNull Flowable<T> sequentialDelayError(int prefetch)
        Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Flowable sequence, running with a give prefetch value for the rails and delaying errors from all rails till all terminate.
        Backpressure:
        The operator honors backpressure from the downstream and requests the prefetch amount from each rail, then requests from each rail 75% of this amount after 75% received.
        Scheduler:
        sequentialDelayError does not operate by default on a particular Scheduler.

        History: 2.0.7 - experimental

        Parameters:
        prefetch - the prefetch amount to use for each rail
        Returns:
        the new Flowable instance
        Throws:
        IllegalArgumentException - if prefetch is non-positive
        Since:
        2.2
        See Also:
        sequential(), sequentialDelayError()

      • collect

        @CheckReturnValue
 @NonNull
 @BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public final <C> @NonNull ParallelFlowable<C> collect(@NonNull Supplier<? extends C> collectionSupplier,
 @NonNull BiConsumer<? super C,? super T> collector)
        Collect the elements in each rail into a collection supplied via a collectionSupplier and collected into with a collector action, emitting the collection at the end.
        Backpressure:
        The operator honors backpressure from the downstream rails and consumes the upstream rails in an unbounded manner (requesting Long.MAX_VALUE).
        Scheduler:
        map does not operate by default on a particular Scheduler.
        Type Parameters:
        C - the collection type
        Parameters:
        collectionSupplier - the supplier of the collection in each rail
        collector - the collector, taking the per-rail collection and the current item
        Returns:
        the new ParallelFlowable instance
        Throws:
        NullPointerException - if collectionSupplier or collector is null

      • to

        @CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public final <R> R to(@NonNull ParallelFlowableConverter<T,R> converter)
        Calls the specified converter function during assembly time and returns its resulting value.

        This allows fluent conversion to any other type.

        Backpressure:
        The operator is a pass-through for backpressure and the behavior is determined by how the converter function composes over the upstream source.
        Scheduler:
        to does not operate by default on a particular Scheduler.

        History: 2.1.7 - experimental

        Type Parameters:
        R - the resulting object type
        Parameters:
        converter - the function that receives the current ParallelFlowable instance and returns a value
        Returns:
        the converted value
        Throws:
        NullPointerException - if converter is null
        Since:
        2.2

      • compose

        @CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public final <U> @NonNull ParallelFlowable<U> compose(@NonNull ParallelTransformer<T,U> composer)
        Allows composing operators, in assembly time, on top of this ParallelFlowable and returns another ParallelFlowable with composed features.
        Backpressure:
        The operator is a pass-through for backpressure and the behavior is determined by how the converter function composes over the upstream source.
        Scheduler:
        compose does not operate by default on a particular Scheduler.
        Type Parameters:
        U - the output value type
        Parameters:
        composer - the composer function from ParallelFlowable (this) to another ParallelFlowable
        Returns:
        the ParallelFlowable returned by the function
        Throws:
        NullPointerException - if composer is null

      • flatMap

        @CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final <R> @NonNull ParallelFlowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
 boolean delayError)
        Generates and flattens Publishers on each 'rail', optionally delaying errors.

        It uses unbounded concurrency along with default inner prefetch.

        Backpressure:
        The operator honors backpressure from the downstream rails and requests Flowable.bufferSize() amount from each rail upfront and keeps requesting as many items per rail as many inner sources on that rail completed. The inner sources are requested Flowable.bufferSize() amount upfront, then 75% of this amount requested after 75% received.
        Scheduler:
        flatMap does not operate by default on a particular Scheduler.
        Type Parameters:
        R - the result type
        Parameters:
        mapper - the function to map each rail's value into a Publisher
        delayError - should the errors from the main and the inner sources delayed till everybody terminates?
        Returns:
        the new ParallelFlowable instance
        Throws:
        NullPointerException - if mapper is null

      • flatMap

        @CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final <R> @NonNull ParallelFlowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
 boolean delayError,
 int maxConcurrency)
        Generates and flattens Publishers on each 'rail', optionally delaying errors and having a total number of simultaneous subscriptions to the inner Publishers.

        It uses a default inner prefetch.

        Backpressure:
        The operator honors backpressure from the downstream rails and requests maxConcurrency amount from each rail upfront and keeps requesting as many items per rail as many inner sources on that rail completed. The inner sources are requested Flowable.bufferSize() amount upfront, then 75% of this amount requested after 75% received.
        Scheduler:
        flatMap does not operate by default on a particular Scheduler.
        Type Parameters:
        R - the result type
        Parameters:
        mapper - the function to map each rail's value into a Publisher
        delayError - should the errors from the main and the inner sources delayed till everybody terminates?
        maxConcurrency - the maximum number of simultaneous subscriptions to the generated inner Publishers
        Returns:
        the new ParallelFlowable instance
        Throws:
        NullPointerException - if mapper is null
        IllegalArgumentException - if maxConcurrency is non-positive

      • flatMap

        @CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final <R> @NonNull ParallelFlowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
 boolean delayError,
 int maxConcurrency,
 int prefetch)
        Generates and flattens Publishers on each 'rail', optionally delaying errors, having a total number of simultaneous subscriptions to the inner Publishers and using the given prefetch amount for the inner Publishers.
        Backpressure:
        The operator honors backpressure from the downstream rails and requests maxConcurrency amount from each rail upfront and keeps requesting as many items per rail as many inner sources on that rail completed. The inner sources are requested the prefetch amount upfront, then 75% of this amount requested after 75% received.
        Scheduler:
        flatMap does not operate by default on a particular Scheduler.
        Type Parameters:
        R - the result type
        Parameters:
        mapper - the function to map each rail's value into a Publisher
        delayError - should the errors from the main and the inner sources delayed till everybody terminates?
        maxConcurrency - the maximum number of simultaneous subscriptions to the generated inner Publishers
        prefetch - the number of items to prefetch from each inner Publisher
        Returns:
        the new ParallelFlowable instance
        Throws:
        NullPointerException - if mapper is null
        IllegalArgumentException - if maxConcurrency or prefetch is non-positive

      • concatMap

        @CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final <R> @NonNull ParallelFlowable<R> concatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper)
        Generates and concatenates Publishers on each 'rail', signalling errors immediately and generating 2 publishers upfront.
        Backpressure:
        The operator honors backpressure from the downstream rails and requests 2 from each rail upfront and keeps requesting 1 when the inner source complete. Requests for the inner sources are determined by the downstream rails' backpressure behavior.
        Scheduler:
        concatMap does not operate by default on a particular Scheduler.
        Type Parameters:
        R - the result type
        Parameters:
        mapper - the function to map each rail's value into a Publisher source and the inner Publishers (immediate, boundary, end)
        Returns:
        the new ParallelFlowable instance
        Throws:
        NullPointerException - if mapper is null

      • concatMap

        @CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final <R> @NonNull ParallelFlowable<R> concatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
 int prefetch)
        Generates and concatenates Publishers on each 'rail', signalling errors immediately and using the given prefetch amount for generating Publishers upfront.
        Backpressure:
        The operator honors backpressure from the downstream rails and requests the prefetch amount from each rail upfront and keeps requesting 75% of this amount after 75% received and the inner sources completed. Requests for the inner sources are determined by the downstream rails' backpressure behavior.
        Scheduler:
        concatMap does not operate by default on a particular Scheduler.
        Type Parameters:
        R - the result type
        Parameters:
        mapper - the function to map each rail's value into a Publisher
        prefetch - the number of items to prefetch from each inner Publisher source and the inner Publishers (immediate, boundary, end)
        Returns:
        the new ParallelFlowable instance
        Throws:
        NullPointerException - if mapper is null
        IllegalArgumentException - if prefetch is non-positive

      • concatMapDelayError

        @CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final <R> @NonNull ParallelFlowable<R> concatMapDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
 boolean tillTheEnd)
        Generates and concatenates Publishers on each 'rail', optionally delaying errors and generating 2 publishers upfront.
        Backpressure:
        The operator honors backpressure from the downstream rails and requests 2 from each rail upfront and keeps requesting 1 when the inner source complete. Requests for the inner sources are determined by the downstream rails' backpressure behavior.
        Scheduler:
        concatMap does not operate by default on a particular Scheduler.
        Type Parameters:
        R - the result type
        Parameters:
        mapper - the function to map each rail's value into a Publisher
        tillTheEnd - if true, all errors from the upstream and inner Publishers are delayed till all of them terminate, if false, the error is emitted when an inner Publisher terminates. source and the inner Publishers (immediate, boundary, end)
        Returns:
        the new ParallelFlowable instance
        Throws:
        NullPointerException - if mapper is null

      • concatMapDelayError

        @CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final <R> @NonNull ParallelFlowable<R> concatMapDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
 int prefetch,
 boolean tillTheEnd)
        Generates and concatenates Publishers on each 'rail', optionally delaying errors and using the given prefetch amount for generating Publishers upfront.
        Backpressure:
        The operator honors backpressure from the downstream rails and requests the prefetch amount from each rail upfront and keeps requesting 75% of this amount after 75% received and the inner sources completed. Requests for the inner sources are determined by the downstream rails' backpressure behavior.
        Scheduler:
        concatMap does not operate by default on a particular Scheduler.
        Type Parameters:
        R - the result type
        Parameters:
        mapper - the function to map each rail's value into a Publisher
        prefetch - the number of items to prefetch from each inner Publisher
        tillTheEnd - if true, all errors from the upstream and inner Publishers are delayed till all of them terminate, if false, the error is emitted when an inner Publisher terminates.
        Returns:
        the new ParallelFlowable instance
        Throws:
        NullPointerException - if mapper is null
        IllegalArgumentException - if prefetch is non-positive

      • mapOptional

        @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=PASS_THROUGH)
public final <R> @NonNull ParallelFlowable<R> mapOptional(@NonNull Function<? super T,Optional<? extends R>> mapper)
        Maps the source values on each 'rail' to an optional and emits its value if any.

        Note that the same mapper function may be called from multiple threads concurrently.

        Backpressure:
        The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.
        Scheduler:
        map does not operate by default on a particular Scheduler.
        Type Parameters:
        R - the output value type
        Parameters:
        mapper - the mapper function turning Ts into optional of Rs.
        Returns:
        the new ParallelFlowable instance
        Throws:
        NullPointerException - if mapper is null
        Since:
        3.0.0

      • mapOptional

        @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=PASS_THROUGH)
public final <R> @NonNull ParallelFlowable<R> mapOptional(@NonNull Function<? super T,Optional<? extends R>> mapper,
 @NonNull ParallelFailureHandling errorHandler)
        Maps the source values on each 'rail' to an optional and emits its value if any and handles errors based on the given ParallelFailureHandling enumeration value.

        Note that the same mapper function may be called from multiple threads concurrently.

        Backpressure:
        The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.
        Scheduler:
        map does not operate by default on a particular Scheduler.

        History: 2.0.8 - experimental

        Type Parameters:
        R - the output value type
        Parameters:
        mapper - the mapper function turning Ts into optional of Rs.
        errorHandler - the enumeration that defines how to handle errors thrown from the mapper function
        Returns:
        the new ParallelFlowable instance
        Throws:
        NullPointerException - if mapper or errorHandler is null
        Since:
        3.0.0

      • flatMapStream

        @CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull ParallelFlowable<R> flatMapStream(@NonNull Function<? super T,? extends Stream<? extends R>> mapper)
        Maps each upstream item on each rail into a Stream and emits the Stream's items to the downstream in a sequential fashion.

        Due to the blocking and sequential nature of Java Streams, the streams are mapped and consumed in a sequential fashion without interleaving (unlike a more general flatMap(Function)). Therefore, flatMapStream and concatMapStream are identical operators and are provided as aliases.

        The operator closes the Stream upon cancellation and when it terminates. The exceptions raised when closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). If a Stream should not be closed, turn it into an Iterable and use flatMapIterable(Function): 

        
 source.flatMapIterable(v -> createStream(v)::iterator);

        Note that Streams can be consumed only once; any subsequent attempt to consume a Stream will result in an IllegalStateException.

        Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()): 

        
 source.flatMapStream(v -> IntStream.rangeClosed(v + 1, v + 10).boxed());

        Stream does not support concurrent usage so creating and/or consuming the same instance multiple times from multiple threads can lead to undefined behavior.

        Backpressure:
        The operator honors the downstream backpressure and consumes the inner stream only on demand. The operator prefetches Flowable.bufferSize() items of the upstream (then 75% of it after the 75% received) and caches them until they are ready to be mapped into Streams after the current Stream has been consumed.
        Scheduler:
        flatMapStream does not operate by default on a particular Scheduler.
        Type Parameters:
        R - the element type of the Streams and the result
        Parameters:
        mapper - the function that receives an upstream item and should return a Stream whose elements will be emitted to the downstream
        Returns:
        the new ParallelFlowable instance
        Throws:
        NullPointerException - if mapper is null
        Since:
        3.0.0
        See Also:
        flatMap(Function), flatMapIterable(Function), flatMapStream(Function, int)

      • flatMapStream

        @CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull ParallelFlowable<R> flatMapStream(@NonNull Function<? super T,? extends Stream<? extends R>> mapper,
 int prefetch)
        Maps each upstream item of each rail into a Stream and emits the Stream's items to the downstream in a sequential fashion.

        Due to the blocking and sequential nature of Java Streams, the streams are mapped and consumed in a sequential fashion without interleaving (unlike a more general flatMap(Function)). Therefore, flatMapStream and concatMapStream are identical operators and are provided as aliases.

        The operator closes the Stream upon cancellation and when it terminates. The exceptions raised when closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). If a Stream should not be closed, turn it into an Iterable and use flatMapIterable(Function, int): 

        
 source.flatMapIterable(v -> createStream(v)::iterator, 32);

        Note that Streams can be consumed only once; any subsequent attempt to consume a Stream will result in an IllegalStateException.

        Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()): 

        
 source.flatMapStream(v -> IntStream.rangeClosed(v + 1, v + 10).boxed(), 32);

        Stream does not support concurrent usage so creating and/or consuming the same instance multiple times from multiple threads can lead to undefined behavior.

        Backpressure:
        The operator honors the downstream backpressure and consumes the inner stream only on demand. The operator prefetches the given amount of upstream items and caches them until they are ready to be mapped into Streams after the current Stream has been consumed.
        Scheduler:
        flatMapStream does not operate by default on a particular Scheduler.
        Type Parameters:
        R - the element type of the Streams and the result
        Parameters:
        mapper - the function that receives an upstream item and should return a Stream whose elements will be emitted to the downstream
        prefetch - the number of upstream items to request upfront, then 75% of this amount after each 75% upstream items received
        Returns:
        the new ParallelFlowable instance
        Throws:
        NullPointerException - if mapper is null
        IllegalArgumentException - if prefetch is non-positive
        Since:
        3.0.0
        See Also:
        flatMap(Function, boolean, int), flatMapIterable(Function, int)
Skip navigation links

AltStyle によって変換されたページ (->オリジナル) /