io.reactivex

Class Flowable<T>

java.lang.Object

io.reactivex.Flowable<T>

Type Parameters:

T - the type of the items emitted by the Flowable

All Implemented Interfaces:

Publisher<T>

Direct Known Subclasses:

ConnectableFlowable, FlowableProcessor, GroupedFlowable

public abstract class Flowable<T>
extends Object
implements Publisher<T>

The Flowable class that implements the Reactive Streams Pattern and offers factory methods, intermediate operators and the ability to consume reactive dataflows.

Reactive Streams operates with Publishers which Flowable extends. Many operators therefore accept general Publishers directly and allow direct interoperation with other Reactive Streams implementations.

The Flowable hosts the default buffer size of 128 elements for operators, accessible via bufferSize(), that can be overridden globally via the system parameter rx2.buffer-size. Most operators, however, have overloads that allow setting their internal buffer size explicitly.

The documentation for this class makes use of marble diagrams. The following legend explains these diagrams:

The Flowable follows the protocol

      onSubscribe onNext* (onError | onComplete)?
 

where the stream can be disposed through the Subscription instance provided to consumers through Subscriber.onSubscribe(Subscription). Unlike the Observable.subscribe() of version 1.x, subscribe(Subscriber) does not allow external cancellation of a subscription and the Subscriber instance is expected to expose such capability if needed.

Flowables support backpressure and require Subscribers to signal demand via Subscription.request(long).

Example:

 Disposable d = Flowable.just("Hello world!")
     .delay(1, TimeUnit.SECONDS)
     .subscribeWith(new DisposableSubscriber<String>() {
         @Override public void onStart() {
             System.out.println("Start!");
             request(1);
         }
         @Override public void onNext(String t) {
             System.out.println(t);
             request(1);
         }
         @Override public void onError(Throwable t) {
             t.printStackTrace();
         }
         @Override public void onComplete() {
             System.out.println("Done!");
         }
     });

 Thread.sleep(500);
 // the sequence can now be cancelled via dispose()
 d.dispose();
 

The Reactive Streams specification is relatively strict when defining interactions between Publishers and Subscribers, so much so that there is a significant performance penalty due certain timing requirements and the need to prepare for invalid request amounts via Subscription.request(long). Therefore, RxJava has introduced the FlowableSubscriber interface that indicates the consumer can be driven with relaxed rules. All RxJava operators are implemented with these relaxed rules in mind. If the subscribing Subscriber does not implement this interface, for example, due to it being from another Reactive Streams compliant library, the Flowable will automatically apply a compliance wrapper around it.

Flowable is an abstract class, but it is not advised to implement sources and custom operators by extending the class directly due to the large amounts of Reactive Streams rules to be followed to the letter. See the wiki for some guidance if such custom implementations are necessary.

The recommended way of creating custom Flowables is by using the create(FlowableOnSubscribe, BackpressureStrategy) factory method:

 Flowable<String> source = Flowable.create(new FlowableOnSubscribe<String>() {
     @Override
     public void subscribe(FlowableEmitter<String> emitter) throws Exception {

         // signal an item
         emitter.onNext("Hello");

         // could be some blocking operation
         Thread.sleep(1000);

         // the consumer might have cancelled the flow
         if (emitter.isCancelled() {
             return;
         }

         emitter.onNext("World");

         Thread.sleep(1000);

         // the end-of-sequence has to be signaled, otherwise the
         // consumers may never finish
         emitter.onComplete();
     }
 }, BackpressureStrategy.BUFFER);

 System.out.println("Subscribe!");
 
 source.subscribe(System.out::println);
 
 System.out.println("Done!");
 

RxJava reactive sources, such as Flowable, are generally synchronous and sequential in nature. In the ReactiveX design, the location (thread) where operators run is orthogonal to when the operators can work with data. This means that asynchrony and parallelism has to be explicitly expressed via operators such as subscribeOn(Scheduler), observeOn(Scheduler) and parallel(). In general, operators featuring a Scheduler parameter are introducing this type of asynchrony into the flow.

For more information see the ReactiveX documentation.

See Also:

Observable, ParallelFlowable, DisposableSubscriber

Constructor Summary

Constructors

Constructor and Description
Flowable()

Method Summary

Modifier and Type	Method and Description
Single<Boolean>	all(Predicate<? super T> predicate) Returns a Single that emits a Boolean that indicates whether all of the items emitted by the source Publisher satisfy a condition.
static <T> Flowable<T>	amb(Iterable<? extends Publisher<? extends T>> sources) Mirrors the one Publisher in an Iterable of several Publishers that first either emits an item or sends a termination notification.
static <T> Flowable<T>	ambArray(Publisher<? extends T>... sources) Mirrors the one Publisher in an array of several Publishers that first either emits an item or sends a termination notification.
Flowable<T>	ambWith(Publisher<? extends T> other) Mirrors the Publisher (current or provided) that first either emits an item or sends a termination notification.
Single<Boolean>	any(Predicate<? super T> predicate) Returns a Single that emits true if any item emitted by the source Publisher satisfies a specified condition, otherwise false.
<R> R	as(FlowableConverter<T,? extends R> converter) Calls the specified converter function during assembly time and returns its resulting value.
T	blockingFirst() Returns the first item emitted by this Flowable, or throws NoSuchElementException if it emits no items.
T	blockingFirst(T defaultItem) Returns the first item emitted by this Flowable, or a default value if it emits no items.
void	blockingForEach(Consumer<? super T> onNext) Consumes the upstream Flowable in a blocking fashion and invokes the given Consumer with each upstream item on the current thread until the upstream terminates.
Iterable<T>	blockingIterable() Converts this Flowable into an Iterable.
Iterable<T>	blockingIterable(int bufferSize) Converts this Flowable into an Iterable.
T	blockingLast() Returns the last item emitted by this Flowable, or throws NoSuchElementException if this Flowable emits no items.
T	blockingLast(T defaultItem) Returns the last item emitted by this Flowable, or a default value if it emits no items.
Iterable<T>	blockingLatest() Returns an Iterable that returns the latest item emitted by this Flowable, waiting if necessary for one to become available.
Iterable<T>	blockingMostRecent(T initialItem) Returns an Iterable that always returns the item most recently emitted by this Flowable.
Iterable<T>	blockingNext() Returns an Iterable that blocks until this Flowable emits another item, then returns that item.
T	blockingSingle() If this Flowable completes after emitting a single item, return that item, otherwise throw a NoSuchElementException.
T	blockingSingle(T defaultItem) If this Flowable completes after emitting a single item, return that item; if it emits more than one item, throw an IllegalArgumentException; if it emits no items, return a default value.
void	blockingSubscribe() Runs the source Flowable to a terminal event, ignoring any values and rethrowing any exception.
void	blockingSubscribe(Consumer<? super T> onNext) Subscribes to the source and calls the given callbacks on the current thread.
void	blockingSubscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) Subscribes to the source and calls the given callbacks on the current thread.
void	blockingSubscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) Subscribes to the source and calls the given callbacks on the current thread.
void	blockingSubscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, int bufferSize) Subscribes to the source and calls the given callbacks on the current thread.
void	blockingSubscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, int bufferSize) Subscribes to the source and calls the given callbacks on the current thread.
void	blockingSubscribe(Consumer<? super T> onNext, int bufferSize) Subscribes to the source and calls the given callbacks on the current thread.
void	blockingSubscribe(Subscriber<? super T> subscriber) Subscribes to the source and calls the Subscriber methods on the current thread.
<B> Flowable<List<T>>	buffer(Callable<? extends Publisher<B>> boundaryIndicatorSupplier) Returns a Flowable that emits buffers of items it collects from the source Publisher.
<B,U extends Collection<? super T>> Flowable<U>	buffer(Callable<? extends Publisher<B>> boundaryIndicatorSupplier, Callable<U> bufferSupplier) Returns a Flowable that emits buffers of items it collects from the source Publisher.
<TOpening,TClosing> Flowable<List<T>>	buffer(Flowable<? extends TOpening> openingIndicator, Function<? super TOpening,? extends Publisher<? extends TClosing>> closingIndicator) Returns a Flowable that emits buffers of items it collects from the source Publisher.
<TOpening,TClosing,U extends Collection<? super T>> Flowable<U>	buffer(Flowable<? extends TOpening> openingIndicator, Function<? super TOpening,? extends Publisher<? extends TClosing>> closingIndicator, Callable<U> bufferSupplier) Returns a Flowable that emits buffers of items it collects from the source Publisher.
Flowable<List<T>>	buffer(int count) Returns a Flowable that emits buffers of items it collects from the source Publisher.
<U extends Collection<? super T>> Flowable<U>	buffer(int count, Callable<U> bufferSupplier) Returns a Flowable that emits buffers of items it collects from the source Publisher.
Flowable<List<T>>	buffer(int count, int skip) Returns a Flowable that emits buffers of items it collects from the source Publisher.
<U extends Collection<? super T>> Flowable<U>	buffer(int count, int skip, Callable<U> bufferSupplier) Returns a Flowable that emits buffers of items it collects from the source Publisher.
Flowable<List<T>>	buffer(long timespan, long timeskip, TimeUnit unit) Returns a Flowable that emits buffers of items it collects from the source Publisher.
Flowable<List<T>>	buffer(long timespan, long timeskip, TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits buffers of items it collects from the source Publisher.
<U extends Collection<? super T>> Flowable<U>	buffer(long timespan, long timeskip, TimeUnit unit, Scheduler scheduler, Callable<U> bufferSupplier) Returns a Flowable that emits buffers of items it collects from the source Publisher.
Flowable<List<T>>	buffer(long timespan, TimeUnit unit) Returns a Flowable that emits buffers of items it collects from the source Publisher.
Flowable<List<T>>	buffer(long timespan, TimeUnit unit, int count) Returns a Flowable that emits buffers of items it collects from the source Publisher.
Flowable<List<T>>	buffer(long timespan, TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits buffers of items it collects from the source Publisher.
Flowable<List<T>>	buffer(long timespan, TimeUnit unit, Scheduler scheduler, int count) Returns a Flowable that emits buffers of items it collects from the source Publisher.
<U extends Collection<? super T>> Flowable<U>	buffer(long timespan, TimeUnit unit, Scheduler scheduler, int count, Callable<U> bufferSupplier, boolean restartTimerOnMaxSize) Returns a Flowable that emits buffers of items it collects from the source Publisher.
<B> Flowable<List<T>>	buffer(Publisher<B> boundaryIndicator) Returns a Flowable that emits non-overlapping buffered items from the source Publisher each time the specified boundary Publisher emits an item.
<B,U extends Collection<? super T>> Flowable<U>	buffer(Publisher<B> boundaryIndicator, Callable<U> bufferSupplier) Returns a Flowable that emits non-overlapping buffered items from the source Publisher each time the specified boundary Publisher emits an item.
<B> Flowable<List<T>>	buffer(Publisher<B> boundaryIndicator, int initialCapacity) Returns a Flowable that emits non-overlapping buffered items from the source Publisher each time the specified boundary Publisher emits an item.
static int	bufferSize() Returns the default internal buffer size used by most async operators.
Flowable<T>	cache() Returns a Flowable that subscribes to this Publisher lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.
Flowable<T>	cacheWithInitialCapacity(int initialCapacity) Returns a Flowable that subscribes to this Publisher lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.
<U> Flowable<U>	cast(Class<U> clazz) Returns a Flowable that emits the items emitted by the source Publisher, converted to the specified type.
<U> Single<U>	collect(Callable<? extends U> initialItemSupplier, BiConsumer<? super U,? super T> collector) Collects items emitted by the finite source Publisher into a single mutable data structure and returns a Single that emits this structure.
<U> Single<U>	collectInto(U initialItem, BiConsumer<? super U,? super T> collector) Collects items emitted by the finite source Publisher into a single mutable data structure and returns a Single that emits this structure.
static <T,R> Flowable<R>	combineLatest(Function<? super Object[],? extends R> combiner, Publisher<? extends T>... sources) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <T,R> Flowable<R>	combineLatest(Iterable<? extends Publisher<? extends T>> sources, Function<? super Object[],? extends R> combiner) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <T,R> Flowable<R>	combineLatest(Iterable<? extends Publisher<? extends T>> sources, Function<? super Object[],? extends R> combiner, int bufferSize) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <T,R> Flowable<R>	combineLatest(Publisher<? extends T>[] sources, Function<? super Object[],? extends R> combiner) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <T,R> Flowable<R>	combineLatest(Publisher<? extends T>[] sources, Function<? super Object[],? extends R> combiner, int bufferSize) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <T1,T2,R> Flowable<R>	combineLatest(Publisher<? extends T1> source1, Publisher<? extends T2> source2, BiFunction<? super T1,? super T2,? extends R> combiner) Combines two source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from either of the source Publishers, where this aggregation is defined by a specified function.
static <T1,T2,T3,R> Flowable<R>	combineLatest(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Function3<? super T1,? super T2,? super T3,? extends R> combiner) Combines three source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <T1,T2,T3,T4,R> Flowable<R>	combineLatest(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Function4<? super T1,? super T2,? super T3,? super T4,? extends R> combiner) Combines four source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <T1,T2,T3,T4,T5,R> Flowable<R>	combineLatest(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Publisher<? extends T5> source5, Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> combiner) Combines five source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <T1,T2,T3,T4,T5,T6,R> Flowable<R>	combineLatest(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Publisher<? extends T5> source5, Publisher<? extends T6> source6, Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> combiner) Combines six source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <T1,T2,T3,T4,T5,T6,T7,R> Flowable<R>	combineLatest(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Publisher<? extends T5> source5, Publisher<? extends T6> source6, Publisher<? extends T7> source7, Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> combiner) Combines seven source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <T1,T2,T3,T4,T5,T6,T7,T8,R> Flowable<R>	combineLatest(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Publisher<? extends T5> source5, Publisher<? extends T6> source6, Publisher<? extends T7> source7, Publisher<? extends T8> source8, Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> combiner) Combines eight source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Flowable<R>	combineLatest(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Publisher<? extends T5> source5, Publisher<? extends T6> source6, Publisher<? extends T7> source7, Publisher<? extends T8> source8, Publisher<? extends T9> source9, Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> combiner) Combines nine source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <T,R> Flowable<R>	combineLatestDelayError(Function<? super Object[],? extends R> combiner, int bufferSize, Publisher<? extends T>... sources) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publisher, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
static <T,R> Flowable<R>	combineLatestDelayError(Function<? super Object[],? extends R> combiner, Publisher<? extends T>... sources) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
static <T,R> Flowable<R>	combineLatestDelayError(Iterable<? extends Publisher<? extends T>> sources, Function<? super Object[],? extends R> combiner) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
static <T,R> Flowable<R>	combineLatestDelayError(Iterable<? extends Publisher<? extends T>> sources, Function<? super Object[],? extends R> combiner, int bufferSize) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
static <T,R> Flowable<R>	combineLatestDelayError(Publisher<? extends T>[] sources, Function<? super Object[],? extends R> combiner) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <T,R> Flowable<R>	combineLatestDelayError(Publisher<? extends T>[] sources, Function<? super Object[],? extends R> combiner, int bufferSize) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
<R> Flowable<R>	compose(FlowableTransformer<? super T,? extends R> composer) Transform a Publisher by applying a particular Transformer function to it.
static <T> Flowable<T>	concat(Iterable<? extends Publisher<? extends T>> sources) Concatenates elements of each Publisher provided via an Iterable sequence into a single sequence of elements without interleaving them.
static <T> Flowable<T>	concat(Publisher<? extends Publisher<? extends T>> sources) Returns a Flowable that emits the items emitted by each of the Publishers emitted by the source Publisher, one after the other, without interleaving them.
static <T> Flowable<T>	concat(Publisher<? extends Publisher<? extends T>> sources, int prefetch) Returns a Flowable that emits the items emitted by each of the Publishers emitted by the source Publisher, one after the other, without interleaving them.
static <T> Flowable<T>	concat(Publisher<? extends T> source1, Publisher<? extends T> source2) Returns a Flowable that emits the items emitted by two Publishers, one after the other, without interleaving them.
static <T> Flowable<T>	concat(Publisher<? extends T> source1, Publisher<? extends T> source2, Publisher<? extends T> source3) Returns a Flowable that emits the items emitted by three Publishers, one after the other, without interleaving them.
static <T> Flowable<T>	concat(Publisher<? extends T> source1, Publisher<? extends T> source2, Publisher<? extends T> source3, Publisher<? extends T> source4) Returns a Flowable that emits the items emitted by four Publishers, one after the other, without interleaving them.
static <T> Flowable<T>	concatArray(Publisher<? extends T>... sources) Concatenates a variable number of Publisher sources.
static <T> Flowable<T>	concatArrayDelayError(Publisher<? extends T>... sources) Concatenates a variable number of Publisher sources and delays errors from any of them till all terminate.
static <T> Flowable<T>	concatArrayEager(int maxConcurrency, int prefetch, Publisher<? extends T>... sources) Concatenates an array of Publishers eagerly into a single stream of values.
static <T> Flowable<T>	concatArrayEager(Publisher<? extends T>... sources) Concatenates an array of Publishers eagerly into a single stream of values.
static <T> Flowable<T>	concatArrayEagerDelayError(int maxConcurrency, int prefetch, Publisher<? extends T>... sources) Concatenates an array of Publishers eagerly into a single stream of values and delaying any errors until all sources terminate.
static <T> Flowable<T>	concatArrayEagerDelayError(Publisher<? extends T>... sources) Concatenates an array of Publishers eagerly into a single stream of values and delaying any errors until all sources terminate.
static <T> Flowable<T>	concatDelayError(Iterable<? extends Publisher<? extends T>> sources) Concatenates the Iterable sequence of Publishers into a single sequence by subscribing to each Publisher, one after the other, one at a time and delays any errors till the all inner Publishers terminate.
static <T> Flowable<T>	concatDelayError(Publisher<? extends Publisher<? extends T>> sources) Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher, one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate.
static <T> Flowable<T>	concatDelayError(Publisher<? extends Publisher<? extends T>> sources, int prefetch, boolean tillTheEnd) Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher, one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate.
static <T> Flowable<T>	concatEager(Iterable<? extends Publisher<? extends T>> sources) Concatenates a sequence of Publishers eagerly into a single stream of values.
static <T> Flowable<T>	concatEager(Iterable<? extends Publisher<? extends T>> sources, int maxConcurrency, int prefetch) Concatenates a sequence of Publishers eagerly into a single stream of values.
static <T> Flowable<T>	concatEager(Publisher<? extends Publisher<? extends T>> sources) Concatenates a Publisher sequence of Publishers eagerly into a single stream of values.
static <T> Flowable<T>	concatEager(Publisher<? extends Publisher<? extends T>> sources, int maxConcurrency, int prefetch) Concatenates a Publisher sequence of Publishers eagerly into a single stream of values.
<R> Flowable<R>	concatMap(Function<? super T,? extends Publisher<? extends R>> mapper) Returns a new Flowable that emits items resulting from applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then emitting the items that result from concatenating those resulting Publishers.
<R> Flowable<R>	concatMap(Function<? super T,? extends Publisher<? extends R>> mapper, int prefetch) Returns a new Flowable that emits items resulting from applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then emitting the items that result from concatenating those resulting Publishers.
Completable	concatMapCompletable(Function<? super T,? extends CompletableSource> mapper) Maps the upstream items into CompletableSources and subscribes to them one after the other completes.
Completable	concatMapCompletable(Function<? super T,? extends CompletableSource> mapper, int prefetch) Maps the upstream items into CompletableSources and subscribes to them one after the other completes.
Completable	concatMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper) Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, delaying all errors till both this Flowable and all inner CompletableSources terminate.
Completable	concatMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper, boolean tillTheEnd) Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both this Flowable and all inner CompletableSources terminate.
Completable	concatMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper, boolean tillTheEnd, int prefetch) Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both this Flowable and all inner CompletableSources terminate.
<R> Flowable<R>	concatMapDelayError(Function<? super T,? extends Publisher<? extends R>> mapper) Maps each of the items into a Publisher, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner Publishers till all of them terminate.
<R> Flowable<R>	concatMapDelayError(Function<? super T,? extends Publisher<? extends R>> mapper, int prefetch, boolean tillTheEnd) Maps each of the items into a Publisher, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner Publishers till all of them terminate.
<R> Flowable<R>	concatMapEager(Function<? super T,? extends Publisher<? extends R>> mapper) Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
<R> Flowable<R>	concatMapEager(Function<? super T,? extends Publisher<? extends R>> mapper, int maxConcurrency, int prefetch) Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
<R> Flowable<R>	concatMapEagerDelayError(Function<? super T,? extends Publisher<? extends R>> mapper, boolean tillTheEnd) Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
<R> Flowable<R>	concatMapEagerDelayError(Function<? super T,? extends Publisher<? extends R>> mapper, int maxConcurrency, int prefetch, boolean tillTheEnd) Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
<U> Flowable<U>	concatMapIterable(Function<? super T,? extends Iterable<? extends U>> mapper) Returns a Flowable that concatenate each item emitted by the source Publisher with the values in an Iterable corresponding to that item that is generated by a selector.
<U> Flowable<U>	concatMapIterable(Function<? super T,? extends Iterable<? extends U>> mapper, int prefetch) Returns a Flowable that concatenate each item emitted by the source Publisher with the values in an Iterable corresponding to that item that is generated by a selector.
<R> Flowable<R>	concatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper) Maps the upstream items into MaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either this Flowable or the current inner MaybeSource fail.
<R> Flowable<R>	concatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper, int prefetch) Maps the upstream items into MaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either this Flowable or the current inner MaybeSource fail.
<R> Flowable<R>	concatMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper) Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and delaying all errors till both this Flowable and all inner MaybeSources terminate.
<R> Flowable<R>	concatMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper, boolean tillTheEnd) Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both this Flowable and all inner MaybeSources terminate.
<R> Flowable<R>	concatMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper, boolean tillTheEnd, int prefetch) Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both this Flowable and all inner MaybeSources terminate.
<R> Flowable<R>	concatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper) Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either this Flowable or the current inner SingleSource fail.
<R> Flowable<R>	concatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper, int prefetch) Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either this Flowable or the current inner SingleSource fail.
<R> Flowable<R>	concatMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper) Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and delays all errors till both this Flowable and all inner SingleSources terminate.
<R> Flowable<R>	concatMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper, boolean tillTheEnd) Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays all errors till both this Flowable and all inner SingleSources terminate.
<R> Flowable<R>	concatMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper, boolean tillTheEnd, int prefetch) Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays errors till both this Flowable and all inner SingleSources terminate.
Flowable<T>	concatWith(CompletableSource other) Returns a Flowable that emits items from this Flowable and when it completes normally, the other CompletableSource is subscribed to and the returned Flowable emits its terminal events.
Flowable<T>	concatWith(MaybeSource<? extends T> other) Returns a Flowable that emits the items from this Flowable followed by the success item or terminal events of the other MaybeSource.
Flowable<T>	concatWith(Publisher<? extends T> other) Returns a Flowable that emits the items emitted from the current Publisher, then the next, one after the other, without interleaving them.
Flowable<T>	concatWith(SingleSource<? extends T> other) Returns a Flowable that emits the items from this Flowable followed by the success item or error event of the other SingleSource.
Single<Boolean>	contains(Object item) Returns a Single that emits a Boolean that indicates whether the source Publisher emitted a specified item.
Single<Long>	count() Returns a Single that counts the total number of items emitted by the source Publisher and emits this count as a 64-bit Long.
static <T> Flowable<T>	create(FlowableOnSubscribe<T> source, BackpressureStrategy mode) Provides an API (via a cold Flowable) that bridges the reactive world with the callback-style, generally non-backpressured world.
<U> Flowable<T>	debounce(Function<? super T,? extends Publisher<U>> debounceIndicator) Returns a Flowable that mirrors the source Publisher, except that it drops items emitted by the source Publisher that are followed by another item within a computed debounce duration.
Flowable<T>	debounce(long timeout, TimeUnit unit) Returns a Flowable that mirrors the source Publisher, except that it drops items emitted by the source Publisher that are followed by newer items before a timeout value expires.
Flowable<T>	debounce(long timeout, TimeUnit unit, Scheduler scheduler) Returns a Flowable that mirrors the source Publisher, except that it drops items emitted by the source Publisher that are followed by newer items before a timeout value expires on a specified Scheduler.
Flowable<T>	defaultIfEmpty(T defaultItem) Returns a Flowable that emits the items emitted by the source Publisher or a specified default item if the source Publisher is empty.
static <T> Flowable<T>	defer(Callable<? extends Publisher<? extends T>> supplier) Returns a Flowable that calls a Publisher factory to create a Publisher for each new Subscriber that subscribes.
<U> Flowable<T>	delay(Function<? super T,? extends Publisher<U>> itemDelayIndicator) Returns a Flowable that delays the emissions of the source Publisher via another Publisher on a per-item basis.
Flowable<T>	delay(long delay, TimeUnit unit) Returns a Flowable that emits the items emitted by the source Publisher shifted forward in time by a specified delay.
Flowable<T>	delay(long delay, TimeUnit unit, boolean delayError) Returns a Flowable that emits the items emitted by the source Publisher shifted forward in time by a specified delay.
Flowable<T>	delay(long delay, TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits the items emitted by the source Publisher shifted forward in time by a specified delay.
Flowable<T>	delay(long delay, TimeUnit unit, Scheduler scheduler, boolean delayError) Returns a Flowable that emits the items emitted by the source Publisher shifted forward in time by a specified delay.
<U,V> Flowable<T>	delay(Publisher<U> subscriptionIndicator, Function<? super T,? extends Publisher<V>> itemDelayIndicator) Returns a Flowable that delays the subscription to and emissions from the source Publisher via another Publisher on a per-item basis.
Flowable<T>	delaySubscription(long delay, TimeUnit unit) Returns a Flowable that delays the subscription to the source Publisher by a given amount of time.
Flowable<T>	delaySubscription(long delay, TimeUnit unit, Scheduler scheduler) Returns a Flowable that delays the subscription to the source Publisher by a given amount of time, both waiting and subscribing on a given Scheduler.
<U> Flowable<T>	delaySubscription(Publisher<U> subscriptionIndicator) Returns a Flowable that delays the subscription to this Publisher until the other Publisher emits an element or completes normally.
<T2> Flowable<T2>	dematerialize() Deprecated. in 2.2.4; inherently type-unsafe as it overrides the output generic type. Use dematerialize(Function) instead.
<R> Flowable<R>	dematerialize(Function<? super T,Notification<R>> selector) Returns a Flowable that reverses the effect of materialize by transforming the Notification objects extracted from the source items via a selector function into their respective Subscriber signal types.
Flowable<T>	distinct() Returns a Flowable that emits all items emitted by the source Publisher that are distinct based on Object.equals(Object) comparison.
<K> Flowable<T>	distinct(Function<? super T,K> keySelector) Returns a Flowable that emits all items emitted by the source Publisher that are distinct according to a key selector function and based on Object.equals(Object) comparison of the objects returned by the key selector function.
<K> Flowable<T>	distinct(Function<? super T,K> keySelector, Callable<? extends Collection<? super K>> collectionSupplier) Returns a Flowable that emits all items emitted by the source Publisher that are distinct according to a key selector function and based on Object.equals(Object) comparison of the objects returned by the key selector function.
Flowable<T>	distinctUntilChanged() Returns a Flowable that emits all items emitted by the source Publisher that are distinct from their immediate predecessors based on Object.equals(Object) comparison.
Flowable<T>	distinctUntilChanged(BiPredicate<? super T,? super T> comparer) Returns a Flowable that emits all items emitted by the source Publisher that are distinct from their immediate predecessors when compared with each other via the provided comparator function.
<K> Flowable<T>	distinctUntilChanged(Function<? super T,K> keySelector) Returns a Flowable that emits all items emitted by the source Publisher that are distinct from their immediate predecessors, according to a key selector function and based on Object.equals(Object) comparison of those objects returned by the key selector function.
Flowable<T>	doAfterNext(Consumer<? super T> onAfterNext) Calls the specified consumer with the current item after this item has been emitted to the downstream.
Flowable<T>	doAfterTerminate(Action onAfterTerminate) Registers an Action to be called when this Publisher invokes either onComplete or onError.
Flowable<T>	doFinally(Action onFinally) Calls the specified action after this Flowable signals onError or onCompleted or gets canceled by the downstream.
Flowable<T>	doOnCancel(Action onCancel) Calls the cancel Action if the downstream cancels the sequence.
Flowable<T>	doOnComplete(Action onComplete) Modifies the source Publisher so that it invokes an action when it calls onComplete.
Flowable<T>	doOnEach(Consumer<? super Notification<T>> onNotification) Modifies the source Publisher so that it invokes an action for each item it emits.
Flowable<T>	doOnEach(Subscriber<? super T> subscriber) Modifies the source Publisher so that it notifies a Subscriber for each item and terminal event it emits.
Flowable<T>	doOnError(Consumer<? super Throwable> onError) Modifies the source Publisher so that it invokes an action if it calls onError.
Flowable<T>	doOnLifecycle(Consumer<? super Subscription> onSubscribe, LongConsumer onRequest, Action onCancel) Calls the appropriate onXXX method (shared between all Subscribers) for the lifecycle events of the sequence (subscription, cancellation, requesting).
Flowable<T>	doOnNext(Consumer<? super T> onNext) Modifies the source Publisher so that it invokes an action when it calls onNext.
Flowable<T>	doOnRequest(LongConsumer onRequest) Modifies the source Publisher so that it invokes the given action when it receives a request for more items.
Flowable<T>	doOnSubscribe(Consumer<? super Subscription> onSubscribe) Modifies the source Publisher so that it invokes the given action when it is subscribed from its subscribers.
Flowable<T>	doOnTerminate(Action onTerminate) Modifies the source Publisher so that it invokes an action when it calls onComplete or onError.
Maybe<T>	elementAt(long index) Returns a Maybe that emits the single item at a specified index in a sequence of emissions from this Flowable or completes if this Flowable sequence has fewer elements than index.
Single<T>	elementAt(long index, T defaultItem) Returns a Single that emits the item found at a specified index in a sequence of emissions from this Flowable, or a default item if that index is out of range.
Single<T>	elementAtOrError(long index) Returns a Single that emits the item found at a specified index in a sequence of emissions from this Flowable or signals a NoSuchElementException if this Flowable has fewer elements than index.
static <T> Flowable<T>	empty() Returns a Flowable that emits no items to the Subscriber and immediately invokes its onComplete method.
static <T> Flowable<T>	error(Callable<? extends Throwable> supplier) Returns a Flowable that invokes a Subscriber's onError method when the Subscriber subscribes to it.
static <T> Flowable<T>	error(Throwable throwable) Returns a Flowable that invokes a Subscriber's onError method when the Subscriber subscribes to it.
Flowable<T>	filter(Predicate<? super T> predicate) Filters items emitted by a Publisher by only emitting those that satisfy a specified predicate.
Single<T>	first(T defaultItem) Returns a Single that emits only the very first item emitted by this Flowable, or a default item if this Flowable completes without emitting anything.
Maybe<T>	firstElement() Returns a Maybe that emits only the very first item emitted by this Flowable or completes if this Flowable is empty.
Single<T>	firstOrError() Returns a Single that emits only the very first item emitted by this Flowable or signals a NoSuchElementException if this Flowable is empty.
<R> Flowable<R>	flatMap(Function<? super T,? extends Publisher<? extends R>> mapper) Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger.
<R> Flowable<R>	flatMap(Function<? super T,? extends Publisher<? extends R>> mapper, boolean delayErrors) Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger.
<R> Flowable<R>	flatMap(Function<? super T,? extends Publisher<? extends R>> mapper, boolean delayErrors, int maxConcurrency) Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Publishers.
<R> Flowable<R>	flatMap(Function<? super T,? extends Publisher<? extends R>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize) Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Publishers.
<R> Flowable<R>	flatMap(Function<? super T,? extends Publisher<? extends R>> onNextMapper, Function<? super Throwable,? extends Publisher<? extends R>> onErrorMapper, Callable<? extends Publisher<? extends R>> onCompleteSupplier) Returns a Flowable that applies a function to each item emitted or notification raised by the source Publisher and then flattens the Publishers returned from these functions and emits the resulting items.
<R> Flowable<R>	flatMap(Function<? super T,? extends Publisher<? extends R>> onNextMapper, Function<Throwable,? extends Publisher<? extends R>> onErrorMapper, Callable<? extends Publisher<? extends R>> onCompleteSupplier, int maxConcurrency) Returns a Flowable that applies a function to each item emitted or notification raised by the source Publisher and then flattens the Publishers returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to these Publishers.
<R> Flowable<R>	flatMap(Function<? super T,? extends Publisher<? extends R>> mapper, int maxConcurrency) Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Publishers.
<U,R> Flowable<R>	flatMap(Function<? super T,? extends Publisher<? extends U>> mapper, BiFunction<? super T,? super U,? extends R> combiner) Returns a Flowable that emits the results of a specified function to the pair of values emitted by the source Publisher and a specified collection Publisher.
<U,R> Flowable<R>	flatMap(Function<? super T,? extends Publisher<? extends U>> mapper, BiFunction<? super T,? super U,? extends R> combiner, boolean delayErrors) Returns a Flowable that emits the results of a specified function to the pair of values emitted by the source Publisher and a specified collection Publisher.
<U,R> Flowable<R>	flatMap(Function<? super T,? extends Publisher<? extends U>> mapper, BiFunction<? super T,? super U,? extends R> combiner, boolean delayErrors, int maxConcurrency) Returns a Flowable that emits the results of a specified function to the pair of values emitted by the source Publisher and a specified collection Publisher, while limiting the maximum number of concurrent subscriptions to these Publishers.
<U,R> Flowable<R>	flatMap(Function<? super T,? extends Publisher<? extends U>> mapper, BiFunction<? super T,? super U,? extends R> combiner, boolean delayErrors, int maxConcurrency, int bufferSize) Returns a Flowable that emits the results of a specified function to the pair of values emitted by the source Publisher and a specified collection Publisher, while limiting the maximum number of concurrent subscriptions to these Publishers.
<U,R> Flowable<R>	flatMap(Function<? super T,? extends Publisher<? extends U>> mapper, BiFunction<? super T,? super U,? extends R> combiner, int maxConcurrency) Returns a Flowable that emits the results of a specified function to the pair of values emitted by the source Publisher and a specified collection Publisher, while limiting the maximum number of concurrent subscriptions to these Publishers.
Completable	flatMapCompletable(Function<? super T,? extends CompletableSource> mapper) Maps each element of the upstream Flowable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete.
Completable	flatMapCompletable(Function<? super T,? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency) Maps each element of the upstream Flowable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete, optionally delaying all errors.
<U> Flowable<U>	flatMapIterable(Function<? super T,? extends Iterable<? extends U>> mapper) Returns a Flowable that merges each item emitted by the source Publisher with the values in an Iterable corresponding to that item that is generated by a selector.
<U,V> Flowable<V>	flatMapIterable(Function<? super T,? extends Iterable<? extends U>> mapper, BiFunction<? super T,? super U,? extends V> resultSelector) Returns a Flowable that emits the results of applying a function to the pair of values from the source Publisher and an Iterable corresponding to that item that is generated by a selector.
<U,V> Flowable<V>	flatMapIterable(Function<? super T,? extends Iterable<? extends U>> mapper, BiFunction<? super T,? super U,? extends V> resultSelector, int prefetch) Returns a Flowable that merges each item emitted by the source Publisher with the values in an Iterable corresponding to that item that is generated by a selector, while limiting the number of concurrent subscriptions to these Publishers.
<U> Flowable<U>	flatMapIterable(Function<? super T,? extends Iterable<? extends U>> mapper, int bufferSize) Returns a Flowable that merges each item emitted by the source Publisher with the values in an Iterable corresponding to that item that is generated by a selector.
<R> Flowable<R>	flatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper) Maps each element of the upstream Flowable into MaybeSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Flowable sequence.
<R> Flowable<R>	flatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper, boolean delayErrors, int maxConcurrency) Maps each element of the upstream Flowable into MaybeSources, subscribes to at most maxConcurrency MaybeSources at a time and merges their onSuccess values, in no particular order, into a single Flowable sequence, optionally delaying all errors.
<R> Flowable<R>	flatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper) Maps each element of the upstream Flowable into SingleSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Flowable sequence.
<R> Flowable<R>	flatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper, boolean delayErrors, int maxConcurrency) Maps each element of the upstream Flowable into SingleSources, subscribes to at most maxConcurrency SingleSources at a time and merges their onSuccess values, in no particular order, into a single Flowable sequence, optionally delaying all errors.
Disposable	forEach(Consumer<? super T> onNext) Subscribes to the Publisher and receives notifications for each element.
Disposable	forEachWhile(Predicate<? super T> onNext) Subscribes to the Publisher and receives notifications for each element until the onNext Predicate returns false.
Disposable	forEachWhile(Predicate<? super T> onNext, Consumer<? super Throwable> onError) Subscribes to the Publisher and receives notifications for each element and error events until the onNext Predicate returns false.
Disposable	forEachWhile(Predicate<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) Subscribes to the Publisher and receives notifications for each element and the terminal events until the onNext Predicate returns false.
static <T> Flowable<T>	fromArray(T... items) Converts an Array into a Publisher that emits the items in the Array.
static <T> Flowable<T>	fromCallable(Callable<? extends T> supplier) Returns a Flowable that, when a Subscriber subscribes to it, invokes a function you specify and then emits the value returned from that function.
static <T> Flowable<T>	fromFuture(Future<? extends T> future) Converts a Future into a Publisher.
static <T> Flowable<T>	fromFuture(Future<? extends T> future, long timeout, TimeUnit unit) Converts a Future into a Publisher, with a timeout on the Future.
static <T> Flowable<T>	fromFuture(Future<? extends T> future, long timeout, TimeUnit unit, Scheduler scheduler) Converts a Future into a Publisher, with a timeout on the Future.
static <T> Flowable<T>	fromFuture(Future<? extends T> future, Scheduler scheduler) Converts a Future, operating on a specified Scheduler, into a Publisher.
static <T> Flowable<T>	fromIterable(Iterable<? extends T> source) Converts an Iterable sequence into a Publisher that emits the items in the sequence.
static <T> Flowable<T>	fromPublisher(Publisher<? extends T> source) Converts an arbitrary Reactive Streams Publisher into a Flowable if not already a Flowable.
static <T,S> Flowable<T>	generate(Callable<S> initialState, BiConsumer<S,Emitter<T>> generator) Returns a cold, synchronous, stateful and backpressure-aware generator of values.
static <T,S> Flowable<T>	generate(Callable<S> initialState, BiConsumer<S,Emitter<T>> generator, Consumer<? super S> disposeState) Returns a cold, synchronous, stateful and backpressure-aware generator of values.
static <T,S> Flowable<T>	generate(Callable<S> initialState, BiFunction<S,Emitter<T>,S> generator) Returns a cold, synchronous, stateful and backpressure-aware generator of values.
static <T,S> Flowable<T>	generate(Callable<S> initialState, BiFunction<S,Emitter<T>,S> generator, Consumer<? super S> disposeState) Returns a cold, synchronous, stateful and backpressure-aware generator of values.
static <T> Flowable<T>	generate(Consumer<Emitter<T>> generator) Returns a cold, synchronous, stateless and backpressure-aware generator of values.
<K> Flowable<GroupedFlowable<K,T>>	groupBy(Function<? super T,? extends K> keySelector) Groups the items emitted by a Publisher according to a specified criterion, and emits these grouped items as GroupedFlowables.
<K> Flowable<GroupedFlowable<K,T>>	groupBy(Function<? super T,? extends K> keySelector, boolean delayError) Groups the items emitted by a Publisher according to a specified criterion, and emits these grouped items as GroupedFlowables.
<K,V> Flowable<GroupedFlowable<K,V>>	groupBy(Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector) Groups the items emitted by a Publisher according to a specified criterion, and emits these grouped items as GroupedFlowables.
<K,V> Flowable<GroupedFlowable<K,V>>	groupBy(Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector, boolean delayError) Groups the items emitted by a Publisher according to a specified criterion, and emits these grouped items as GroupedFlowables.
<K,V> Flowable<GroupedFlowable<K,V>>	groupBy(Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector, boolean delayError, int bufferSize) Groups the items emitted by a Publisher according to a specified criterion, and emits these grouped items as GroupedFlowables.
<K,V> Flowable<GroupedFlowable<K,V>>	groupBy(Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector, boolean delayError, int bufferSize, Function<? super Consumer<Object>,? extends Map<K,Object>> evictingMapFactory) Groups the items emitted by a Publisher according to a specified criterion, and emits these grouped items as GroupedFlowables.
<TRight,TLeftEnd,TRightEnd,R> Flowable<R>	groupJoin(Publisher<? extends TRight> other, Function<? super T,? extends Publisher<TLeftEnd>> leftEnd, Function<? super TRight,? extends Publisher<TRightEnd>> rightEnd, BiFunction<? super T,? super Flowable<TRight>,? extends R> resultSelector) Returns a Flowable that correlates two Publishers when they overlap in time and groups the results.
Flowable<T>	hide() Hides the identity of this Flowable and its Subscription.
Completable	ignoreElements() Ignores all items emitted by the source Publisher and only calls onComplete or onError.
static Flowable<Long>	interval(long initialDelay, long period, TimeUnit unit) Returns a Flowable that emits a 0L after the initialDelay and ever-increasing numbers after each period of time thereafter.
static Flowable<Long>	interval(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits a 0L after the initialDelay and ever-increasing numbers after each period of time thereafter, on a specified Scheduler.
static Flowable<Long>	interval(long period, TimeUnit unit) Returns a Flowable that emits a sequential number every specified interval of time.
static Flowable<Long>	interval(long period, TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits a sequential number every specified interval of time, on a specified Scheduler.
static Flowable<Long>	intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit) Signals a range of long values, the first after some initial delay and the rest periodically after.
static Flowable<Long>	intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit, Scheduler scheduler) Signals a range of long values, the first after some initial delay and the rest periodically after.
Single<Boolean>	isEmpty() Returns a Single that emits true if the source Publisher is empty, otherwise false.
<TRight,TLeftEnd,TRightEnd,R> Flowable<R>	join(Publisher<? extends TRight> other, Function<? super T,? extends Publisher<TLeftEnd>> leftEnd, Function<? super TRight,? extends Publisher<TRightEnd>> rightEnd, BiFunction<? super T,? super TRight,? extends R> resultSelector) Correlates the items emitted by two Publishers based on overlapping durations.
static <T> Flowable<T>	just(T item) Returns a Flowable that signals the given (constant reference) item and then completes.
static <T> Flowable<T>	just(T item1, T item2) Converts two items into a Publisher that emits those items.
static <T> Flowable<T>	just(T item1, T item2, T item3) Converts three items into a Publisher that emits those items.
static <T> Flowable<T>	just(T item1, T item2, T item3, T item4) Converts four items into a Publisher that emits those items.
static <T> Flowable<T>	just(T item1, T item2, T item3, T item4, T item5) Converts five items into a Publisher that emits those items.
static <T> Flowable<T>	just(T item1, T item2, T item3, T item4, T item5, T item6) Converts six items into a Publisher that emits those items.
static <T> Flowable<T>	just(T item1, T item2, T item3, T item4, T item5, T item6, T item7) Converts seven items into a Publisher that emits those items.
static <T> Flowable<T>	just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8) Converts eight items into a Publisher that emits those items.
static <T> Flowable<T>	just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9) Converts nine items into a Publisher that emits those items.
static <T> Flowable<T>	just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9, T item10) Converts ten items into a Publisher that emits those items.
Single<T>	last(T defaultItem) Returns a Single that emits only the last item emitted by this Flowable, or a default item if this Flowable completes without emitting any items.
Maybe<T>	lastElement() Returns a Maybe that emits the last item emitted by this Flowable or completes if this Flowable is empty.
Single<T>	lastOrError() Returns a Single that emits only the last item emitted by this Flowable or signals a NoSuchElementException if this Flowable is empty.
<R> Flowable<R>	lift(FlowableOperator<? extends R,? super T> lifter) This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns a Flowable which, when subscribed to, invokes the apply(Subscriber) method of the provided FlowableOperator for each individual downstream Subscriber and allows the insertion of a custom operator by accessing the downstream's Subscriber during this subscription phase and providing a new Subscriber, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.
Flowable<T>	limit(long count) Limits both the number of upstream items (after which the sequence completes) and the total downstream request amount requested from the upstream to possibly prevent the creation of excess items by the upstream.
<R> Flowable<R>	map(Function<? super T,? extends R> mapper) Returns a Flowable that applies a specified function to each item emitted by the source Publisher and emits the results of these function applications.
Flowable<Notification<T>>	materialize() Returns a Flowable that represents all of the emissions and notifications from the source Publisher into emissions marked with their original types within Notification objects.
static <T> Flowable<T>	merge(Iterable<? extends Publisher<? extends T>> sources) Flattens an Iterable of Publishers into one Publisher, without any transformation.
static <T> Flowable<T>	merge(Iterable<? extends Publisher<? extends T>> sources, int maxConcurrency) Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the number of concurrent subscriptions to these Publishers.
static <T> Flowable<T>	merge(Iterable<? extends Publisher<? extends T>> sources, int maxConcurrency, int bufferSize) Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the number of concurrent subscriptions to these Publishers.
static <T> Flowable<T>	merge(Publisher<? extends Publisher<? extends T>> sources) Flattens a Publisher that emits Publishers into a single Publisher that emits the items emitted by those Publishers, without any transformation.
static <T> Flowable<T>	merge(Publisher<? extends Publisher<? extends T>> sources, int maxConcurrency) Flattens a Publisher that emits Publishers into a single Publisher that emits the items emitted by those Publishers, without any transformation, while limiting the maximum number of concurrent subscriptions to these Publishers.
static <T> Flowable<T>	merge(Publisher<? extends T> source1, Publisher<? extends T> source2) Flattens two Publishers into a single Publisher, without any transformation.
static <T> Flowable<T>	merge(Publisher<? extends T> source1, Publisher<? extends T> source2, Publisher<? extends T> source3) Flattens three Publishers into a single Publisher, without any transformation.
static <T> Flowable<T>	merge(Publisher<? extends T> source1, Publisher<? extends T> source2, Publisher<? extends T> source3, Publisher<? extends T> source4) Flattens four Publishers into a single Publisher, without any transformation.
static <T> Flowable<T>	mergeArray(int maxConcurrency, int bufferSize, Publisher<? extends T>... sources) Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the number of concurrent subscriptions to these Publishers.
static <T> Flowable<T>	mergeArray(Publisher<? extends T>... sources) Flattens an Array of Publishers into one Publisher, without any transformation.
static <T> Flowable<T>	mergeArrayDelayError(int maxConcurrency, int bufferSize, Publisher<? extends T>... sources) Flattens an array of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
static <T> Flowable<T>	mergeArrayDelayError(Publisher<? extends T>... sources) Flattens an array of Publishers into one Flowable, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them.
static <T> Flowable<T>	mergeDelayError(Iterable<? extends Publisher<? extends T>> sources) Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them.
static <T> Flowable<T>	mergeDelayError(Iterable<? extends Publisher<? extends T>> sources, int maxConcurrency) Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
static <T> Flowable<T>	mergeDelayError(Iterable<? extends Publisher<? extends T>> sources, int maxConcurrency, int bufferSize) Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
static <T> Flowable<T>	mergeDelayError(Publisher<? extends Publisher<? extends T>> sources) Flattens a Publisher that emits Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them.
static <T> Flowable<T>	mergeDelayError(Publisher<? extends Publisher<? extends T>> sources, int maxConcurrency) Flattens a Publisher that emits Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
static <T> Flowable<T>	mergeDelayError(Publisher<? extends T> source1, Publisher<? extends T> source2) Flattens two Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them.
static <T> Flowable<T>	mergeDelayError(Publisher<? extends T> source1, Publisher<? extends T> source2, Publisher<? extends T> source3) Flattens three Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them.
static <T> Flowable<T>	mergeDelayError(Publisher<? extends T> source1, Publisher<? extends T> source2, Publisher<? extends T> source3, Publisher<? extends T> source4) Flattens four Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them.
Flowable<T>	mergeWith(CompletableSource other) Relays the items of this Flowable and completes only when the other CompletableSource completes as well.
Flowable<T>	mergeWith(MaybeSource<? extends T> other) Merges the sequence of items of this Flowable with the success value of the other MaybeSource or waits for both to complete normally if the MaybeSource is empty.
Flowable<T>	mergeWith(Publisher<? extends T> other) Flattens this and another Publisher into a single Publisher, without any transformation.
Flowable<T>	mergeWith(SingleSource<? extends T> other) Merges the sequence of items of this Flowable with the success value of the other SingleSource.
static <T> Flowable<T>	never() Returns a Flowable that never sends any items or notifications to a Subscriber.
Flowable<T>	observeOn(Scheduler scheduler) Modifies a Publisher to perform its emissions and notifications on a specified Scheduler, asynchronously with a bounded buffer of bufferSize() slots.
Flowable<T>	observeOn(Scheduler scheduler, boolean delayError) Modifies a Publisher to perform its emissions and notifications on a specified Scheduler, asynchronously with a bounded buffer and optionally delays onError notifications.
Flowable<T>	observeOn(Scheduler scheduler, boolean delayError, int bufferSize) Modifies a Publisher to perform its emissions and notifications on a specified Scheduler, asynchronously with a bounded buffer of configurable size and optionally delays onError notifications.
<U> Flowable<U>	ofType(Class<U> clazz) Filters the items emitted by a Publisher, only emitting those of the specified type.
Flowable<T>	onBackpressureBuffer() Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer these items indefinitely until they can be emitted.
Flowable<T>	onBackpressureBuffer(boolean delayError) Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer these items indefinitely until they can be emitted.
Flowable<T>	onBackpressureBuffer(int capacity) Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer up to a given amount of items until they can be emitted.
Flowable<T>	onBackpressureBuffer(int capacity, Action onOverflow) Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer up to a given amount of items until they can be emitted.
Flowable<T>	onBackpressureBuffer(int capacity, boolean delayError) Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer up to a given amount of items until they can be emitted.
Flowable<T>	onBackpressureBuffer(int capacity, boolean delayError, boolean unbounded) Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer up to a given amount of items until they can be emitted.
Flowable<T>	onBackpressureBuffer(int capacity, boolean delayError, boolean unbounded, Action onOverflow) Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer up to a given amount of items until they can be emitted.
Flowable<T>	onBackpressureBuffer(long capacity, Action onOverflow, BackpressureOverflowStrategy overflowStrategy) Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer up to a given amount of items until they can be emitted.
Flowable<T>	onBackpressureDrop() Instructs a Publisher that is emitting items faster than its Subscriber can consume them to discard, rather than emit, those items that its Subscriber is not prepared to observe.
Flowable<T>	onBackpressureDrop(Consumer<? super T> onDrop) Instructs a Publisher that is emitting items faster than its Subscriber can consume them to discard, rather than emit, those items that its Subscriber is not prepared to observe.
Flowable<T>	onBackpressureLatest() Instructs a Publisher that is emitting items faster than its Subscriber can consume them to hold onto the latest value and emit that on request.
Flowable<T>	onErrorResumeNext(Function<? super Throwable,? extends Publisher<? extends T>> resumeFunction) Instructs a Publisher to pass control to another Publisher rather than invoking onError if it encounters an error.
Flowable<T>	onErrorResumeNext(Publisher<? extends T> next) Instructs a Publisher to pass control to another Publisher rather than invoking onError if it encounters an error.
Flowable<T>	onErrorReturn(Function<? super Throwable,? extends T> valueSupplier) Instructs a Publisher to emit an item (returned by a specified function) rather than invoking onError if it encounters an error.
Flowable<T>	onErrorReturnItem(T item) Instructs a Publisher to emit an item (returned by a specified function) rather than invoking onError if it encounters an error.
Flowable<T>	onExceptionResumeNext(Publisher<? extends T> next) Instructs a Publisher to pass control to another Publisher rather than invoking onError if it encounters an Exception.
Flowable<T>	onTerminateDetach() Nulls out references to the upstream producer and downstream Subscriber if the sequence is terminated or downstream cancels.
ParallelFlowable<T>	parallel() Parallelizes the flow by creating multiple 'rails' (equal to the number of CPUs) and dispatches the upstream items to them in a round-robin fashion.
ParallelFlowable<T>	parallel(int parallelism) Parallelizes the flow by creating the specified number of 'rails' and dispatches the upstream items to them in a round-robin fashion.
ParallelFlowable<T>	parallel(int parallelism, int prefetch) Parallelizes the flow by creating the specified number of 'rails' and dispatches the upstream items to them in a round-robin fashion and uses the defined per-'rail' prefetch amount.
ConnectableFlowable<T>	publish() Returns a ConnectableFlowable, which is a variety of Publisher that waits until its connect method is called before it begins emitting items to those Subscribers that have subscribed to it.
<R> Flowable<R>	publish(Function<? super Flowable<T>,? extends Publisher<? extends R>> selector, int prefetch) Returns a Flowable that emits the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the underlying sequence.
<R> Flowable<R>	publish(Function<? super Flowable<T>,? extends Publisher<R>> selector) Returns a Flowable that emits the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the underlying sequence.
ConnectableFlowable<T>	publish(int bufferSize) Returns a ConnectableFlowable, which is a variety of Publisher that waits until its connect method is called before it begins emitting items to those Subscribers that have subscribed to it.
static Flowable<Integer>	range(int start, int count) Returns a Flowable that emits a sequence of Integers within a specified range.
static Flowable<Long>	rangeLong(long start, long count) Returns a Flowable that emits a sequence of Longs within a specified range.
Flowable<T>	rebatchRequests(int n) Requests n initially from the upstream and then 75% of n subsequently after 75% of n values have been emitted to the downstream.
Maybe<T>	reduce(BiFunction<T,T,T> reducer) Returns a Maybe that applies a specified accumulator function to the first item emitted by a source Publisher, then feeds the result of that function along with the second item emitted by the source Publisher into the same function, and so on until all items have been emitted by the finite source Publisher, and emits the final result from the final call to your function as its sole item.
<R> Single<R>	reduce(R seed, BiFunction<R,? super T,R> reducer) Returns a Single that applies a specified accumulator function to the first item emitted by a source Publisher and a specified seed value, then feeds the result of that function along with the second item emitted by a Publisher into the same function, and so on until all items have been emitted by the finite source Publisher, emitting the final result from the final call to your function as its sole item.
<R> Single<R>	reduceWith(Callable<R> seedSupplier, BiFunction<R,? super T,R> reducer) Returns a Single that applies a specified accumulator function to the first item emitted by a source Publisher and a seed value derived from calling a specified seedSupplier, then feeds the result of that function along with the second item emitted by a Publisher into the same function, and so on until all items have been emitted by the finite source Publisher, emitting the final result from the final call to your function as its sole item.
Flowable<T>	repeat() Returns a Flowable that repeats the sequence of items emitted by the source Publisher indefinitely.
Flowable<T>	repeat(long times) Returns a Flowable that repeats the sequence of items emitted by the source Publisher at most count times.
Flowable<T>	repeatUntil(BooleanSupplier stop) Returns a Flowable that repeats the sequence of items emitted by the source Publisher until the provided stop function returns true.
Flowable<T>	repeatWhen(Function<? super Flowable<Object>,? extends Publisher<?>> handler) Returns a Flowable that emits the same values as the source Publisher with the exception of an onComplete.
ConnectableFlowable<T>	replay() Returns a ConnectableFlowable that shares a single subscription to the underlying Publisher that will replay all of its items and notifications to any future Subscriber.
<R> Flowable<R>	replay(Function<? super Flowable<T>,? extends Publisher<R>> selector) Returns a Flowable that emits items that are the results of invoking a specified selector on the items emitted by a ConnectableFlowable that shares a single subscription to the source Publisher.
<R> Flowable<R>	replay(Function<? super Flowable<T>,? extends Publisher<R>> selector, int bufferSize) Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the source Publisher, replaying bufferSize notifications.
<R> Flowable<R>	replay(Function<? super Flowable<T>,? extends Publisher<R>> selector, int bufferSize, long time, TimeUnit unit) Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the source Publisher, replaying no more than bufferSize items that were emitted within a specified time window.
<R> Flowable<R>	replay(Function<? super Flowable<T>,? extends Publisher<R>> selector, int bufferSize, long time, TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the source Publisher, replaying no more than bufferSize items that were emitted within a specified time window.
<R> Flowable<R>	replay(Function<? super Flowable<T>,? extends Publisher<R>> selector, int bufferSize, Scheduler scheduler) Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the source Publisher, replaying a maximum of bufferSize items.
<R> Flowable<R>	replay(Function<? super Flowable<T>,? extends Publisher<R>> selector, long time, TimeUnit unit) Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the source Publisher, replaying all items that were emitted within a specified time window.
<R> Flowable<R>	replay(Function<? super Flowable<T>,? extends Publisher<R>> selector, long time, TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the source Publisher, replaying all items that were emitted within a specified time window.
<R> Flowable<R>	replay(Function<? super Flowable<T>,? extends Publisher<R>> selector, Scheduler scheduler) Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the source Publisher.
ConnectableFlowable<T>	replay(int bufferSize) Returns a ConnectableFlowable that shares a single subscription to the source Publisher that replays at most bufferSize items emitted by that Publisher.
ConnectableFlowable<T>	replay(int bufferSize, long time, TimeUnit unit) Returns a ConnectableFlowable that shares a single subscription to the source Publisher and replays at most bufferSize items that were emitted during a specified time window.
ConnectableFlowable<T>	replay(int bufferSize, long time, TimeUnit unit, Scheduler scheduler) Returns a ConnectableFlowable that shares a single subscription to the source Publisher and that replays a maximum of bufferSize items that are emitted within a specified time window.
ConnectableFlowable<T>	replay(int bufferSize, Scheduler scheduler) Returns a ConnectableFlowable that shares a single subscription to the source Publisher and replays at most bufferSize items emitted by that Publisher.
ConnectableFlowable<T>	replay(long time, TimeUnit unit) Returns a ConnectableFlowable that shares a single subscription to the source Publisher and replays all items emitted by that Publisher within a specified time window.
ConnectableFlowable<T>	replay(long time, TimeUnit unit, Scheduler scheduler) Returns a ConnectableFlowable that shares a single subscription to the source Publisher and replays all items emitted by that Publisher within a specified time window.
ConnectableFlowable<T>	replay(Scheduler scheduler) Returns a ConnectableFlowable that shares a single subscription to the source Publisher that will replay all of its items and notifications to any future Subscriber on the given Scheduler.
Flowable<T>	retry() Returns a Flowable that mirrors the source Publisher, resubscribing to it if it calls onError (infinite retry count).
Flowable<T>	retry(BiPredicate<? super Integer,? super Throwable> predicate) Returns a Flowable that mirrors the source Publisher, resubscribing to it if it calls onError and the predicate returns true for that specific exception and retry count.
Flowable<T>	retry(long count) Returns a Flowable that mirrors the source Publisher, resubscribing to it if it calls onError up to a specified number of retries.
Flowable<T>	retry(long times, Predicate<? super Throwable> predicate) Retries at most times or until the predicate returns false, whichever happens first.
Flowable<T>	retry(Predicate<? super Throwable> predicate) Retries the current Flowable if the predicate returns true.
Flowable<T>	retryUntil(BooleanSupplier stop) Retries until the given stop function returns true.
Flowable<T>	retryWhen(Function<? super Flowable<Throwable>,? extends Publisher<?>> handler) Returns a Flowable that emits the same values as the source Publisher with the exception of an onError.
void	safeSubscribe(Subscriber<? super T> s) Subscribes to the current Flowable and wraps the given Subscriber into a SafeSubscriber (if not already a SafeSubscriber) that deals with exceptions thrown by a misbehaving Subscriber (that doesn't follow the Reactive Streams specification).
Flowable<T>	sample(long period, TimeUnit unit) Returns a Flowable that emits the most recently emitted item (if any) emitted by the source Publisher within periodic time intervals.
Flowable<T>	sample(long period, TimeUnit unit, boolean emitLast) Returns a Flowable that emits the most recently emitted item (if any) emitted by the source Publisher within periodic time intervals and optionally emit the very last upstream item when the upstream completes.
Flowable<T>	sample(long period, TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits the most recently emitted item (if any) emitted by the source Publisher within periodic time intervals, where the intervals are defined on a particular Scheduler.
Flowable<T>	sample(long period, TimeUnit unit, Scheduler scheduler, boolean emitLast) Returns a Flowable that emits the most recently emitted item (if any) emitted by the source Publisher within periodic time intervals, where the intervals are defined on a particular Scheduler and optionally emit the very last upstream item when the upstream completes.
<U> Flowable<T>	sample(Publisher<U> sampler) Returns a Flowable that, when the specified sampler Publisher emits an item or completes, emits the most recently emitted item (if any) emitted by the source Publisher since the previous emission from the sampler Publisher.
<U> Flowable<T>	sample(Publisher<U> sampler, boolean emitLast) Returns a Flowable that, when the specified sampler Publisher emits an item or completes, emits the most recently emitted item (if any) emitted by the source Publisher since the previous emission from the sampler Publisher and optionally emit the very last upstream item when the upstream or other Publisher complete.
Flowable<T>	scan(BiFunction<T,T,T> accumulator) Returns a Flowable that applies a specified accumulator function to the first item emitted by a source Publisher, then feeds the result of that function along with the second item emitted by the source Publisher into the same function, and so on until all items have been emitted by the source Publisher, emitting the result of each of these iterations.
<R> Flowable<R>	scan(R initialValue, BiFunction<R,? super T,R> accumulator) Returns a Flowable that applies a specified accumulator function to the first item emitted by a source Publisher and a seed value, then feeds the result of that function along with the second item emitted by the source Publisher into the same function, and so on until all items have been emitted by the source Publisher, emitting the result of each of these iterations.
<R> Flowable<R>	scanWith(Callable<R> seedSupplier, BiFunction<R,? super T,R> accumulator) Returns a Flowable that applies a specified accumulator function to the first item emitted by a source Publisher and a seed value, then feeds the result of that function along with the second item emitted by the source Publisher into the same function, and so on until all items have been emitted by the source Publisher, emitting the result of each of these iterations.
static <T> Single<Boolean>	sequenceEqual(Publisher<? extends T> source1, Publisher<? extends T> source2) Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise.
static <T> Single<Boolean>	sequenceEqual(Publisher<? extends T> source1, Publisher<? extends T> source2, BiPredicate<? super T,? super T> isEqual) Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.
static <T> Single<Boolean>	sequenceEqual(Publisher<? extends T> source1, Publisher<? extends T> source2, BiPredicate<? super T,? super T> isEqual, int bufferSize) Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.
static <T> Single<Boolean>	sequenceEqual(Publisher<? extends T> source1, Publisher<? extends T> source2, int bufferSize) Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise.
Flowable<T>	serialize() Forces a Publisher's emissions and notifications to be serialized and for it to obey the Publisher contract in other ways.
Flowable<T>	share() Returns a new Publisher that multicasts (and shares a single subscription to) the original Publisher.
Single<T>	single(T defaultItem) Returns a Single that emits the single item emitted by the source Publisher, if that Publisher emits only a single item, or a default item if the source Publisher emits no items.
Maybe<T>	singleElement() Returns a Maybe that completes if this Flowable is empty, signals one item if this Flowable signals exactly one item or signals an IllegalArgumentException if this Flowable signals more than one item.
Single<T>	singleOrError() Returns a Single that emits the single item emitted by this Flowable, if this Flowable emits only a single item, otherwise if this Flowable completes without emitting any items a NoSuchElementException will be signaled and if this Flowable emits more than one item, an IllegalArgumentException will be signaled.
Flowable<T>	skip(long count) Returns a Flowable that skips the first count items emitted by the source Publisher and emits the remainder.
Flowable<T>	skip(long time, TimeUnit unit) Returns a Flowable that skips values emitted by the source Publisher before a specified time window elapses.
Flowable<T>	skip(long time, TimeUnit unit, Scheduler scheduler) Returns a Flowable that skips values emitted by the source Publisher before a specified time window on a specified Scheduler elapses.
Flowable<T>	skipLast(int count) Returns a Flowable that drops a specified number of items from the end of the sequence emitted by the source Publisher.
Flowable<T>	skipLast(long time, TimeUnit unit) Returns a Flowable that drops items emitted by the source Publisher during a specified time window before the source completes.
Flowable<T>	skipLast(long time, TimeUnit unit, boolean delayError) Returns a Flowable that drops items emitted by the source Publisher during a specified time window before the source completes.
Flowable<T>	skipLast(long time, TimeUnit unit, Scheduler scheduler) Returns a Flowable that drops items emitted by the source Publisher during a specified time window (defined on a specified scheduler) before the source completes.
Flowable<T>	skipLast(long time, TimeUnit unit, Scheduler scheduler, boolean delayError) Returns a Flowable that drops items emitted by the source Publisher during a specified time window (defined on a specified scheduler) before the source completes.
Flowable<T>	skipLast(long time, TimeUnit unit, Scheduler scheduler, boolean delayError, int bufferSize) Returns a Flowable that drops items emitted by the source Publisher during a specified time window (defined on a specified scheduler) before the source completes.
<U> Flowable<T>	skipUntil(Publisher<U> other) Returns a Flowable that skips items emitted by the source Publisher until a second Publisher emits an item.
Flowable<T>	skipWhile(Predicate<? super T> predicate) Returns a Flowable that skips all items emitted by the source Publisher as long as a specified condition holds true, but emits all further source items as soon as the condition becomes false.
Flowable<T>	sorted() Returns a Flowable that emits the events emitted by source Publisher, in a sorted order.
Flowable<T>	sorted(Comparator<? super T> sortFunction) Returns a Flowable that emits the events emitted by source Publisher, in a sorted order based on a specified comparison function.
Flowable<T>	startWith(Iterable<? extends T> items) Returns a Flowable that emits the items in a specified Iterable before it begins to emit items emitted by the source Publisher.
Flowable<T>	startWith(Publisher<? extends T> other) Returns a Flowable that emits the items in a specified Publisher before it begins to emit items emitted by the source Publisher.
Flowable<T>	startWith(T value) Returns a Flowable that emits a specified item before it begins to emit items emitted by the source Publisher.
Flowable<T>	startWithArray(T... items) Returns a Flowable that emits the specified items before it begins to emit items emitted by the source Publisher.
Disposable	subscribe() Subscribes to a Publisher and ignores onNext and onComplete emissions.
Disposable	subscribe(Consumer<? super T> onNext) Subscribes to a Publisher and provides a callback to handle the items it emits.
Disposable	subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) Subscribes to a Publisher and provides callbacks to handle the items it emits and any error notification it issues.
Disposable	subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) Subscribes to a Publisher and provides callbacks to handle the items it emits and any error or completion notification it issues.
Disposable	subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Subscription> onSubscribe) Subscribes to a Publisher and provides callbacks to handle the items it emits and any error or completion notification it issues.
void	subscribe(FlowableSubscriber<? super T> s) Establish a connection between this Flowable and the given FlowableSubscriber and start streaming events based on the demand of the FlowableSubscriber.
void	subscribe(Subscriber<? super T> s)
protected abstract void	subscribeActual(Subscriber<? super T> s) Operator implementations (both source and intermediate) should implement this method that performs the necessary business logic and handles the incoming Subscribers.
Flowable<T>	subscribeOn(Scheduler scheduler) Asynchronously subscribes Subscribers to this Publisher on the specified Scheduler.
Flowable<T>	subscribeOn(Scheduler scheduler, boolean requestOn) Asynchronously subscribes Subscribers to this Publisher on the specified Scheduler optionally reroutes requests from other threads to the same Scheduler thread.
<E extends Subscriber<? super T>> E	subscribeWith(E subscriber) Subscribes a given Subscriber (subclass) to this Flowable and returns the given Subscriber as is.
Flowable<T>	switchIfEmpty(Publisher<? extends T> other) Returns a Flowable that emits the items emitted by the source Publisher or the items of an alternate Publisher if the source Publisher is empty.
<R> Flowable<R>	switchMap(Function<? super T,? extends Publisher<? extends R>> mapper) Returns a new Publisher by applying a function that you supply to each item emitted by the source Publisher that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers.
<R> Flowable<R>	switchMap(Function<? super T,? extends Publisher<? extends R>> mapper, int bufferSize) Returns a new Publisher by applying a function that you supply to each item emitted by the source Publisher that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers.
Completable	switchMapCompletable(Function<? super T,? extends CompletableSource> mapper) Maps the upstream values into CompletableSources, subscribes to the newer one while disposing the subscription to the previous CompletableSource, thus keeping at most one active CompletableSource running.
Completable	switchMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper) Maps the upstream values into CompletableSources, subscribes to the newer one while disposing the subscription to the previous CompletableSource, thus keeping at most one active CompletableSource running and delaying any main or inner errors until all of them terminate.
<R> Flowable<R>	switchMapDelayError(Function<? super T,? extends Publisher<? extends R>> mapper) Returns a new Publisher by applying a function that you supply to each item emitted by the source Publisher that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers and delays any error until all Publishers terminate.
<R> Flowable<R>	switchMapDelayError(Function<? super T,? extends Publisher<? extends R>> mapper, int bufferSize) Returns a new Publisher by applying a function that you supply to each item emitted by the source Publisher that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers and delays any error until all Publishers terminate.
<R> Flowable<R>	switchMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper) Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available while failing immediately if this Flowable or any of the active inner MaybeSources fail.
<R> Flowable<R>	switchMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper) Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available, delaying errors from this Flowable or the inner MaybeSources until all terminate.
<R> Flowable<R>	switchMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper) Maps the upstream items into SingleSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one while failing immediately if this Flowable or any of the active inner SingleSources fail.
<R> Flowable<R>	switchMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper) Maps the upstream items into SingleSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one, delaying errors from this Flowable or the inner SingleSources until all terminate.
static <T> Flowable<T>	switchOnNext(Publisher<? extends Publisher<? extends T>> sources) Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers.
static <T> Flowable<T>	switchOnNext(Publisher<? extends Publisher<? extends T>> sources, int bufferSize) Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers.
static <T> Flowable<T>	switchOnNextDelayError(Publisher<? extends Publisher<? extends T>> sources) Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers and delays any exception until all Publishers terminate.
static <T> Flowable<T>	switchOnNextDelayError(Publisher<? extends Publisher<? extends T>> sources, int prefetch) Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers and delays any exception until all Publishers terminate.
Flowable<T>	take(long count) Returns a Flowable that emits only the first count items emitted by the source Publisher.
Flowable<T>	take(long time, TimeUnit unit) Returns a Flowable that emits those items emitted by source Publisher before a specified time runs out.
Flowable<T>	take(long time, TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits those items emitted by source Publisher before a specified time (on a specified Scheduler) runs out.
Flowable<T>	takeLast(int count) Returns a Flowable that emits at most the last count items emitted by the source Publisher.
Flowable<T>	takeLast(long count, long time, TimeUnit unit) Returns a Flowable that emits at most a specified number of items from the source Publisher that were emitted in a specified window of time before the Publisher completed.
Flowable<T>	takeLast(long count, long time, TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits at most a specified number of items from the source Publisher that were emitted in a specified window of time before the Publisher completed, where the timing information is provided by a given Scheduler.
Flowable<T>	takeLast(long count, long time, TimeUnit unit, Scheduler scheduler, boolean delayError, int bufferSize) Returns a Flowable that emits at most a specified number of items from the source Publisher that were emitted in a specified window of time before the Publisher completed, where the timing information is provided by a given Scheduler.
Flowable<T>	takeLast(long time, TimeUnit unit) Returns a Flowable that emits the items from the source Publisher that were emitted in a specified window of time before the Publisher completed.
Flowable<T>	takeLast(long time, TimeUnit unit, boolean delayError) Returns a Flowable that emits the items from the source Publisher that were emitted in a specified window of time before the Publisher completed.
Flowable<T>	takeLast(long time, TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits the items from the source Publisher that were emitted in a specified window of time before the Publisher completed, where the timing information is provided by a specified Scheduler.
Flowable<T>	takeLast(long time, TimeUnit unit, Scheduler scheduler, boolean delayError) Returns a Flowable that emits the items from the source Publisher that were emitted in a specified window of time before the Publisher completed, where the timing information is provided by a specified Scheduler.
Flowable<T>	takeLast(long time, TimeUnit unit, Scheduler scheduler, boolean delayError, int bufferSize) Returns a Flowable that emits the items from the source Publisher that were emitted in a specified window of time before the Publisher completed, where the timing information is provided by a specified Scheduler.
Flowable<T>	takeUntil(Predicate<? super T> stopPredicate) Returns a Flowable that emits items emitted by the source Publisher, checks the specified predicate for each item, and then completes when the condition is satisfied.
<U> Flowable<T>	takeUntil(Publisher<U> other) Returns a Flowable that emits the items emitted by the source Publisher until a second Publisher emits an item.
Flowable<T>	takeWhile(Predicate<? super T> predicate) Returns a Flowable that emits items emitted by the source Publisher so long as each item satisfied a specified condition, and then completes as soon as this condition is not satisfied.
TestSubscriber<T>	test() Creates a TestSubscriber that requests Long.MAX_VALUE and subscribes it to this Flowable.
TestSubscriber<T>	test(long initialRequest) Creates a TestSubscriber with the given initial request amount and subscribes it to this Flowable.
TestSubscriber<T>	test(long initialRequest, boolean cancel) Creates a TestSubscriber with the given initial request amount, optionally cancels it before the subscription and subscribes it to this Flowable.
Flowable<T>	throttleFirst(long windowDuration, TimeUnit unit) Returns a Flowable that emits only the first item emitted by the source Publisher during sequential time windows of a specified duration.
Flowable<T>	throttleFirst(long skipDuration, TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits only the first item emitted by the source Publisher during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.
Flowable<T>	throttleLast(long intervalDuration, TimeUnit unit) Returns a Flowable that emits only the last item emitted by the source Publisher during sequential time windows of a specified duration.
Flowable<T>	throttleLast(long intervalDuration, TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits only the last item emitted by the source Publisher during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.
Flowable<T>	throttleLatest(long timeout, TimeUnit unit) Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
Flowable<T>	throttleLatest(long timeout, TimeUnit unit, boolean emitLast) Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
Flowable<T>	throttleLatest(long timeout, TimeUnit unit, Scheduler scheduler) Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
Flowable<T>	throttleLatest(long timeout, TimeUnit unit, Scheduler scheduler, boolean emitLast) Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
Flowable<T>	throttleWithTimeout(long timeout, TimeUnit unit) Returns a Flowable that mirrors the source Publisher, except that it drops items emitted by the source Publisher that are followed by newer items before a timeout value expires.
Flowable<T>	throttleWithTimeout(long timeout, TimeUnit unit, Scheduler scheduler) Returns a Flowable that mirrors the source Publisher, except that it drops items emitted by the source Publisher that are followed by newer items before a timeout value expires on a specified Scheduler.
Flowable<Timed<T>>	timeInterval() Returns a Flowable that emits records of the time interval between consecutive items emitted by the source Publisher.
Flowable<Timed<T>>	timeInterval(Scheduler scheduler) Returns a Flowable that emits records of the time interval between consecutive items emitted by the source Publisher, where this interval is computed on a specified Scheduler.
Flowable<Timed<T>>	timeInterval(TimeUnit unit) Returns a Flowable that emits records of the time interval between consecutive items emitted by the source Publisher.
Flowable<Timed<T>>	timeInterval(TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits records of the time interval between consecutive items emitted by the source Publisher, where this interval is computed on a specified Scheduler.
<V> Flowable<T>	timeout(Function<? super T,? extends Publisher<V>> itemTimeoutIndicator) Returns a Flowable that mirrors the source Publisher, but notifies Subscribers of a TimeoutException if an item emitted by the source Publisher doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by a Publisher that is a function of the previous item.
<V> Flowable<T>	timeout(Function<? super T,? extends Publisher<V>> itemTimeoutIndicator, Flowable<? extends T> other) Returns a Flowable that mirrors the source Publisher, but that switches to a fallback Publisher if an item emitted by the source Publisher doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by a Publisher that is a function of the previous item.
Flowable<T>	timeout(long timeout, TimeUnit timeUnit) Returns a Flowable that mirrors the source Publisher but applies a timeout policy for each emitted item.
Flowable<T>	timeout(long timeout, TimeUnit timeUnit, Publisher<? extends T> other) Returns a Flowable that mirrors the source Publisher but applies a timeout policy for each emitted item.
Flowable<T>	timeout(long timeout, TimeUnit timeUnit, Scheduler scheduler) Returns a Flowable that mirrors the source Publisher but applies a timeout policy for each emitted item, where this policy is governed by a specified Scheduler.
Flowable<T>	timeout(long timeout, TimeUnit timeUnit, Scheduler scheduler, Publisher<? extends T> other) Returns a Flowable that mirrors the source Publisher but applies a timeout policy for each emitted item using a specified Scheduler.
<U,V> Flowable<T>	timeout(Publisher<U> firstTimeoutIndicator, Function<? super T,? extends Publisher<V>> itemTimeoutIndicator) Returns a Flowable that mirrors the source Publisher, but notifies Subscribers of a TimeoutException if either the first item emitted by the source Publisher or any subsequent item doesn't arrive within time windows defined by other Publishers.
<U,V> Flowable<T>	timeout(Publisher<U> firstTimeoutIndicator, Function<? super T,? extends Publisher<V>> itemTimeoutIndicator, Publisher<? extends T> other) Returns a Flowable that mirrors the source Publisher, but switches to a fallback Publisher if either the first item emitted by the source Publisher or any subsequent item doesn't arrive within time windows defined by other Publishers.
static Flowable<Long>	timer(long delay, TimeUnit unit) Returns a Flowable that emits 0L after a specified delay, and then completes.
static Flowable<Long>	timer(long delay, TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits 0L after a specified delay, on a specified Scheduler, and then completes.
Flowable<Timed<T>>	timestamp() Returns a Flowable that emits each item emitted by the source Publisher, wrapped in a Timed object.
Flowable<Timed<T>>	timestamp(Scheduler scheduler) Returns a Flowable that emits each item emitted by the source Publisher, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.
Flowable<Timed<T>>	timestamp(TimeUnit unit) Returns a Flowable that emits each item emitted by the source Publisher, wrapped in a Timed object.
Flowable<Timed<T>>	timestamp(TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits each item emitted by the source Publisher, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.
<R> R	to(Function<? super Flowable<T>,R> converter) Calls the specified converter function during assembly time and returns its resulting value.
Future<T>	toFuture() Returns a Future representing the only value emitted by this Flowable.
Single<List<T>>	toList() Returns a Single that emits a single item, a list composed of all the items emitted by the finite upstream source Publisher.
<U extends Collection<? super T>> Single<U>	toList(Callable<U> collectionSupplier) Returns a Single that emits a single item, a list composed of all the items emitted by the finite source Publisher.
Single<List<T>>	toList(int capacityHint) Returns a Single that emits a single item, a list composed of all the items emitted by the finite source Publisher.
<K> Single<Map<K,T>>	toMap(Function<? super T,? extends K> keySelector) Returns a Single that emits a single HashMap containing all items emitted by the finite source Publisher, mapped by the keys returned by a specified keySelector function.
<K,V> Single<Map<K,V>>	toMap(Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector) Returns a Single that emits a single HashMap containing values corresponding to items emitted by the finite source Publisher, mapped by the keys returned by a specified keySelector function.
<K,V> Single<Map<K,V>>	toMap(Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector, Callable<? extends Map<K,V>> mapSupplier) Returns a Single that emits a single Map, returned by a specified mapFactory function, that contains keys and values extracted from the items emitted by the finite source Publisher.
<K> Single<Map<K,Collection<T>>>	toMultimap(Function<? super T,? extends K> keySelector) Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the finite source Publisher keyed by a specified keySelector function.
<K,V> Single<Map<K,Collection<V>>>	toMultimap(Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector) Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a specified valueSelector function from items emitted by the finite source Publisher, keyed by a specified keySelector function.
<K,V> Single<Map<K,Collection<V>>>	toMultimap(Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector, Callable<? extends Map<K,Collection<V>>> mapSupplier, Function<? super K,? extends Collection<? super V>> collectionFactory) Returns a Single that emits a single Map, returned by a specified mapFactory function, that contains a custom collection of values, extracted by a specified valueSelector function from items emitted by the finite source Publisher, and keyed by the keySelector function.
<K,V> Single<Map<K,Collection<V>>>	toMultimap(Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector, Callable<Map<K,Collection<V>>> mapSupplier) Returns a Single that emits a single Map, returned by a specified mapFactory function, that contains an ArrayList of values, extracted by a specified valueSelector function from items emitted by the finite source Publisher and keyed by the keySelector function.
Observable<T>	toObservable() Converts the current Flowable into a non-backpressured Observable.
Single<List<T>>	toSortedList() Returns a Single that emits a list that contains the items emitted by the finite source Publisher, in a sorted order.
Single<List<T>>	toSortedList(Comparator<? super T> comparator) Returns a Single that emits a list that contains the items emitted by the finite source Publisher, in a sorted order based on a specified comparison function.
Single<List<T>>	toSortedList(Comparator<? super T> comparator, int capacityHint) Returns a Single that emits a list that contains the items emitted by the finite source Publisher, in a sorted order based on a specified comparison function.
Single<List<T>>	toSortedList(int capacityHint) Returns a Flowable that emits a list that contains the items emitted by the finite source Publisher, in a sorted order.
static <T> Flowable<T>	unsafeCreate(Publisher<T> onSubscribe) Create a Flowable by wrapping a Publisher which has to be implemented according to the Reactive Streams specification by handling backpressure and cancellation correctly; no safeguards are provided by the Flowable itself.
Flowable<T>	unsubscribeOn(Scheduler scheduler) Modifies the source Publisher so that subscribers will cancel it on a specified Scheduler.
static <T,D> Flowable<T>	using(Callable<? extends D> resourceSupplier, Function<? super D,? extends Publisher<? extends T>> sourceSupplier, Consumer<? super D> resourceDisposer) Constructs a Publisher that creates a dependent resource object which is disposed of on cancellation.
static <T,D> Flowable<T>	using(Callable<? extends D> resourceSupplier, Function<? super D,? extends Publisher<? extends T>> sourceSupplier, Consumer<? super D> resourceDisposer, boolean eager) Constructs a Publisher that creates a dependent resource object which is disposed of just before termination if you have set disposeEagerly to true and cancellation does not occur before termination.
<B> Flowable<Flowable<T>>	window(Callable<? extends Publisher<B>> boundaryIndicatorSupplier) Returns a Flowable that emits windows of items it collects from the source Publisher.
<B> Flowable<Flowable<T>>	window(Callable<? extends Publisher<B>> boundaryIndicatorSupplier, int bufferSize) Returns a Flowable that emits windows of items it collects from the source Publisher.
Flowable<Flowable<T>>	window(long count) Returns a Flowable that emits windows of items it collects from the source Publisher.
Flowable<Flowable<T>>	window(long count, long skip) Returns a Flowable that emits windows of items it collects from the source Publisher.
Flowable<Flowable<T>>	window(long count, long skip, int bufferSize) Returns a Flowable that emits windows of items it collects from the source Publisher.
Flowable<Flowable<T>>	window(long timespan, long timeskip, TimeUnit unit) Returns a Flowable that emits windows of items it collects from the source Publisher.
Flowable<Flowable<T>>	window(long timespan, long timeskip, TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits windows of items it collects from the source Publisher.
Flowable<Flowable<T>>	window(long timespan, long timeskip, TimeUnit unit, Scheduler scheduler, int bufferSize) Returns a Flowable that emits windows of items it collects from the source Publisher.
Flowable<Flowable<T>>	window(long timespan, TimeUnit unit) Returns a Flowable that emits windows of items it collects from the source Publisher.
Flowable<Flowable<T>>	window(long timespan, TimeUnit unit, long count) Returns a Flowable that emits windows of items it collects from the source Publisher.
Flowable<Flowable<T>>	window(long timespan, TimeUnit unit, long count, boolean restart) Returns a Flowable that emits windows of items it collects from the source Publisher.
Flowable<Flowable<T>>	window(long timespan, TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits windows of items it collects from the source Publisher.
Flowable<Flowable<T>>	window(long timespan, TimeUnit unit, Scheduler scheduler, long count) Returns a Flowable that emits windows of items it collects from the source Publisher.
Flowable<Flowable<T>>	window(long timespan, TimeUnit unit, Scheduler scheduler, long count, boolean restart) Returns a Flowable that emits windows of items it collects from the source Publisher.
Flowable<Flowable<T>>	window(long timespan, TimeUnit unit, Scheduler scheduler, long count, boolean restart, int bufferSize) Returns a Flowable that emits windows of items it collects from the source Publisher.
<B> Flowable<Flowable<T>>	window(Publisher<B> boundaryIndicator) Returns a Flowable that emits non-overlapping windows of items it collects from the source Publisher where the boundary of each window is determined by the items emitted from a specified boundary-governing Publisher.
<B> Flowable<Flowable<T>>	window(Publisher<B> boundaryIndicator, int bufferSize) Returns a Flowable that emits non-overlapping windows of items it collects from the source Publisher where the boundary of each window is determined by the items emitted from a specified boundary-governing Publisher.
<U,V> Flowable<Flowable<T>>	window(Publisher<U> openingIndicator, Function<? super U,? extends Publisher<V>> closingIndicator) Returns a Flowable that emits windows of items it collects from the source Publisher.
<U,V> Flowable<Flowable<T>>	window(Publisher<U> openingIndicator, Function<? super U,? extends Publisher<V>> closingIndicator, int bufferSize) Returns a Flowable that emits windows of items it collects from the source Publisher.
<R> Flowable<R>	withLatestFrom(Iterable<? extends Publisher<?>> others, Function<? super Object[],R> combiner) Combines the value emission from this Publisher with the latest emissions from the other Publishers via a function to produce the output item.
<R> Flowable<R>	withLatestFrom(Publisher<?>[] others, Function<? super Object[],R> combiner) Combines the value emission from this Publisher with the latest emissions from the other Publishers via a function to produce the output item.
<U,R> Flowable<R>	withLatestFrom(Publisher<? extends U> other, BiFunction<? super T,? super U,? extends R> combiner) Merges the specified Publisher into this Publisher sequence by using the resultSelector function only when the source Publisher (this instance) emits an item.
<T1,T2,R> Flowable<R>	withLatestFrom(Publisher<T1> source1, Publisher<T2> source2, Function3<? super T,? super T1,? super T2,R> combiner) Combines the value emission from this Publisher with the latest emissions from the other Publishers via a function to produce the output item.
<T1,T2,T3,R> Flowable<R>	withLatestFrom(Publisher<T1> source1, Publisher<T2> source2, Publisher<T3> source3, Function4<? super T,? super T1,? super T2,? super T3,R> combiner) Combines the value emission from this Publisher with the latest emissions from the other Publishers via a function to produce the output item.
<T1,T2,T3,T4,R> Flowable<R>	withLatestFrom(Publisher<T1> source1, Publisher<T2> source2, Publisher<T3> source3, Publisher<T4> source4, Function5<? super T,? super T1,? super T2,? super T3,? super T4,R> combiner) Combines the value emission from this Publisher with the latest emissions from the other Publishers via a function to produce the output item.
static <T,R> Flowable<R>	zip(Iterable<? extends Publisher<? extends T>> sources, Function<? super Object[],? extends R> zipper) Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other Publishers.
static <T,R> Flowable<R>	zip(Publisher<? extends Publisher<? extends T>> sources, Function<? super Object[],? extends R> zipper) Returns a Flowable that emits the results of a specified combiner function applied to combinations of n items emitted, in sequence, by the n Publishers emitted by a specified Publisher.
static <T1,T2,R> Flowable<R>	zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, BiFunction<? super T1,? super T2,? extends R> zipper) Returns a Flowable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other Publishers.
static <T1,T2,R> Flowable<R>	zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, BiFunction<? super T1,? super T2,? extends R> zipper, boolean delayError) Returns a Flowable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other Publishers.
static <T1,T2,R> Flowable<R>	zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, BiFunction<? super T1,? super T2,? extends R> zipper, boolean delayError, int bufferSize) Returns a Flowable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other Publishers.
static <T1,T2,T3,R> Flowable<R>	zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Function3<? super T1,? super T2,? super T3,? extends R> zipper) Returns a Flowable that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three other Publishers.
static <T1,T2,T3,T4,R> Flowable<R>	zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper) Returns a Flowable that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four other Publishers.
static <T1,T2,T3,T4,T5,R> Flowable<R>	zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Publisher<? extends T5> source5, Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper) Returns a Flowable that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five other Publishers.
static <T1,T2,T3,T4,T5,T6,R> Flowable<R>	zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Publisher<? extends T5> source5, Publisher<? extends T6> source6, Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper) Returns a Flowable that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six other Publishers.
static <T1,T2,T3,T4,T5,T6,T7,R> Flowable<R>	zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Publisher<? extends T5> source5, Publisher<? extends T6> source6, Publisher<? extends T7> source7, Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper) Returns a Flowable that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven other Publishers.
static <T1,T2,T3,T4,T5,T6,T7,T8,R> Flowable<R>	zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Publisher<? extends T5> source5, Publisher<? extends T6> source6, Publisher<? extends T7> source7, Publisher<? extends T8> source8, Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper) Returns a Flowable that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight other Publishers.
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Flowable<R>	zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Publisher<? extends T5> source5, Publisher<? extends T6> source6, Publisher<? extends T7> source7, Publisher<? extends T8> source8, Publisher<? extends T9> source9, Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper) Returns a Flowable that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine other Publishers.
static <T,R> Flowable<R>	zipArray(Function<? super Object[],? extends R> zipper, boolean delayError, int bufferSize, Publisher<? extends T>... sources) Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of other Publishers.
static <T,R> Flowable<R>	zipIterable(Iterable<? extends Publisher<? extends T>> sources, Function<? super Object[],? extends R> zipper, boolean delayError, int bufferSize) Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other Publishers.
<U,R> Flowable<R>	zipWith(Iterable<U> other, BiFunction<? super T,? super U,? extends R> zipper) Returns a Flowable that emits items that are the result of applying a specified function to pairs of values, one each from the source Publisher and a specified Iterable sequence.
<U,R> Flowable<R>	zipWith(Publisher<? extends U> other, BiFunction<? super T,? super U,? extends R> zipper) Returns a Flowable that emits items that are the result of applying a specified function to pairs of values, one each from the source Publisher and another specified Publisher.
<U,R> Flowable<R>	zipWith(Publisher<? extends U> other, BiFunction<? super T,? super U,? extends R> zipper, boolean delayError) Returns a Flowable that emits items that are the result of applying a specified function to pairs of values, one each from the source Publisher and another specified Publisher.
<U,R> Flowable<R>	zipWith(Publisher<? extends U> other, BiFunction<? super T,? super U,? extends R> zipper, boolean delayError, int bufferSize) Returns a Flowable that emits items that are the result of applying a specified function to pairs of values, one each from the source Publisher and another specified Publisher.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Flowable

public Flowable()

Method Detail

amb

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> amb(Iterable<? extends Publisher<? extends T>> sources)

Mirrors the one Publisher in an Iterable of several Publishers that first either emits an item or sends a termination notification.

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by the winning Publisher's backpressure behavior.

Scheduler:

amb does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element type

Parameters:

sources - an Iterable of Publishers sources competing to react first. A subscription to each Publisher will occur in the same order as in this Iterable.

Returns:

a Flowable that emits the same sequence as whichever of the source Publishers first emitted an item or sent a termination notification

See Also:

ReactiveX operators documentation: Amb

ambArray

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> ambArray(Publisher<? extends T>... sources)

Mirrors the one Publisher in an array of several Publishers that first either emits an item or sends a termination notification.

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by the winning Publisher's backpressure behavior.

Scheduler:

ambArray does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element type

Parameters:

sources - an array of Publisher sources competing to react first. A subscription to each Publisher will occur in the same order as in this Iterable.

Returns:

a Flowable that emits the same sequence as whichever of the source Publishers first emitted an item or sent a termination notification

See Also:

ReactiveX operators documentation: Amb

bufferSize

public static int bufferSize()

Returns the default internal buffer size used by most async operators.

The value can be overridden via system parameter rx2.buffer-size before the Flowable class is loaded.

Returns:

the default internal buffer size.

combineLatest

@SchedulerSupport(value="none")
 @CheckReturnValue
 @BackpressureSupport(value=FULL)
public static <T,R> Flowable<R> combineLatest(Publisher<? extends T>[] sources,
        Function<? super Object[],? extends R> combiner)

Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.

If the provided array of source Publishers is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.

Backpressure:

The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source Publishers

combiner - the aggregation function used to combine the items emitted by the source Publishers

Returns:

a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

@SchedulerSupport(value="none")
 @CheckReturnValue
 @BackpressureSupport(value=FULL)
public static <T,R> Flowable<R> combineLatest(Function<? super Object[],? extends R> combiner,
        Publisher<? extends T>... sources)

Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.

If there are no source Publishers provided, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.

Backpressure:

The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source Publishers

combiner - the aggregation function used to combine the items emitted by the source Publishers

Returns:

a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

@SchedulerSupport(value="none")
 @CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
public static <T,R> Flowable<R> combineLatest(Publisher<? extends T>[] sources,
        Function<? super Object[],? extends R> combiner,
        int bufferSize)

Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.

If the provided array of source Publishers is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.

Backpressure:

The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source Publishers

combiner - the aggregation function used to combine the items emitted by the source Publishers

bufferSize - the internal buffer size and prefetch amount applied to every source Flowable

Returns:

a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

@SchedulerSupport(value="none")
 @CheckReturnValue
 @BackpressureSupport(value=FULL)
public static <T,R> Flowable<R> combineLatest(Iterable<? extends Publisher<? extends T>> sources,
        Function<? super Object[],? extends R> combiner)

Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.

If the provided iterable of source Publishers is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.

Backpressure:

The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source Publishers

combiner - the aggregation function used to combine the items emitted by the source Publishers

Returns:

a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

@SchedulerSupport(value="none")
 @CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
public static <T,R> Flowable<R> combineLatest(Iterable<? extends Publisher<? extends T>> sources,
        Function<? super Object[],? extends R> combiner,
        int bufferSize)

Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.

If the provided iterable of source Publishers is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.

Backpressure:

The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source Publishers

combiner - the aggregation function used to combine the items emitted by the source Publishers

bufferSize - the internal buffer size and prefetch amount applied to every source Flowable

Returns:

a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatestDelayError

@SchedulerSupport(value="none")
 @CheckReturnValue
 @BackpressureSupport(value=FULL)
public static <T,R> Flowable<R> combineLatestDelayError(Publisher<? extends T>[] sources,
        Function<? super Object[],? extends R> combiner)

Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.

If the provided array of source Publishers is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.

Backpressure:

The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

combineLatestDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source Publishers

combiner - the aggregation function used to combine the items emitted by the source Publishers

Returns:

a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatestDelayError

@SchedulerSupport(value="none")
 @CheckReturnValue
 @BackpressureSupport(value=FULL)
public static <T,R> Flowable<R> combineLatestDelayError(Function<? super Object[],? extends R> combiner,
        Publisher<? extends T>... sources)

Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.

If there are no source Publishers provided, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.

Backpressure:

The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

combineLatestDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source Publishers

combiner - the aggregation function used to combine the items emitted by the source Publishers

Returns:

a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatestDelayError

@SchedulerSupport(value="none")
 @CheckReturnValue
 @BackpressureSupport(value=FULL)
public static <T,R> Flowable<R> combineLatestDelayError(Function<? super Object[],? extends R> combiner,
        int bufferSize,
        Publisher<? extends T>... sources)

Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publisher, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.

If there are no source Publishers provided, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.

Backpressure:

The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

combineLatestDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source Publishers

combiner - the aggregation function used to combine the items emitted by the source Publishers

bufferSize - the internal buffer size and prefetch amount applied to every source Publisher

Returns:

a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatestDelayError

@SchedulerSupport(value="none")
 @CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
public static <T,R> Flowable<R> combineLatestDelayError(Publisher<? extends T>[] sources,
        Function<? super Object[],? extends R> combiner,
        int bufferSize)

Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.

If the provided array of source Publishers is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.

Backpressure:

The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

combineLatestDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source Publishers

combiner - the aggregation function used to combine the items emitted by the source Publishers

bufferSize - the internal buffer size and prefetch amount applied to every source Flowable

Returns:

a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatestDelayError

@SchedulerSupport(value="none")
 @CheckReturnValue
 @BackpressureSupport(value=FULL)
public static <T,R> Flowable<R> combineLatestDelayError(Iterable<? extends Publisher<? extends T>> sources,
        Function<? super Object[],? extends R> combiner)

Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.

If the provided iterable of source Publishers is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.

Backpressure:

The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

combineLatestDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source Publishers

combiner - the aggregation function used to combine the items emitted by the source Publishers

Returns:

a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatestDelayError

@SchedulerSupport(value="none")
 @CheckReturnValue
 @BackpressureSupport(value=FULL)
public static <T,R> Flowable<R> combineLatestDelayError(Iterable<? extends Publisher<? extends T>> sources,
        Function<? super Object[],? extends R> combiner,
        int bufferSize)

Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.

If the provided iterable of source Publishers is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.

Backpressure:

The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

combineLatestDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source Publishers

combiner - the aggregation function used to combine the items emitted by the source Publishers

bufferSize - the internal buffer size and prefetch amount applied to every source Flowable

Returns:

a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T1,T2,R> Flowable<R> combineLatest(Publisher<? extends T1> source1,
        Publisher<? extends T2> source2,
        BiFunction<? super T1,? super T2,? extends R> combiner)

Combines two source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from either of the source Publishers, where this aggregation is defined by a specified function.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.

Backpressure:

The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

R - the combined output type

Parameters:

source1 - the first source Publisher

source2 - the second source Publisher

combiner - the aggregation function used to combine the items emitted by the source Publishers

Returns:

a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T1,T2,T3,R> Flowable<R> combineLatest(Publisher<? extends T1> source1,
        Publisher<? extends T2> source2,
        Publisher<? extends T3> source3,
        Function3<? super T1,? super T2,? super T3,? extends R> combiner)

Combines three source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.

Backpressure:

The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

T3 - the element type of the third source

R - the combined output type

Parameters:

source1 - the first source Publisher

source2 - the second source Publisher

source3 - the third source Publisher

combiner - the aggregation function used to combine the items emitted by the source Publishers

Returns:

a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,R> Flowable<R> combineLatest(Publisher<? extends T1> source1,
        Publisher<? extends T2> source2,
        Publisher<? extends T3> source3,
        Publisher<? extends T4> source4,
        Function4<? super T1,? super T2,? super T3,? super T4,? extends R> combiner)

Combines four source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.

Backpressure:

The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

T3 - the element type of the third source

T4 - the element type of the fourth source

R - the combined output type

Parameters:

source1 - the first source Publisher

source2 - the second source Publisher

source3 - the third source Publisher

source4 - the fourth source Publisher

combiner - the aggregation function used to combine the items emitted by the source Publishers

Returns:

a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,T5,R> Flowable<R> combineLatest(Publisher<? extends T1> source1,
        Publisher<? extends T2> source2,
        Publisher<? extends T3> source3,
        Publisher<? extends T4> source4,
        Publisher<? extends T5> source5,
        Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> combiner)

Combines five source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.

Backpressure:

The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

T3 - the element type of the third source

T4 - the element type of the fourth source

T5 - the element type of the fifth source

R - the combined output type

Parameters:

source1 - the first source Publisher

source2 - the second source Publisher

source3 - the third source Publisher

source4 - the fourth source Publisher

source5 - the fifth source Publisher

combiner - the aggregation function used to combine the items emitted by the source Publishers

Returns:

a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,T5,T6,R> Flowable<R> combineLatest(Publisher<? extends T1> source1,
        Publisher<? extends T2> source2,
        Publisher<? extends T3> source3,
        Publisher<? extends T4> source4,
        Publisher<? extends T5> source5,
        Publisher<? extends T6> source6,
        Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> combiner)

Combines six source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.

Backpressure:

The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

T3 - the element type of the third source

T4 - the element type of the fourth source

T5 - the element type of the fifth source

T6 - the element type of the sixth source

R - the combined output type

Parameters:

source1 - the first source Publisher

source2 - the second source Publisher

source3 - the third source Publisher

source4 - the fourth source Publisher

source5 - the fifth source Publisher

source6 - the sixth source Publisher

combiner - the aggregation function used to combine the items emitted by the source Publishers

Returns:

a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,T5,T6,T7,R> Flowable<R> combineLatest(Publisher<? extends T1> source1,
        Publisher<? extends T2> source2,
        Publisher<? extends T3> source3,
        Publisher<? extends T4> source4,
        Publisher<? extends T5> source5,
        Publisher<? extends T6> source6,
        Publisher<? extends T7> source7,
        Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> combiner)

Combines seven source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.

Backpressure:

The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

T3 - the element type of the third source

T4 - the element type of the fourth source

T5 - the element type of the fifth source

T6 - the element type of the sixth source

T7 - the element type of the seventh source

R - the combined output type

Parameters:

source1 - the first source Publisher

source2 - the second source Publisher

source3 - the third source Publisher

source4 - the fourth source Publisher

source5 - the fifth source Publisher

source6 - the sixth source Publisher

source7 - the seventh source Publisher

combiner - the aggregation function used to combine the items emitted by the source Publishers

Returns:

a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,T5,T6,T7,T8,R> Flowable<R> combineLatest(Publisher<? extends T1> source1,
        Publisher<? extends T2> source2,
        Publisher<? extends T3> source3,
        Publisher<? extends T4> source4,
        Publisher<? extends T5> source5,
        Publisher<? extends T6> source6,
        Publisher<? extends T7> source7,
        Publisher<? extends T8> source8,
        Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> combiner)

Combines eight source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.

Backpressure:

The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

T3 - the element type of the third source

T4 - the element type of the fourth source

T5 - the element type of the fifth source

T6 - the element type of the sixth source

T7 - the element type of the seventh source

T8 - the element type of the eighth source

R - the combined output type

Parameters:

source1 - the first source Publisher

source2 - the second source Publisher

source3 - the third source Publisher

source4 - the fourth source Publisher

source5 - the fifth source Publisher

source6 - the sixth source Publisher

source7 - the seventh source Publisher

source8 - the eighth source Publisher

combiner - the aggregation function used to combine the items emitted by the source Publishers

Returns:

a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Flowable<R> combineLatest(Publisher<? extends T1> source1,
        Publisher<? extends T2> source2,
        Publisher<? extends T3> source3,
        Publisher<? extends T4> source4,
        Publisher<? extends T5> source5,
        Publisher<? extends T6> source6,
        Publisher<? extends T7> source7,
        Publisher<? extends T8> source8,
        Publisher<? extends T9> source9,
        Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> combiner)

Combines nine source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.

Backpressure:

The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

T3 - the element type of the third source

T4 - the element type of the fourth source

T5 - the element type of the fifth source

T6 - the element type of the sixth source

T7 - the element type of the seventh source

T8 - the element type of the eighth source

T9 - the element type of the ninth source

R - the combined output type

Parameters:

source1 - the first source Publisher

source2 - the second source Publisher

source3 - the third source Publisher

source4 - the fourth source Publisher

source5 - the fifth source Publisher

source6 - the sixth source Publisher

source7 - the seventh source Publisher

source8 - the eighth source Publisher

source9 - the ninth source Publisher

combiner - the aggregation function used to combine the items emitted by the source Publishers

Returns:

a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

concat

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> concat(Iterable<? extends Publisher<? extends T>> sources)

Concatenates elements of each Publisher provided via an Iterable sequence into a single sequence of elements without interleaving them.

Backpressure:

The operator honors backpressure from downstream. The Publisher sources are expected to honor backpressure as well. If any of the source Publishers violate this, it may throw an IllegalStateException when the source Publisher completes.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common value type of the sources

Parameters:

sources - the Iterable sequence of Publishers

Returns:

the new Flowable instance

concat

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> concat(Publisher<? extends Publisher<? extends T>> sources)

Returns a Flowable that emits the items emitted by each of the Publishers emitted by the source Publisher, one after the other, without interleaving them.

Backpressure:

The operator honors backpressure from downstream. Both the outer and inner Publisher sources are expected to honor backpressure as well. If the outer violates this, a MissingBackpressureException is signaled. If any of the inner Publishers violates this, it may throw an IllegalStateException when an inner Publisher completes.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - a Publisher that emits Publishers

Returns:

a Flowable that emits items all of the items emitted by the Publishers emitted by Publishers, one after the other, without interleaving them

See Also:

ReactiveX operators documentation: Concat

concat

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> concat(Publisher<? extends Publisher<? extends T>> sources,
        int prefetch)

Returns a Flowable that emits the items emitted by each of the Publishers emitted by the source Publisher, one after the other, without interleaving them.

Backpressure:

The operator honors backpressure from downstream. Both the outer and inner Publisher sources are expected to honor backpressure as well. If the outer violates this, a MissingBackpressureException is signaled. If any of the inner Publishers violates this, it may throw an IllegalStateException when an inner Publisher completes.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - a Publisher that emits Publishers

prefetch - the number of Publishers to prefetch from the sources sequence.

Returns:

a Flowable that emits items all of the items emitted by the Publishers emitted by Publishers, one after the other, without interleaving them

See Also:

ReactiveX operators documentation: Concat

concat

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> concat(Publisher<? extends T> source1,
        Publisher<? extends T> source2)

Returns a Flowable that emits the items emitted by two Publishers, one after the other, without interleaving them.

Backpressure:

The operator honors backpressure from downstream. The Publisher sources are expected to honor backpressure as well. If any of the source Publishers violate this, it may throw an IllegalStateException when the source Publisher completes.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source1 - a Publisher to be concatenated

source2 - a Publisher to be concatenated

Returns:

a Flowable that emits items emitted by the two source Publishers, one after the other, without interleaving them

See Also:

ReactiveX operators documentation: Concat

concat

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> concat(Publisher<? extends T> source1,
        Publisher<? extends T> source2,
        Publisher<? extends T> source3)

Returns a Flowable that emits the items emitted by three Publishers, one after the other, without interleaving them.

Backpressure:

The operator honors backpressure from downstream. The Publisher sources are expected to honor backpressure as well. If any of the source Publishers violate this, it may throw an IllegalStateException when the source Publisher completes.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source1 - a Publisher to be concatenated

source2 - a Publisher to be concatenated

source3 - a Publisher to be concatenated

Returns:

a Flowable that emits items emitted by the three source Publishers, one after the other, without interleaving them

See Also:

ReactiveX operators documentation: Concat

concat

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> concat(Publisher<? extends T> source1,
        Publisher<? extends T> source2,
        Publisher<? extends T> source3,
        Publisher<? extends T> source4)

Returns a Flowable that emits the items emitted by four Publishers, one after the other, without interleaving them.

Backpressure:

The operator honors backpressure from downstream. The Publisher sources are expected to honor backpressure as well. If any of the source Publishers violate this, it may throw an IllegalStateException when the source Publisher completes.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source1 - a Publisher to be concatenated

source2 - a Publisher to be concatenated

source3 - a Publisher to be concatenated

source4 - a Publisher to be concatenated

Returns:

a Flowable that emits items emitted by the four source Publishers, one after the other, without interleaving them

See Also:

ReactiveX operators documentation: Concat

concatArray

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> concatArray(Publisher<? extends T>... sources)

Concatenates a variable number of Publisher sources.

Note: named this way because of overload conflict with concat(Publisher<Publisher>).

Backpressure:

The operator honors backpressure from downstream. The Publisher sources are expected to honor backpressure as well. If any of the source Publishers violate this, it may throw an IllegalStateException when the source Publisher completes.

Scheduler:

concatArray does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base value type

Parameters:

sources - the array of sources

Returns:

the new Publisher instance

Throws:

NullPointerException - if sources is null

concatArrayDelayError

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> concatArrayDelayError(Publisher<? extends T>... sources)

Concatenates a variable number of Publisher sources and delays errors from any of them till all terminate.

Backpressure:

The operator honors backpressure from downstream. The Publisher sources are expected to honor backpressure as well. If any of the source Publishers violate this, it may throw an IllegalStateException when the source Publisher completes.

Scheduler:

concatArrayDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base value type

Parameters:

sources - the array of sources

Returns:

the new Flowable instance

Throws:

NullPointerException - if sources is null

concatArrayEager

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> concatArrayEager(Publisher<? extends T>... sources)

Concatenates an array of Publishers eagerly into a single stream of values.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source Publishers. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.

Backpressure:

The operator honors backpressure from downstream. The Publisher sources are expected to honor backpressure as well. If any of the source Publishers violate this, the operator will signal a MissingBackpressureException.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - an array of Publishers that need to be eagerly concatenated

Returns:

the new Publisher instance with the specified concatenation behavior

Since:

2.0

concatArrayEager

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> concatArrayEager(int maxConcurrency,
        int prefetch,
        Publisher<? extends T>... sources)

Concatenates an array of Publishers eagerly into a single stream of values.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source Publishers. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.

Backpressure:

The operator honors backpressure from downstream. The Publisher sources are expected to honor backpressure as well. If any of the source Publishers violate this, the operator will signal a MissingBackpressureException.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - an array of Publishers that need to be eagerly concatenated

maxConcurrency - the maximum number of concurrent subscriptions at a time, Integer.MAX_VALUE is interpreted as an indication to subscribe to all sources at once

prefetch - the number of elements to prefetch from each Publisher source

Returns:

the new Publisher instance with the specified concatenation behavior

Since:

2.0

concatArrayEagerDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static <T> Flowable<T> concatArrayEagerDelayError(Publisher<? extends T>... sources)

Concatenates an array of Publishers eagerly into a single stream of values and delaying any errors until all sources terminate.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source Publishers. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.

Backpressure:

The operator honors backpressure from downstream. The Publisher sources are expected to honor backpressure as well. If any of the source Publishers violate this, the operator will signal a MissingBackpressureException.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - an array of Publishers that need to be eagerly concatenated

Returns:

the new Flowable instance with the specified concatenation behavior

Since:

2.2.1 - experimental

concatArrayEagerDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static <T> Flowable<T> concatArrayEagerDelayError(int maxConcurrency,
        int prefetch,
        Publisher<? extends T>... sources)

Concatenates an array of Publishers eagerly into a single stream of values and delaying any errors until all sources terminate.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source Publishers. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.

Backpressure:

The operator honors backpressure from downstream. The Publisher sources are expected to honor backpressure as well. If any of the source Publishers violate this, the operator will signal a MissingBackpressureException.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - an array of Publishers that need to be eagerly concatenated

maxConcurrency - the maximum number of concurrent subscriptions at a time, Integer.MAX_VALUE is interpreted as indication to subscribe to all sources at once

prefetch - the number of elements to prefetch from each Publisher source

Returns:

the new Flowable instance with the specified concatenation behavior

Since:

2.2.1 - experimental

concatDelayError

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> concatDelayError(Iterable<? extends Publisher<? extends T>> sources)

Concatenates the Iterable sequence of Publishers into a single sequence by subscribing to each Publisher, one after the other, one at a time and delays any errors till the all inner Publishers terminate.

Backpressure:

The operator honors backpressure from downstream. Both the outer and inner Publisher sources are expected to honor backpressure as well. If the outer violates this, a MissingBackpressureException is signaled. If any of the inner Publishers violates this, it may throw an IllegalStateException when an inner Publisher completes.

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable sequence of Publishers

Returns:

the new Publisher with the concatenating behavior

concatDelayError

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> concatDelayError(Publisher<? extends Publisher<? extends T>> sources)

Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher, one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate.

Backpressure:

concatDelayError fully supports backpressure.

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the Publisher sequence of Publishers

Returns:

the new Publisher with the concatenating behavior

concatDelayError

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> concatDelayError(Publisher<? extends Publisher<? extends T>> sources,
        int prefetch,
        boolean tillTheEnd)

Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher, one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate.

Backpressure:

concatDelayError fully supports backpressure.

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the Publisher sequence of Publishers

prefetch - the number of elements to prefetch from the outer Publisher

tillTheEnd - if true exceptions from the outer and all inner Publishers are delayed to the end if false, exception from the outer Publisher is delayed till the current Publisher terminates

Returns:

the new Publisher with the concatenating behavior

concatEager

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> concatEager(Publisher<? extends Publisher<? extends T>> sources)

Concatenates a Publisher sequence of Publishers eagerly into a single stream of values.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the emitted source Publishers as they are observed. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.

Backpressure:

Backpressure is honored towards the downstream and both the outer and inner Publishers are expected to support backpressure. Violating this assumption, the operator will signal MissingBackpressureException.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - a sequence of Publishers that need to be eagerly concatenated

Returns:

the new Publisher instance with the specified concatenation behavior

Since:

2.0

concatEager

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> concatEager(Publisher<? extends Publisher<? extends T>> sources,
        int maxConcurrency,
        int prefetch)

Concatenates a Publisher sequence of Publishers eagerly into a single stream of values.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the emitted source Publishers as they are observed. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.

Backpressure:

Backpressure is honored towards the downstream and both the outer and inner Publishers are expected to support backpressure. Violating this assumption, the operator will signal MissingBackpressureException.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - a sequence of Publishers that need to be eagerly concatenated

maxConcurrency - the maximum number of concurrently running inner Publishers; Integer.MAX_VALUE is interpreted as all inner Publishers can be active at the same time

prefetch - the number of elements to prefetch from each inner Publisher source

Returns:

the new Publisher instance with the specified concatenation behavior

Since:

2.0

concatEager

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> concatEager(Iterable<? extends Publisher<? extends T>> sources)

Concatenates a sequence of Publishers eagerly into a single stream of values.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source Publishers. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.

Backpressure:

Backpressure is honored towards the downstream and the inner Publishers are expected to support backpressure. Violating this assumption, the operator will signal MissingBackpressureException.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - a sequence of Publishers that need to be eagerly concatenated

Returns:

the new Publisher instance with the specified concatenation behavior

Since:

2.0

concatEager

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> concatEager(Iterable<? extends Publisher<? extends T>> sources,
        int maxConcurrency,
        int prefetch)

Concatenates a sequence of Publishers eagerly into a single stream of values.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source Publishers. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.

Backpressure:

Backpressure is honored towards the downstream and both the outer and inner Publishers are expected to support backpressure. Violating this assumption, the operator will signal MissingBackpressureException.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - a sequence of Publishers that need to be eagerly concatenated

maxConcurrency - the maximum number of concurrently running inner Publishers; Integer.MAX_VALUE is interpreted as all inner Publishers can be active at the same time

prefetch - the number of elements to prefetch from each inner Publisher source

Returns:

the new Publisher instance with the specified concatenation behavior

Since:

2.0

create

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=SPECIAL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> create(FlowableOnSubscribe<T> source,
        BackpressureStrategy mode)

Provides an API (via a cold Flowable) that bridges the reactive world with the callback-style, generally non-backpressured world.

Example:

 Flowable.<Event>create(emitter -> {
     Callback listener = new Callback() {
         @Override
         public void onEvent(Event e) {
             emitter.onNext(e);
             if (e.isLast()) {
                 emitter.onComplete();
             }
         }

         @Override
         public void onFailure(Exception e) {
             emitter.onError(e);
         }
     };

     AutoCloseable c = api.someMethod(listener);

     emitter.setCancellable(c::close);

 }, BackpressureStrategy.BUFFER);
 

You should call the FlowableEmitter onNext, onError and onComplete methods in a serialized fashion. The rest of its methods are thread-safe.

Backpressure:

The backpressure behavior is determined by the mode parameter.

Scheduler:

create does not operate by default on a particular Scheduler.

Type Parameters:

T - the element type

Parameters:

source - the emitter that is called when a Subscriber subscribes to the returned Flowable

mode - the backpressure mode to apply if the downstream Subscriber doesn't request (fast) enough

Returns:

the new Flowable instance

See Also:

FlowableOnSubscribe, BackpressureStrategy, Cancellable

defer

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> defer(Callable<? extends Publisher<? extends T>> supplier)

Returns a Flowable that calls a Publisher factory to create a Publisher for each new Subscriber that subscribes. That is, for each subscriber, the actual Publisher that subscriber observes is determined by the factory function.

The defer Subscriber allows you to defer or delay emitting items from a Publisher until such time as a Subscriber subscribes to the Publisher. This allows a Subscriber to easily obtain updates or a refreshed version of the sequence.

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by the Publisher returned by the supplier.

Scheduler:

defer does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of the items emitted by the Publisher

Parameters:

supplier - the Publisher factory function to invoke for each Subscriber that subscribes to the resulting Publisher

Returns:

a Flowable whose Subscribers' subscriptions trigger an invocation of the given Publisher factory function

See Also:

ReactiveX operators documentation: Defer

empty

@CheckReturnValue
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> empty()

Returns a Flowable that emits no items to the Subscriber and immediately invokes its onComplete method.

Backpressure:

This source doesn't produce any elements and effectively ignores downstream backpressure.

Scheduler:

empty does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of the items (ostensibly) emitted by the Publisher

Returns:

a Flowable that emits no items to the Subscriber but immediately invokes the Subscriber's onComplete method

See Also:

ReactiveX operators documentation: Empty

error

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> error(Callable<? extends Throwable> supplier)

Returns a Flowable that invokes a Subscriber's onError method when the Subscriber subscribes to it.

Backpressure:

This source doesn't produce any elements and effectively ignores downstream backpressure.

Scheduler:

error does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of the items (ostensibly) emitted by the Publisher

Parameters:

supplier - a Callable factory to return a Throwable for each individual Subscriber

Returns:

a Flowable that invokes the Subscriber's onError method when the Subscriber subscribes to it

See Also:

ReactiveX operators documentation: Throw

error

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> error(Throwable throwable)

Returns a Flowable that invokes a Subscriber's onError method when the Subscriber subscribes to it.

Backpressure:

This source doesn't produce any elements and effectively ignores downstream backpressure.

Scheduler:

error does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of the items (ostensibly) emitted by the Publisher

Parameters:

throwable - the particular Throwable to pass to onError

Returns:

a Flowable that invokes the Subscriber's onError method when the Subscriber subscribes to it

See Also:

ReactiveX operators documentation: Throw

fromArray

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> fromArray(T... items)

Converts an Array into a Publisher that emits the items in the Array.

Backpressure:

The operator honors backpressure from downstream and iterates the given array on demand (i.e., when requested).

Scheduler:

fromArray does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of items in the Array and the type of items to be emitted by the resulting Publisher

Parameters:

items - the array of elements

Returns:

a Flowable that emits each item in the source Array

See Also:

ReactiveX operators documentation: From

fromCallable

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> fromCallable(Callable<? extends T> supplier)

Returns a Flowable that, when a Subscriber subscribes to it, invokes a function you specify and then emits the value returned from that function.

This allows you to defer the execution of the function you specify until a Subscriber subscribes to the Publisher. That is to say, it makes the function "lazy."

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

fromCallable does not operate by default on a particular Scheduler.

Error handling:

If the Callable throws an exception, the respective Throwable is delivered to the downstream via Subscriber.onError(Throwable), except when the downstream has canceled this Flowable source. In this latter case, the Throwable is delivered to the global error handler via RxJavaPlugins.onError(Throwable) as an UndeliverableException.

Type Parameters:

T - the type of the item emitted by the Publisher

Parameters:

supplier - a function, the execution of which should be deferred; fromCallable will invoke this function only when a Subscriber subscribes to the Publisher that fromCallable returns

Returns:

a Flowable whose Subscribers' subscriptions trigger an invocation of the given function

Since:

2.0

See Also:

defer(Callable)

fromFuture

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> fromFuture(Future<? extends T> future)

Converts a Future into a Publisher.

You can convert any object that supports the Future interface into a Publisher that emits the return value of the Future.get() method of that object by passing the object into the from method.

Important note: This Publisher is blocking on the thread it gets subscribed on; you cannot cancel it.

Unlike 1.x, canceling the Flowable won't cancel the future. If necessary, one can use composition to achieve the cancellation effect: futurePublisher.doOnCancel(() -> future.cancel(true));.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

fromFuture does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of object that the Future returns, and also the type of item to be emitted by the resulting Publisher

Parameters:

future - the source Future

Returns:

a Flowable that emits the item from the source Future

See Also:

ReactiveX operators documentation: From

fromFuture

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> fromFuture(Future<? extends T> future,
        long timeout,
        TimeUnit unit)

Converts a Future into a Publisher, with a timeout on the Future.

You can convert any object that supports the Future interface into a Publisher that emits the return value of the Future.get() method of that object by passing the object into the fromFuture method.

Unlike 1.x, canceling the Flowable won't cancel the future. If necessary, one can use composition to achieve the cancellation effect: futurePublisher.doOnCancel(() -> future.cancel(true));.

Important note: This Publisher is blocking on the thread it gets subscribed on; you cannot cancel it.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

fromFuture does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of object that the Future returns, and also the type of item to be emitted by the resulting Publisher

Parameters:

future - the source Future

timeout - the maximum time to wait before calling get

unit - the TimeUnit of the timeout argument

Returns:

a Flowable that emits the item from the source Future

See Also:

ReactiveX operators documentation: From

fromFuture

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="custom")
public static <T> Flowable<T> fromFuture(Future<? extends T> future,
        long timeout,
        TimeUnit unit,
        Scheduler scheduler)

Converts a Future into a Publisher, with a timeout on the Future.

You can convert any object that supports the Future interface into a Publisher that emits the return value of the Future.get() method of that object by passing the object into the from method.

Unlike 1.x, canceling the Flowable won't cancel the future. If necessary, one can use composition to achieve the cancellation effect: futurePublisher.doOnCancel(() -> future.cancel(true));.

Important note: This Publisher is blocking; you cannot cancel it.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

fromFuture does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of object that the Future returns, and also the type of item to be emitted by the resulting Publisher

Parameters:

future - the source Future

timeout - the maximum time to wait before calling get

unit - the TimeUnit of the timeout argument

scheduler - the Scheduler to wait for the Future on. Use a Scheduler such as Schedulers.io() that can block and wait on the Future

Returns:

a Flowable that emits the item from the source Future

See Also:

ReactiveX operators documentation: From

fromFuture

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="custom")
public static <T> Flowable<T> fromFuture(Future<? extends T> future,
        Scheduler scheduler)

Converts a Future, operating on a specified Scheduler, into a Publisher.

You can convert any object that supports the Future interface into a Publisher that emits the return value of the Future.get() method of that object by passing the object into the from method.

Unlike 1.x, canceling the Flowable won't cancel the future. If necessary, one can use composition to achieve the cancellation effect: futurePublisher.doOnCancel(() -> future.cancel(true));.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

You specify which Scheduler this operator will use.

Type Parameters:

T - the type of object that the Future returns, and also the type of item to be emitted by the resulting Publisher

Parameters:

future - the source Future

scheduler - the Scheduler to wait for the Future on. Use a Scheduler such as Schedulers.io() that can block and wait on the Future

Returns:

a Flowable that emits the item from the source Future

See Also:

ReactiveX operators documentation: From

fromIterable

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> fromIterable(Iterable<? extends T> source)

Converts an Iterable sequence into a Publisher that emits the items in the sequence.

Backpressure:

The operator honors backpressure from downstream and iterates the given iterable on demand (i.e., when requested).

Scheduler:

fromIterable does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of items in the Iterable sequence and the type of items to be emitted by the resulting Publisher

Parameters:

source - the source Iterable sequence

Returns:

a Flowable that emits each item in the source Iterable sequence

See Also:

ReactiveX operators documentation: From

fromPublisher

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> fromPublisher(Publisher<? extends T> source)

Converts an arbitrary Reactive Streams Publisher into a Flowable if not already a Flowable.

The Publisher must follow the Reactive Streams specification. Violating the specification may result in undefined behavior.

If possible, use create(FlowableOnSubscribe, BackpressureStrategy) to create a source-like Flowable instead.

Note that even though Publisher appears to be a functional interface, it is not recommended to implement it through a lambda as the specification requires state management that is not achievable with a stateless lambda.

Backpressure:

The operator is a pass-through for backpressure and its behavior is determined by the backpressure behavior of the wrapped publisher.

Scheduler:

fromPublisher does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type of the flow

Parameters:

source - the Publisher to convert

Returns:

the new Flowable instance

Throws:

NullPointerException - if the source Publisher is null

See Also:

create(FlowableOnSubscribe, BackpressureStrategy)

generate

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> generate(Consumer<Emitter<T>> generator)

Returns a cold, synchronous, stateless and backpressure-aware generator of values.

Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, never concurrently and only while the function body is executing. Calling them from multiple threads or outside the function call is not supported and leads to an undefined behavior.

Backpressure:

The operator honors downstream backpressure.

Scheduler:

generate does not operate by default on a particular Scheduler.

Type Parameters:

T - the generated value type

Parameters:

generator - the Consumer called whenever a particular downstream Subscriber has requested a value. The callback then should call onNext, onError or onComplete to signal a value or a terminal event. Signaling multiple onNext in a call will make the operator signal IllegalStateException.

Returns:

the new Flowable instance

generate

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T,S> Flowable<T> generate(Callable<S> initialState,
        BiConsumer<S,Emitter<T>> generator)

Returns a cold, synchronous, stateful and backpressure-aware generator of values.

Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, never concurrently and only while the function body is executing. Calling them from multiple threads or outside the function call is not supported and leads to an undefined behavior.

Backpressure:

The operator honors downstream backpressure.

Scheduler:

generate does not operate by default on a particular Scheduler.

Type Parameters:

S - the type of the per-Subscriber state

T - the generated value type

Parameters:

initialState - the Callable to generate the initial state for each Subscriber

generator - the Consumer called with the current state whenever a particular downstream Subscriber has requested a value. The callback then should call onNext, onError or onComplete to signal a value or a terminal event. Signaling multiple onNext in a call will make the operator signal IllegalStateException.

Returns:

the new Flowable instance

generate

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T,S> Flowable<T> generate(Callable<S> initialState,
        BiConsumer<S,Emitter<T>> generator,
        Consumer<? super S> disposeState)

Returns a cold, synchronous, stateful and backpressure-aware generator of values.

Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, never concurrently and only while the function body is executing. Calling them from multiple threads or outside the function call is not supported and leads to an undefined behavior.

Backpressure:

The operator honors downstream backpressure.

Scheduler:

generate does not operate by default on a particular Scheduler.

Type Parameters:

S - the type of the per-Subscriber state

T - the generated value type

Parameters:

initialState - the Callable to generate the initial state for each Subscriber

generator - the Consumer called with the current state whenever a particular downstream Subscriber has requested a value. The callback then should call onNext, onError or onComplete to signal a value or a terminal event. Signaling multiple onNext in a call will make the operator signal IllegalStateException.

disposeState - the Consumer that is called with the current state when the generator terminates the sequence or it gets canceled

Returns:

the new Flowable instance

generate

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T,S> Flowable<T> generate(Callable<S> initialState,
        BiFunction<S,Emitter<T>,S> generator)

Returns a cold, synchronous, stateful and backpressure-aware generator of values.

Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, never concurrently and only while the function body is executing. Calling them from multiple threads or outside the function call is not supported and leads to an undefined behavior.

Backpressure:

The operator honors downstream backpressure.

Scheduler:

generate does not operate by default on a particular Scheduler.

Type Parameters:

S - the type of the per-Subscriber state

T - the generated value type

Parameters:

initialState - the Callable to generate the initial state for each Subscriber

generator - the Function called with the current state whenever a particular downstream Subscriber has requested a value. The callback then should call onNext, onError or onComplete to signal a value or a terminal event and should return a (new) state for the next invocation. Signaling multiple onNext in a call will make the operator signal IllegalStateException.

Returns:

the new Flowable instance

generate

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T,S> Flowable<T> generate(Callable<S> initialState,
        BiFunction<S,Emitter<T>,S> generator,
        Consumer<? super S> disposeState)

Returns a cold, synchronous, stateful and backpressure-aware generator of values.

Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, never concurrently and only while the function body is executing. Calling them from multiple threads or outside the function call is not supported and leads to an undefined behavior.

Backpressure:

The operator honors downstream backpressure.

Scheduler:

generate does not operate by default on a particular Scheduler.

Type Parameters:

S - the type of the per-Subscriber state

T - the generated value type

Parameters:

initialState - the Callable to generate the initial state for each Subscriber

generator - the Function called with the current state whenever a particular downstream Subscriber has requested a value. The callback then should call onNext, onError or onComplete to signal a value or a terminal event and should return a (new) state for the next invocation. Signaling multiple onNext in a call will make the operator signal IllegalStateException.

disposeState - the Consumer that is called with the current state when the generator terminates the sequence or it gets canceled

Returns:

the new Flowable instance

interval

@CheckReturnValue
 @BackpressureSupport(value=ERROR)
 @SchedulerSupport(value="io.reactivex:computation")
public static Flowable<Long> interval(long initialDelay,
        long period,
        TimeUnit unit)

Returns a Flowable that emits a 0L after the initialDelay and ever-increasing numbers after each period of time thereafter.

Backpressure:

The operator generates values based on time and ignores downstream backpressure which may lead to MissingBackpressureException at some point in the chain. Consumers should consider applying one of the onBackpressureXXX operators as well.

Scheduler:

interval operates by default on the computation Scheduler.

Parameters:

initialDelay - the initial delay time to wait before emitting the first value of 0L

period - the period of time between emissions of the subsequent numbers

unit - the time unit for both initialDelay and period

Returns:

a Flowable that emits a 0L after the initialDelay and ever-increasing numbers after each period of time thereafter

Since:

1.0.12

See Also:

ReactiveX operators documentation: Interval

interval

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=ERROR)
 @SchedulerSupport(value="custom")
public static Flowable<Long> interval(long initialDelay,
        long period,
        TimeUnit unit,
        Scheduler scheduler)

Returns a Flowable that emits a 0L after the initialDelay and ever-increasing numbers after each period of time thereafter, on a specified Scheduler.

Backpressure:

The operator generates values based on time and ignores downstream backpressure which may lead to MissingBackpressureException at some point in the chain. Consumers should consider applying one of the onBackpressureXXX operators as well.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

initialDelay - the initial delay time to wait before emitting the first value of 0L

period - the period of time between emissions of the subsequent numbers

unit - the time unit for both initialDelay and period

scheduler - the Scheduler on which the waiting happens and items are emitted

Returns:

a Flowable that emits a 0L after the initialDelay and ever-increasing numbers after each period of time thereafter, while running on the given Scheduler

Since:

1.0.12

See Also:

ReactiveX operators documentation: Interval

interval

@CheckReturnValue
 @BackpressureSupport(value=ERROR)
 @SchedulerSupport(value="io.reactivex:computation")
public static Flowable<Long> interval(long period,
        TimeUnit unit)

Returns a Flowable that emits a sequential number every specified interval of time.

Backpressure:

The operator signals a MissingBackpressureException if the downstream is not ready to receive the next value.

Scheduler:

interval operates by default on the computation Scheduler.

Parameters:

period - the period size in time units (see below)

unit - time units to use for the interval size

Returns:

a Flowable that emits a sequential number each time interval

See Also:

ReactiveX operators documentation: Interval

interval

@CheckReturnValue
 @BackpressureSupport(value=ERROR)
 @SchedulerSupport(value="custom")
public static Flowable<Long> interval(long period,
        TimeUnit unit,
        Scheduler scheduler)

Returns a Flowable that emits a sequential number every specified interval of time, on a specified Scheduler.

Backpressure:

The operator generates values based on time and ignores downstream backpressure which may lead to MissingBackpressureException at some point in the chain. Consumers should consider applying one of the onBackpressureXXX operators as well.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

period - the period size in time units (see below)

unit - time units to use for the interval size

scheduler - the Scheduler to use for scheduling the items

Returns:

a Flowable that emits a sequential number each time interval

See Also:

ReactiveX operators documentation: Interval

intervalRange

@CheckReturnValue
 @BackpressureSupport(value=ERROR)
 @SchedulerSupport(value="io.reactivex:computation")
public static Flowable<Long> intervalRange(long start,
        long count,
        long initialDelay,
        long period,
        TimeUnit unit)

Signals a range of long values, the first after some initial delay and the rest periodically after.

The sequence completes immediately after the last value (start + count - 1) has been reached.

Backpressure:

The operator signals a MissingBackpressureException if the downstream can't keep up.

Scheduler:

intervalRange by default operates on the computation Scheduler.

Parameters:

start - that start value of the range

count - the number of values to emit in total, if zero, the operator emits an onComplete after the initial delay.

initialDelay - the initial delay before signaling the first value (the start)

period - the period between subsequent values

unit - the unit of measure of the initialDelay and period amounts

Returns:

the new Flowable instance

intervalRange

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=ERROR)
 @SchedulerSupport(value="custom")
public static Flowable<Long> intervalRange(long start,
        long count,
        long initialDelay,
        long period,
        TimeUnit unit,
        Scheduler scheduler)

Signals a range of long values, the first after some initial delay and the rest periodically after.

The sequence completes immediately after the last value (start + count - 1) has been reached.

Backpressure:

The operator signals a MissingBackpressureException if the downstream can't keep up.

Scheduler:

you provide the Scheduler.

Parameters:

start - that start value of the range

count - the number of values to emit in total, if zero, the operator emits an onComplete after the initial delay.

initialDelay - the initial delay before signaling the first value (the start)

period - the period between subsequent values

unit - the unit of measure of the initialDelay and period amounts

scheduler - the target scheduler where the values and terminal signals will be emitted

Returns:

the new Flowable instance

just

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> just(T item)

Returns a Flowable that signals the given (constant reference) item and then completes.

Note that the item is taken and re-emitted as is and not computed by any means by just. Use fromCallable(Callable) to generate a single item on demand (when Subscribers subscribe to it).

See the multi-parameter overloads of just to emit more than one (constant reference) items one after the other. Use fromArray(Object...) to emit an arbitrary number of items that are known upfront.

To emit the items of an Iterable sequence (such as a List), use fromIterable(Iterable).

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of that item

Parameters:

item - the item to emit

Returns:

a Flowable that emits value as a single item and then completes

See Also:

ReactiveX operators documentation: Just, just(Object, Object), fromCallable(Callable), fromArray(Object...), fromIterable(Iterable)

just

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> just(T item1,
        T item2)

Converts two items into a Publisher that emits those items.

Backpressure:

The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

Returns:

a Flowable that emits each item

See Also:

ReactiveX operators documentation: Just

just

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> just(T item1,
        T item2,
        T item3)

Converts three items into a Publisher that emits those items.

Backpressure:

The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

Returns:

a Flowable that emits each item

See Also:

ReactiveX operators documentation: Just

just

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> just(T item1,
        T item2,
        T item3,
        T item4)

Converts four items into a Publisher that emits those items.

Backpressure:

The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

Returns:

a Flowable that emits each item

See Also:

ReactiveX operators documentation: Just

just

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> just(T item1,
        T item2,
        T item3,
        T item4,
        T item5)

Converts five items into a Publisher that emits those items.

Backpressure:

The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

item5 - fifth item

Returns:

a Flowable that emits each item

See Also:

ReactiveX operators documentation: Just

just

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> just(T item1,
        T item2,
        T item3,
        T item4,
        T item5,
        T item6)

Converts six items into a Publisher that emits those items.

Backpressure:

The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

item5 - fifth item

item6 - sixth item

Returns:

a Flowable that emits each item

See Also:

ReactiveX operators documentation: Just

just

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> just(T item1,
        T item2,
        T item3,
        T item4,
        T item5,
        T item6,
        T item7)

Converts seven items into a Publisher that emits those items.

Backpressure:

The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

item5 - fifth item

item6 - sixth item

item7 - seventh item

Returns:

a Flowable that emits each item

See Also:

ReactiveX operators documentation: Just

just

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> just(T item1,
        T item2,
        T item3,
        T item4,
        T item5,
        T item6,
        T item7,
        T item8)

Converts eight items into a Publisher that emits those items.

Backpressure:

The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

item5 - fifth item

item6 - sixth item

item7 - seventh item

item8 - eighth item

Returns:

a Flowable that emits each item

See Also:

ReactiveX operators documentation: Just

just

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> just(T item1,
        T item2,
        T item3,
        T item4,
        T item5,
        T item6,
        T item7,
        T item8,
        T item9)

Converts nine items into a Publisher that emits those items.

Backpressure:

The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

item5 - fifth item

item6 - sixth item

item7 - seventh item

item8 - eighth item

item9 - ninth item

Returns:

a Flowable that emits each item

See Also:

ReactiveX operators documentation: Just

just

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> just(T item1,
        T item2,
        T item3,
        T item4,
        T item5,
        T item6,
        T item7,
        T item8,
        T item9,
        T item10)

Converts ten items into a Publisher that emits those items.

Backpressure:

The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

item5 - fifth item

item6 - sixth item

item7 - seventh item

item8 - eighth item

item9 - ninth item

item10 - tenth item

Returns:

a Flowable that emits each item

See Also:

ReactiveX operators documentation: Just

merge

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> merge(Iterable<? extends Publisher<? extends T>> sources,
        int maxConcurrency,
        int bufferSize)

Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the number of concurrent subscriptions to these Publishers.

You can combine the items emitted by multiple Publishers so that they appear as a single Publisher, by using the merge method.

Backpressure:

The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

If any of the source Publishers signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source Publishers are canceled. If more than one Publisher signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Iterable, int, int) to merge sources and terminate only when all source Publishers have completed or failed with an error.

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable of Publishers

maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently

bufferSize - the number of items to prefetch from each inner Publisher

Returns:

a Flowable that emits items that are the result of flattening the items emitted by the Publishers in the Iterable

Throws:

IllegalArgumentException - if maxConcurrency is less than or equal to 0

See Also:

ReactiveX operators documentation: Merge, mergeDelayError(Iterable, int, int)

mergeArray

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> mergeArray(int maxConcurrency,
        int bufferSize,
        Publisher<? extends T>... sources)

Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the number of concurrent subscriptions to these Publishers.

You can combine the items emitted by multiple Publishers so that they appear as a single Publisher, by using the merge method.

Backpressure:

The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeArray does not operate by default on a particular Scheduler.

Error handling:

If any of the source Publishers signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source Publishers are canceled. If more than one Publisher signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. Use mergeArrayDelayError(int, int, Publisher[]) to merge sources and terminate only when all source Publishers have completed or failed with an error.

Type Parameters:

T - the common element base type

Parameters:

sources - the array of Publishers

maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently

bufferSize - the number of items to prefetch from each inner Publisher

Returns:

a Flowable that emits items that are the result of flattening the items emitted by the Publishers in the Iterable

Throws:

IllegalArgumentException - if maxConcurrency is less than or equal to 0

See Also:

ReactiveX operators documentation: Merge, mergeArrayDelayError(int, int, Publisher...)

merge

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> merge(Iterable<? extends Publisher<? extends T>> sources)

Flattens an Iterable of Publishers into one Publisher, without any transformation.

You can combine the items emitted by multiple Publishers so that they appear as a single Publisher, by using the merge method.

Backpressure:

The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

If any of the source Publishers signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source Publishers are canceled. If more than one Publisher signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Iterable) to merge sources and terminate only when all source Publishers have completed or failed with an error.

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable of Publishers

Returns:

a Flowable that emits items that are the result of flattening the items emitted by the Publishers in the Iterable

See Also:

ReactiveX operators documentation: Merge, mergeDelayError(Iterable)

merge

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> merge(Iterable<? extends Publisher<? extends T>> sources,
        int maxConcurrency)

Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the number of concurrent subscriptions to these Publishers.

You can combine the items emitted by multiple Publishers so that they appear as a single Publisher, by using the merge method.

Backpressure:

The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

If any of the source Publishers signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source Publishers are canceled. If more than one Publisher signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Iterable, int) to merge sources and terminate only when all source Publishers have completed or failed with an error.

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable of Publishers

maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently

Returns:

a Flowable that emits items that are the result of flattening the items emitted by the Publishers in the Iterable

Throws:

IllegalArgumentException - if maxConcurrency is less than or equal to 0

See Also:

ReactiveX operators documentation: Merge, mergeDelayError(Iterable, int)

merge

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> merge(Publisher<? extends Publisher<? extends T>> sources)

Flattens a Publisher that emits Publishers into a single Publisher that emits the items emitted by those Publishers, without any transformation.

You can combine the items emitted by multiple Publishers so that they appear as a single Publisher, by using the merge method.

Backpressure:

The operator honors backpressure from downstream. The outer Publisher is consumed in unbounded mode (i.e., no backpressure is applied to it). The inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

If any of the source Publishers signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source Publishers are canceled. If more than one Publisher signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Publisher) to merge sources and terminate only when all source Publishers have completed or failed with an error.

Type Parameters:

T - the common element base type

Parameters:

sources - a Publisher that emits Publishers

Returns:

a Flowable that emits items that are the result of flattening the Publishers emitted by the source Publisher

See Also:

ReactiveX operators documentation: Merge, mergeDelayError(Publisher)

merge

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> merge(Publisher<? extends Publisher<? extends T>> sources,
        int maxConcurrency)

Flattens a Publisher that emits Publishers into a single Publisher that emits the items emitted by those Publishers, without any transformation, while limiting the maximum number of concurrent subscriptions to these Publishers.

You can combine the items emitted by multiple Publishers so that they appear as a single Publisher, by using the merge method.

Backpressure:

The operator honors backpressure from downstream. Both the outer and inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

If any of the source Publishers signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source Publishers are canceled. If more than one Publisher signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Publisher, int) to merge sources and terminate only when all source Publishers have completed or failed with an error.

Type Parameters:

T - the common element base type

Parameters:

sources - a Publisher that emits Publishers

maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently

Returns:

a Flowable that emits items that are the result of flattening the Publishers emitted by the source Publisher

Throws:

IllegalArgumentException - if maxConcurrency is less than or equal to 0

Since:

1.1.0

See Also:

ReactiveX operators documentation: Merge, mergeDelayError(Publisher, int)

mergeArray

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> mergeArray(Publisher<? extends T>... sources)

Flattens an Array of Publishers into one Publisher, without any transformation.

You can combine items emitted by multiple Publishers so that they appear as a single Publisher, by using the merge method.

Backpressure:

The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeArray does not operate by default on a particular Scheduler.

Error handling:

If any of the source Publishers signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source Publishers are canceled. If more than one Publisher signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. Use mergeArrayDelayError(Publisher...) to merge sources and terminate only when all source Publishers have completed or failed with an error.

Type Parameters:

T - the common element base type

Parameters:

sources - the array of Publishers

Returns:

a Flowable that emits all of the items emitted by the Publishers in the Array

See Also:

ReactiveX operators documentation: Merge, mergeArrayDelayError(Publisher...)

merge

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> merge(Publisher<? extends T> source1,
        Publisher<? extends T> source2)

Flattens two Publishers into a single Publisher, without any transformation.

You can combine items emitted by multiple Publishers so that they appear as a single Publisher, by using the merge method.

Backpressure:

The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

If any of the source Publishers signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source Publishers are canceled. If more than one Publisher signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Publisher, Publisher) to merge sources and terminate only when all source Publishers have completed or failed with an error.

Type Parameters:

T - the common element base type

Parameters:

source1 - a Publisher to be merged

source2 - a Publisher to be merged

Returns:

a Flowable that emits all of the items emitted by the source Publishers

See Also:

ReactiveX operators documentation: Merge, mergeDelayError(Publisher, Publisher)

merge

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> merge(Publisher<? extends T> source1,
        Publisher<? extends T> source2,
        Publisher<? extends T> source3)

Flattens three Publishers into a single Publisher, without any transformation.

You can combine items emitted by multiple Publishers so that they appear as a single Publisher, by using the merge method.

Backpressure:

The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

If any of the source Publishers signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source Publishers are canceled. If more than one Publisher signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Publisher, Publisher, Publisher) to merge sources and terminate only when all source Publishers have completed or failed with an error.

Type Parameters:

T - the common element base type

Parameters:

source1 - a Publisher to be merged

source2 - a Publisher to be merged

source3 - a Publisher to be merged

Returns:

a Flowable that emits all of the items emitted by the source Publishers

See Also:

ReactiveX operators documentation: Merge, mergeDelayError(Publisher, Publisher, Publisher)

merge

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> merge(Publisher<? extends T> source1,
        Publisher<? extends T> source2,
        Publisher<? extends T> source3,
        Publisher<? extends T> source4)

Flattens four Publishers into a single Publisher, without any transformation.

You can combine items emitted by multiple Publishers so that they appear as a single Publisher, by using the merge method.

Backpressure:

The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

If any of the source Publishers signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source Publishers are canceled. If more than one Publisher signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Publisher, Publisher, Publisher, Publisher) to merge sources and terminate only when all source Publishers have completed or failed with an error.

Type Parameters:

T - the common element base type

Parameters:

source1 - a Publisher to be merged

source2 - a Publisher to be merged

source3 - a Publisher to be merged

source4 - a Publisher to be merged

Returns:

a Flowable that emits all of the items emitted by the source Publishers

See Also:

ReactiveX operators documentation: Merge, mergeDelayError(Publisher, Publisher, Publisher, Publisher)

mergeDelayError

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> mergeDelayError(Iterable<? extends Publisher<? extends T>> sources)

Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them.

This behaves like merge(Publisher) except that if any of the merged Publishers notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.

Even if multiple merged Publishers send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.

Backpressure:

The operator honors backpressure from downstream. All inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable of Publishers

Returns:

a Flowable that emits items that are the result of flattening the items emitted by the Publishers in the Iterable

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> mergeDelayError(Iterable<? extends Publisher<? extends T>> sources,
        int maxConcurrency,
        int bufferSize)

Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.

This behaves like merge(Publisher) except that if any of the merged Publishers notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.

Even if multiple merged Publishers send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.

Backpressure:

The operator honors backpressure from downstream. All inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable of Publishers

maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently

bufferSize - the number of items to prefetch from each inner Publisher

Returns:

a Flowable that emits items that are the result of flattening the items emitted by the Publishers in the Iterable

See Also:

ReactiveX operators documentation: Merge

mergeArrayDelayError

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> mergeArrayDelayError(int maxConcurrency,
        int bufferSize,
        Publisher<? extends T>... sources)

Flattens an array of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.

This behaves like merge(Publisher) except that if any of the merged Publishers notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.

Even if multiple merged Publishers send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.

Backpressure:

The operator honors backpressure from downstream. All source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeArrayDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the array of Publishers

maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently

bufferSize - the number of items to prefetch from each inner Publisher

Returns:

a Flowable that emits items that are the result of flattening the items emitted by the Publishers in the Iterable

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> mergeDelayError(Iterable<? extends Publisher<? extends T>> sources,
        int maxConcurrency)

Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.

This behaves like merge(Publisher) except that if any of the merged Publishers notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.

Even if multiple merged Publishers send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.

Backpressure:

The operator honors backpressure from downstream. All inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable of Publishers

maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently

Returns:

a Flowable that emits items that are the result of flattening the items emitted by the Publishers in the Iterable

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> mergeDelayError(Publisher<? extends Publisher<? extends T>> sources)

Flattens a Publisher that emits Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them.

This behaves like merge(Publisher) except that if any of the merged Publishers notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.

Even if multiple merged Publishers send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.

Backpressure:

The operator honors backpressure from downstream. The outer Publisher is consumed in unbounded mode (i.e., no backpressure is applied to it). The inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - a Publisher that emits Publishers

Returns:

a Flowable that emits all of the items emitted by the Publishers emitted by the source Publisher

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> mergeDelayError(Publisher<? extends Publisher<? extends T>> sources,
        int maxConcurrency)

Flattens a Publisher that emits Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.

This behaves like merge(Publisher) except that if any of the merged Publishers notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.

Even if multiple merged Publishers send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.

Backpressure:

The operator honors backpressure from downstream. Both the outer and inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - a Publisher that emits Publishers

maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently

Returns:

a Flowable that emits all of the items emitted by the Publishers emitted by the source Publisher

Since:

2.0

See Also:

ReactiveX operators documentation: Merge

mergeArrayDelayError

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> mergeArrayDelayError(Publisher<? extends T>... sources)

Flattens an array of Publishers into one Flowable, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them.

This behaves like merge(Publisher) except that if any of the merged Publishers notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.

Even if multiple merged Publishers send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.

Backpressure:

The operator honors backpressure from downstream. Both the outer and inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeArrayDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable of Publishers

Returns:

a Flowable that emits items that are the result of flattening the items emitted by the Publishers in the Iterable

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> mergeDelayError(Publisher<? extends T> source1,
        Publisher<? extends T> source2)

Flattens two Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them.

This behaves like merge(Publisher, Publisher) except that if any of the merged Publishers notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.

Even if both merged Publishers send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.

Backpressure:

The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source1 - a Publisher to be merged

source2 - a Publisher to be merged

Returns:

a Flowable that emits all of the items that are emitted by the two source Publishers

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> mergeDelayError(Publisher<? extends T> source1,
        Publisher<? extends T> source2,
        Publisher<? extends T> source3)

Flattens three Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them.

This behaves like merge(Publisher, Publisher, Publisher) except that if any of the merged Publishers notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.

Even if multiple merged Publishers send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.

Backpressure:

The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source1 - a Publisher to be merged

source2 - a Publisher to be merged

source3 - a Publisher to be merged

Returns:

a Flowable that emits all of the items that are emitted by the source Publishers

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> mergeDelayError(Publisher<? extends T> source1,
        Publisher<? extends T> source2,
        Publisher<? extends T> source3,
        Publisher<? extends T> source4)

Flattens four Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them.

This behaves like merge(Publisher, Publisher, Publisher, Publisher) except that if any of the merged Publishers notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.

Even if multiple merged Publishers send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.

Backpressure:

The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source1 - a Publisher to be merged

source2 - a Publisher to be merged

source3 - a Publisher to be merged

source4 - a Publisher to be merged

Returns:

a Flowable that emits all of the items that are emitted by the source Publishers

See Also:

ReactiveX operators documentation: Merge

never

@CheckReturnValue
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> never()

Returns a Flowable that never sends any items or notifications to a Subscriber.

This Publisher is useful primarily for testing purposes.

Backpressure:

This source doesn't produce any elements and effectively ignores downstream backpressure.

Scheduler:

never does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of items (not) emitted by the Publisher

Returns:

a Flowable that never emits any items or sends any notifications to a Subscriber

See Also:

ReactiveX operators documentation: Never

range

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static Flowable<Integer> range(int start,
        int count)

Returns a Flowable that emits a sequence of Integers within a specified range.

Backpressure:

The operator honors backpressure from downstream and signals values on-demand (i.e., when requested).

Scheduler:

range does not operate by default on a particular Scheduler.

Parameters:

start - the value of the first Integer in the sequence

count - the number of sequential Integers to generate

Returns:

a Flowable that emits a range of sequential Integers

Throws:

IllegalArgumentException - if count is less than zero, or if start + count − 1 exceeds Integer.MAX_VALUE

See Also:

ReactiveX operators documentation: Range

rangeLong

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static Flowable<Long> rangeLong(long start,
        long count)

Returns a Flowable that emits a sequence of Longs within a specified range.

Backpressure:

The operator honors backpressure from downstream and signals values on-demand (i.e., when requested).

Scheduler:

rangeLong does not operate by default on a particular Scheduler.

Parameters:

start - the value of the first Long in the sequence

count - the number of sequential Longs to generate

Returns:

a Flowable that emits a range of sequential Longs

Throws:

IllegalArgumentException - if count is less than zero, or if start + count − 1 exceeds Long.MAX_VALUE

See Also:

ReactiveX operators documentation: Range

sequenceEqual

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Single<Boolean> sequenceEqual(Publisher<? extends T> source1,
        Publisher<? extends T> source2)

Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise.

Backpressure:

This operator honors downstream backpressure and expects both of its sources to honor backpressure as well. If violated, the operator will emit a MissingBackpressureException.

Scheduler:

sequenceEqual does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of items emitted by each Publisher

Parameters:

source1 - the first Publisher to compare

source2 - the second Publisher to compare

Returns:

a Flowable that emits a Boolean value that indicates whether the two sequences are the same

See Also:

ReactiveX operators documentation: SequenceEqual

sequenceEqual

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Single<Boolean> sequenceEqual(Publisher<? extends T> source1,
        Publisher<? extends T> source2,
        BiPredicate<? super T,? super T> isEqual)

Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.

Backpressure:

The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator signals a MissingBackpressureException.

Scheduler:

sequenceEqual does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of items emitted by each Publisher

Parameters:

source1 - the first Publisher to compare

source2 - the second Publisher to compare

isEqual - a function used to compare items emitted by each Publisher

Returns:

a Single that emits a Boolean value that indicates whether the two Publisher sequences are the same according to the specified function

See Also:

ReactiveX operators documentation: SequenceEqual

sequenceEqual

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Single<Boolean> sequenceEqual(Publisher<? extends T> source1,
        Publisher<? extends T> source2,
        BiPredicate<? super T,? super T> isEqual,
        int bufferSize)

Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.

Backpressure:

The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator signals a MissingBackpressureException.

Scheduler:

sequenceEqual does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of items emitted by each Publisher

Parameters:

source1 - the first Publisher to compare

source2 - the second Publisher to compare

isEqual - a function used to compare items emitted by each Publisher

bufferSize - the number of items to prefetch from the first and second source Publisher

Returns:

a Single that emits a Boolean value that indicates whether the two Publisher sequences are the same according to the specified function

See Also:

ReactiveX operators documentation: SequenceEqual

sequenceEqual

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Single<Boolean> sequenceEqual(Publisher<? extends T> source1,
        Publisher<? extends T> source2,
        int bufferSize)

Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise.

Backpressure:

This operator honors downstream backpressure and expects both of its sources to honor backpressure as well. If violated, the operator will emit a MissingBackpressureException.

Scheduler:

sequenceEqual does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of items emitted by each Publisher

Parameters:

source1 - the first Publisher to compare

source2 - the second Publisher to compare

bufferSize - the number of items to prefetch from the first and second source Publisher

Returns:

a Single that emits a Boolean value that indicates whether the two sequences are the same

See Also:

ReactiveX operators documentation: SequenceEqual

switchOnNext

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> switchOnNext(Publisher<? extends Publisher<? extends T>> sources,
        int bufferSize)

Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers.

switchOnNext subscribes to a Publisher that emits Publishers. Each time it observes one of these emitted Publishers, the Publisher returned by switchOnNext begins emitting the items emitted by that Publisher. When a new Publisher is emitted, switchOnNext stops emitting items from the earlier-emitted Publisher and begins emitting items from the new one.

The resulting Publisher completes if both the outer Publisher and the last inner Publisher, if any, complete. If the outer Publisher signals an onError, the inner Publisher is canceled and the error delivered in-sequence.

Backpressure:

The operator honors backpressure from downstream. The outer Publisher is consumed in an unbounded manner (i.e., without backpressure) and the inner Publishers are expected to honor backpressure but it is not enforced; the operator won't signal a MissingBackpressureException but the violation may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

switchOnNext does not operate by default on a particular Scheduler.

Type Parameters:

T - the item type

Parameters:

sources - the source Publisher that emits Publishers

bufferSize - the number of items to prefetch from the inner Publishers

Returns:

a Flowable that emits the items emitted by the Publisher most recently emitted by the source Publisher

See Also:

ReactiveX operators documentation: Switch

switchOnNext

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> switchOnNext(Publisher<? extends Publisher<? extends T>> sources)

Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers.

switchOnNext subscribes to a Publisher that emits Publishers. Each time it observes one of these emitted Publishers, the Publisher returned by switchOnNext begins emitting the items emitted by that Publisher. When a new Publisher is emitted, switchOnNext stops emitting items from the earlier-emitted Publisher and begins emitting items from the new one.

The resulting Publisher completes if both the outer Publisher and the last inner Publisher, if any, complete. If the outer Publisher signals an onError, the inner Publisher is canceled and the error delivered in-sequence.

Backpressure:

The operator honors backpressure from downstream. The outer Publisher is consumed in an unbounded manner (i.e., without backpressure) and the inner Publishers are expected to honor backpressure but it is not enforced; the operator won't signal a MissingBackpressureException but the violation may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

switchOnNext does not operate by default on a particular Scheduler.

Type Parameters:

T - the item type

Parameters:

sources - the source Publisher that emits Publishers

Returns:

a Flowable that emits the items emitted by the Publisher most recently emitted by the source Publisher

See Also:

ReactiveX operators documentation: Switch

switchOnNextDelayError

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> switchOnNextDelayError(Publisher<? extends Publisher<? extends T>> sources)

Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers and delays any exception until all Publishers terminate.

switchOnNext subscribes to a Publisher that emits Publishers. Each time it observes one of these emitted Publishers, the Publisher returned by switchOnNext begins emitting the items emitted by that Publisher. When a new Publisher is emitted, switchOnNext stops emitting items from the earlier-emitted Publisher and begins emitting items from the new one.

The resulting Publisher completes if both the main Publisher and the last inner Publisher, if any, complete. If the main Publisher signals an onError, the termination of the last inner Publisher will emit that error as is or wrapped into a CompositeException along with the other possible errors the former inner Publishers signaled.

Backpressure:

The operator honors backpressure from downstream. The outer Publisher is consumed in an unbounded manner (i.e., without backpressure) and the inner Publishers are expected to honor backpressure but it is not enforced; the operator won't signal a MissingBackpressureException but the violation may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

switchOnNextDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the item type

Parameters:

sources - the source Publisher that emits Publishers

Returns:

a Flowable that emits the items emitted by the Publisher most recently emitted by the source Publisher

Since:

2.0

See Also:

ReactiveX operators documentation: Switch

switchOnNextDelayError

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> switchOnNextDelayError(Publisher<? extends Publisher<? extends T>> sources,
        int prefetch)

Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers and delays any exception until all Publishers terminate.

switchOnNext subscribes to a Publisher that emits Publishers. Each time it observes one of these emitted Publishers, the Publisher returned by switchOnNext begins emitting the items emitted by that Publisher. When a new Publisher is emitted, switchOnNext stops emitting items from the earlier-emitted Publisher and begins emitting items from the new one.

The resulting Publisher completes if both the main Publisher and the last inner Publisher, if any, complete. If the main Publisher signals an onError, the termination of the last inner Publisher will emit that error as is or wrapped into a CompositeException along with the other possible errors the former inner Publishers signaled.

Backpressure:

The operator honors backpressure from downstream. The outer Publisher is consumed in an unbounded manner (i.e., without backpressure) and the inner Publishers are expected to honor backpressure but it is not enforced; the operator won't signal a MissingBackpressureException but the violation may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

switchOnNextDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the item type

Parameters:

sources - the source Publisher that emits Publishers

prefetch - the number of items to prefetch from the inner Publishers

Returns:

a Flowable that emits the items emitted by the Publisher most recently emitted by the source Publisher

Since:

2.0

See Also:

ReactiveX operators documentation: Switch

timer

@CheckReturnValue
 @BackpressureSupport(value=ERROR)
 @SchedulerSupport(value="io.reactivex:computation")
public static Flowable<Long> timer(long delay,
        TimeUnit unit)

Returns a Flowable that emits 0L after a specified delay, and then completes.

Backpressure:

This operator does not support backpressure as it uses time. If the downstream needs a slower rate it should slow the timer or use something like onBackpressureDrop().

Scheduler:

timer operates by default on the computation Scheduler.

Parameters:

delay - the initial delay before emitting a single 0L

unit - time units to use for delay

Returns:

a Flowable that emits 0L after a specified delay, and then completes

See Also:

ReactiveX operators documentation: Timer

timer

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=ERROR)
 @SchedulerSupport(value="custom")
public static Flowable<Long> timer(long delay,
        TimeUnit unit,
        Scheduler scheduler)

Returns a Flowable that emits 0L after a specified delay, on a specified Scheduler, and then completes.

Backpressure:

This operator does not support backpressure as it uses time. If the downstream needs a slower rate it should slow the timer or use something like onBackpressureDrop().

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

delay - the initial delay before emitting a single 0L

unit - time units to use for delay

scheduler - the Scheduler to use for scheduling the item

Returns:

a Flowable that emits 0L after a specified delay, on a specified Scheduler, and then completes

See Also:

ReactiveX operators documentation: Timer

unsafeCreate

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=NONE)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> unsafeCreate(Publisher<T> onSubscribe)

Create a Flowable by wrapping a Publisher which has to be implemented according to the Reactive Streams specification by handling backpressure and cancellation correctly; no safeguards are provided by the Flowable itself.

Backpressure:

This operator is a pass-through for backpressure and the behavior is determined by the provided Publisher implementation.

Scheduler:

unsafeCreate by default doesn't operate on any particular Scheduler.

Type Parameters:

T - the value type emitted

Parameters:

onSubscribe - the Publisher instance to wrap

Returns:

the new Flowable instance

Throws:

IllegalArgumentException - if onSubscribe is a subclass of Flowable; such instances don't need conversion and is possibly a port remnant from 1.x or one should use hide() instead.

using

@CheckReturnValue
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public static <T,D> Flowable<T> using(Callable<? extends D> resourceSupplier,
        Function<? super D,? extends Publisher<? extends T>> sourceSupplier,
        Consumer<? super D> resourceDisposer)

Constructs a Publisher that creates a dependent resource object which is disposed of on cancellation.

Backpressure:

The operator is a pass-through for backpressure and otherwise depends on the backpressure support of the Publisher returned by the resourceFactory.

Scheduler:

using does not operate by default on a particular Scheduler.

Type Parameters:

T - the element type of the generated Publisher

D - the type of the resource associated with the output sequence

Parameters:

resourceSupplier - the factory function to create a resource object that depends on the Publisher

sourceSupplier - the factory function to create a Publisher

resourceDisposer - the function that will dispose of the resource

Returns:

the Publisher whose lifetime controls the lifetime of the dependent resource object

See Also:

ReactiveX operators documentation: Using

using

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public static <T,D> Flowable<T> using(Callable<? extends D> resourceSupplier,
        Function<? super D,? extends Publisher<? extends T>> sourceSupplier,
        Consumer<? super D> resourceDisposer,
        boolean eager)

Constructs a Publisher that creates a dependent resource object which is disposed of just before termination if you have set disposeEagerly to true and cancellation does not occur before termination. Otherwise, resource disposal will occur on cancellation. Eager disposal is particularly appropriate for a synchronous Publisher that reuses resources. disposeAction will only be called once per subscription.

Backpressure:

The operator is a pass-through for backpressure and otherwise depends on the backpressure support of the Publisher returned by the resourceFactory.

Scheduler:

using does not operate by default on a particular Scheduler.

Type Parameters:

T - the element type of the generated Publisher

D - the type of the resource associated with the output sequence

Parameters:

resourceSupplier - the factory function to create a resource object that depends on the Publisher

sourceSupplier - the factory function to create a Publisher

resourceDisposer - the function that will dispose of the resource

eager - if true then disposal will happen either on cancellation or just before emission of a terminal event (onComplete or onError).

Returns:

the Publisher whose lifetime controls the lifetime of the dependent resource object

Since:

2.0

See Also:

ReactiveX operators documentation: Using

zip

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T,R> Flowable<R> zip(Iterable<? extends Publisher<? extends T>> sources,
        Function<? super Object[],? extends R> zipper)

Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other Publishers.

zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by each of the source Publishers; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by each of those Publishers; and so forth.

The resulting Publisher<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.

The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:

zip(Arrays.asList(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2)), (a) -> a)

action1 will be called but action2 won't.
To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T - the common value type

R - the zipped result type

Parameters:

sources - an Iterable of source Publishers

zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher

Returns:

a Flowable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T,R> Flowable<R> zip(Publisher<? extends Publisher<? extends T>> sources,
        Function<? super Object[],? extends R> zipper)

Returns a Flowable that emits the results of a specified combiner function applied to combinations of n items emitted, in sequence, by the n Publishers emitted by a specified Publisher.

zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by each of the Publishers emitted by the source Publisher; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by each of those Publishers; and so forth.

The resulting Publisher<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.

The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while cancel the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:

zip(just(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2)), (a) -> a)

action1 will be called but action2 won't.
To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type of the inner Publishers

R - the zipped result type

Parameters:

sources - a Publisher of source Publishers

zipper - a function that, when applied to an item emitted by each of the Publishers emitted by ws, results in an item that will be emitted by the resulting Publisher

Returns:

a Flowable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T1,T2,R> Flowable<R> zip(Publisher<? extends T1> source1,
        Publisher<? extends T2> source2,
        BiFunction<? super T1,? super T2,? extends R> zipper)

Returns a Flowable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other Publishers.

zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by o1 and the first item emitted by o2; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by o1 and the second item emitted by o2; and so forth.

The resulting Publisher<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.

The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:

zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), (a, b) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

R - the zipped result type

Parameters:

source1 - the first source Publisher

source2 - a second source Publisher

zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher

Returns:

a Flowable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T1,T2,R> Flowable<R> zip(Publisher<? extends T1> source1,
        Publisher<? extends T2> source2,
        BiFunction<? super T1,? super T2,? extends R> zipper,
        boolean delayError)

Returns a Flowable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other Publishers.

zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by o1 and the first item emitted by o2; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by o1 and the second item emitted by o2; and so forth.

The resulting Publisher<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.

The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:

zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), (a, b) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

R - the zipped result type

Parameters:

source1 - the first source Publisher

source2 - a second source Publisher

zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher

delayError - delay errors from any of the source Publishers till the other terminates

Returns:

a Flowable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T1,T2,R> Flowable<R> zip(Publisher<? extends T1> source1,
        Publisher<? extends T2> source2,
        BiFunction<? super T1,? super T2,? extends R> zipper,
        boolean delayError,
        int bufferSize)

Returns a Flowable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other Publishers.

zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by o1 and the first item emitted by o2; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by o1 and the second item emitted by o2; and so forth.

The resulting Publisher<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.

The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:

zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), (a, b) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

R - the zipped result type

Parameters:

source1 - the first source Publisher

source2 - a second source Publisher

zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher

delayError - delay errors from any of the source Publishers till the other terminates

bufferSize - the number of elements to prefetch from each source Publisher

Returns:

a Flowable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T1,T2,T3,R> Flowable<R> zip(Publisher<? extends T1> source1,
        Publisher<? extends T2> source2,
        Publisher<? extends T3> source3,
        Function3<? super T1,? super T2,? super T3,? extends R> zipper)

Returns a Flowable that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three other Publishers.

zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by o1, the first item emitted by o2, and the first item emitted by o3; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by o1, the second item emitted by o2, and the second item emitted by o3; and so forth.

The resulting Publisher<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.

The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:

zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

T3 - the value type of the third source

R - the zipped result type

Parameters:

source1 - the first source Publisher

source2 - a second source Publisher

source3 - a third source Publisher

zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher

Returns:

a Flowable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,R> Flowable<R> zip(Publisher<? extends T1> source1,
        Publisher<? extends T2> source2,
        Publisher<? extends T3> source3,
        Publisher<? extends T4> source4,
        Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)

Returns a Flowable that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four other Publishers.

zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by o1, the first item emitted by o2, the first item emitted by o3, and the first item emitted by 04; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by each of those Publishers; and so forth.

The resulting Publisher<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.

The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:

zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

T3 - the value type of the third source

T4 - the value type of the fourth source

R - the zipped result type

Parameters:

source1 - the first source Publisher

source2 - a second source Publisher

source3 - a third source Publisher

source4 - a fourth source Publisher

zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher

Returns:

a Flowable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,T5,R> Flowable<R> zip(Publisher<? extends T1> source1,
        Publisher<? extends T2> source2,
        Publisher<? extends T3> source3,
        Publisher<? extends T4> source4,
        Publisher<? extends T5> source5,
        Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)

Returns a Flowable that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five other Publishers.

zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by o1, the first item emitted by o2, the first item emitted by o3, the first item emitted by o4, and the first item emitted by o5; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by each of those Publishers; and so forth.

The resulting Publisher<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.

The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:

zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

T3 - the value type of the third source

T4 - the value type of the fourth source

T5 - the value type of the fifth source

R - the zipped result type

Parameters:

source1 - the first source Publisher

source2 - a second source Publisher

source3 - a third source Publisher

source4 - a fourth source Publisher

source5 - a fifth source Publisher

zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher

Returns:

a Flowable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,T5,T6,R> Flowable<R> zip(Publisher<? extends T1> source1,
        Publisher<? extends T2> source2,
        Publisher<? extends T3> source3,
        Publisher<? extends T4> source4,
        Publisher<? extends T5> source5,
        Publisher<? extends T6> source6,
        Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)

Returns a Flowable that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six other Publishers.

zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by each source Publisher, the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by each of those Publishers, and so forth.

The resulting Publisher<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.

The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:

zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e, f) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

T3 - the value type of the third source

T4 - the value type of the fourth source

T5 - the value type of the fifth source

T6 - the value type of the sixth source

R - the zipped result type

Parameters:

source1 - the first source Publisher

source2 - a second source Publisher

source3 - a third source Publisher

source4 - a fourth source Publisher

source5 - a fifth source Publisher

source6 - a sixth source Publisher

zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher

Returns:

a Flowable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,T5,T6,T7,R> Flowable<R> zip(Publisher<? extends T1> source1,
        Publisher<? extends T2> source2,
        Publisher<? extends T3> source3,
        Publisher<? extends T4> source4,
        Publisher<? extends T5> source5,
        Publisher<? extends T6> source6,
        Publisher<? extends T7> source7,
        Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)

Returns a Flowable that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven other Publishers.

zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by each source Publisher, the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by each of those Publishers, and so forth.

The resulting Publisher<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.

The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:

zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e, f, g) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

T3 - the value type of the third source

T4 - the value type of the fourth source

T5 - the value type of the fifth source

T6 - the value type of the sixth source

T7 - the value type of the seventh source

R - the zipped result type

Parameters:

source1 - the first source Publisher

source2 - a second source Publisher

source3 - a third source Publisher

source4 - a fourth source Publisher

source5 - a fifth source Publisher

source6 - a sixth source Publisher

source7 - a seventh source Publisher

zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher

Returns:

a Flowable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,T5,T6,T7,T8,R> Flowable<R> zip(Publisher<? extends T1> source1,
        Publisher<? extends T2> source2,
        Publisher<? extends T3> source3,
        Publisher<? extends T4> source4,
        Publisher<? extends T5> source5,
        Publisher<? extends T6> source6,
        Publisher<? extends T7> source7,
        Publisher<? extends T8> source8,
        Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper)

Returns a Flowable that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight other Publishers.

zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by each source Publisher, the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by each of those Publishers, and so forth.

The resulting Publisher<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.

The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:

zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e, f, g, h) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

T3 - the value type of the third source

T4 - the value type of the fourth source

T5 - the value type of the fifth source

T6 - the value type of the sixth source

T7 - the value type of the seventh source

T8 - the value type of the eighth source

R - the zipped result type

Parameters:

source1 - the first source Publisher

source2 - a second source Publisher

source3 - a third source Publisher

source4 - a fourth source Publisher

source5 - a fifth source Publisher

source6 - a sixth source Publisher

source7 - a seventh source Publisher

source8 - an eighth source Publisher

zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher

Returns:

a Flowable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Flowable<R> zip(Publisher<? extends T1> source1,
        Publisher<? extends T2> source2,
        Publisher<? extends T3> source3,
        Publisher<? extends T4> source4,
        Publisher<? extends T5> source5,
        Publisher<? extends T6> source6,
        Publisher<? extends T7> source7,
        Publisher<? extends T8> source8,
        Publisher<? extends T9> source9,
        Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper)

Returns a Flowable that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine other Publishers.

zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by each source Publisher, the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by each of those Publishers, and so forth.

The resulting Publisher<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.

The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:

zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e, f, g, h, i) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

T3 - the value type of the third source

T4 - the value type of the fourth source

T5 - the value type of the fifth source

T6 - the value type of the sixth source

T7 - the value type of the seventh source

T8 - the value type of the eighth source

T9 - the value type of the ninth source

R - the zipped result type

Parameters:

source1 - the first source Publisher

source2 - a second source Publisher

source3 - a third source Publisher

source4 - a fourth source Publisher

source5 - a fifth source Publisher

source6 - a sixth source Publisher

source7 - a seventh source Publisher

source8 - an eighth source Publisher

source9 - a ninth source Publisher

zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher

Returns:

a Flowable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zipArray

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T,R> Flowable<R> zipArray(Function<? super Object[],? extends R> zipper,
        boolean delayError,
        int bufferSize,
        Publisher<? extends T>... sources)

Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of other Publishers.

zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by each of the source Publishers; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by each of those Publishers; and so forth.

The resulting Publisher<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.

The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:

zip(new Publisher[]{range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2)}, (a) ->
 a)

action1 will be called but action2 won't.
To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

Scheduler:

zipArray does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element type

R - the result type

Parameters:

sources - an array of source Publishers

zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher

delayError - delay errors signaled by any of the source Publisher until all Publishers terminate

bufferSize - the number of elements to prefetch from each source Publisher

Returns:

a Flowable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zipIterable

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T,R> Flowable<R> zipIterable(Iterable<? extends Publisher<? extends T>> sources,
        Function<? super Object[],? extends R> zipper,
        boolean delayError,
        int bufferSize)

Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other Publishers.

zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by each of the source Publishers; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by each of those Publishers; and so forth.

The resulting Publisher<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.

The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:

zip(Arrays.asList(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2)), (a) -> a)

action1 will be called but action2 won't.
To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

Scheduler:

zipIterable does not operate by default on a particular Scheduler.

Type Parameters:

T - the common source value type

R - the zipped result type

Parameters:

sources - an Iterable of source Publishers

zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher

delayError - delay errors signaled by any of the source Publisher until all Publishers terminate

bufferSize - the number of elements to prefetch from each source Publisher

Returns:

a Flowable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

all

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public final Single<Boolean> all(Predicate<? super T> predicate)

Returns a Single that emits a Boolean that indicates whether all of the items emitted by the source Publisher satisfy a condition.

Backpressure:

The operator honors backpressure from downstream and consumes the source Publisher in an unbounded manner (i.e., without applying backpressure).

Scheduler:

all does not operate by default on a particular Scheduler.

Parameters:

predicate - a function that evaluates an item and returns a Boolean

Returns:

a Single that emits true if all items emitted by the source Publisher satisfy the predicate; otherwise, false

See Also:

ReactiveX operators documentation: All

ambWith

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final Flowable<T> ambWith(Publisher<? extends T> other)

Mirrors the Publisher (current or provided) that first either emits an item or sends a termination notification.

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by the winning Publisher's backpressure behavior.

Scheduler:

ambWith does not operate by default on a particular Scheduler.

Parameters:

other - a Publisher competing to react first. A subscription to this provided Publisher will occur after subscribing to the current Publisher.

Returns:

a Flowable that emits the same sequence as whichever of the source Publishers first emitted an item or sent a termination notification

See Also:

ReactiveX operators documentation: Amb

any

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public final Single<Boolean> any(Predicate<? super T> predicate)

Returns a Single that emits true if any item emitted by the source Publisher satisfies a specified condition, otherwise false. Note: this always emits false if the source Publisher is empty.

In Rx.Net this is the any operator but we renamed it in RxJava to better match Java naming idioms.

Backpressure:

The operator honors backpressure from downstream and consumes the source Publisher in an unbounded manner (i.e., no backpressure applied to it).

Scheduler:

any does not operate by default on a particular Scheduler.

Parameters:

predicate - the condition to test items emitted by the source Publisher

Returns:

a Single that emits a Boolean that indicates whether any item emitted by the source Publisher satisfies the predicate

See Also:

ReactiveX operators documentation: Contains

as

@CheckReturnValue
 @BackpressureSupport(value=SPECIAL)
 @SchedulerSupport(value="none")
public final <R> R as(@NonNull FlowableConverter<T,? extends 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 backpressure behavior depends on what happens in the converter function.

Scheduler:

as 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 Flowable instance and returns a value

Returns:

the converted value

Throws:

NullPointerException - if converter is null

Since:

2.2

blockingFirst

@CheckReturnValue
 @BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public final T blockingFirst()

Returns the first item emitted by this Flowable, or throws NoSuchElementException if it emits no items.

Backpressure:

The operator consumes the source Flowable in an unbounded manner (i.e., no backpressure applied to it).

Scheduler:

blockingFirst does not operate by default on a particular Scheduler.

Error handling:

If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.

Returns:

the first item emitted by this Flowable

Throws:

NoSuchElementException - if this Flowable emits no items

See Also:

ReactiveX documentation: First

blockingFirst

@CheckReturnValue
 @BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public final T blockingFirst(T defaultItem)

Returns the first item emitted by this Flowable, or a default value if it emits no items.

Backpressure:

The operator consumes the source Flowable in an unbounded manner (i.e., no backpressure applied to it).

Scheduler:

blockingFirst does not operate by default on a particular Scheduler.

Error handling:

If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.

Parameters:

defaultItem - a default value to return if this Flowable emits no items

Returns:

the first item emitted by this Flowable, or the default value if it emits no items

See Also:

ReactiveX documentation: First

blockingForEach

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public final void blockingForEach(Consumer<? super T> onNext)

Consumes the upstream Flowable in a blocking fashion and invokes the given Consumer with each upstream item on the current thread until the upstream terminates.

Note: the method will only return if the upstream terminates or the current thread is interrupted.

This method executes the Consumer on the current thread while subscribe(Consumer) executes the consumer on the original caller thread of the sequence.

Backpressure:

The operator consumes the source Flowable in an unbounded manner (i.e., no backpressure applied to it).

Scheduler:

blockingForEach does not operate by default on a particular Scheduler.

Error handling:

If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.

Parameters:

onNext - the Consumer to invoke for each item emitted by the Flowable

Throws:

RuntimeException - if an error occurs

See Also:

ReactiveX documentation: Subscribe, subscribe(Consumer)

blockingIterable

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final Iterable<T> blockingIterable()

Converts this Flowable into an Iterable.

Backpressure:

The operator expects the upstream to honor backpressure otherwise the returned Iterable's iterator will throw a MissingBackpressureException.

Scheduler:

blockingIterable does not operate by default on a particular Scheduler.

Returns:

an Iterable version of this Flowable

See Also:

ReactiveX documentation: To

blockingIterable

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final Iterable<T> blockingIterable(int bufferSize)

Converts this Flowable into an Iterable.

Backpressure:

The operator expects the upstream to honor backpressure otherwise the returned Iterable's iterator will throw a MissingBackpressureException.

Scheduler:

blockingIterable does not operate by default on a particular Scheduler.

Parameters:

bufferSize - the number of items to prefetch from the current Flowable

Returns:

an Iterable version of this Flowable

See Also:

ReactiveX documentation: To

blockingLast

@CheckReturnValue
 @BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public final T blockingLast()

Returns the last item emitted by this Flowable, or throws NoSuchElementException if this Flowable emits no items.

Backpressure:

The operator consumes the source Flowable in an unbounded manner (i.e., no backpressure applied to it).

Scheduler:

blockingLast does not operate by default on a particular Scheduler.

Error handling:

If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.

Returns:

the last item emitted by this Flowable

Throws:

NoSuchElementException - if this Flowable emits no items

See Also:

ReactiveX documentation: Last

blockingLast

@CheckReturnValue
 @BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public final T blockingLast(T defaultItem)

Returns the last item emitted by this Flowable, or a default value if it emits no items.

Backpressure:

The operator consumes the source Flowable in an unbounded manner (i.e., no backpressure applied to it).

Scheduler:

blockingLast does not operate by default on a particular Scheduler.

Error handling:

If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.

Parameters:

defaultItem - a default value to return if this Flowable emits no items

Returns:

the last item emitted by the Flowable, or the default value if it emits no items

See Also:

ReactiveX documentation: Last

blockingLatest