Movatterモバイル変換

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 classFlowable<T>extendsObjectimplementsPublisher<T>
```
The Flowable class that implements theReactive Streams Pattern and offers factory methods, intermediate operators and the ability to consume reactive dataflows.
Reactive Streams operates withPublishers whichFlowable extends. Many operators therefore accept generalPublishers directly and allow direct interoperation with other Reactive Streams implementations.
The Flowable hosts the default buffer size of 128 elements for operators, accessible viabufferSize(), that can be overridden globally via the system parameterrx2.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:
TheFlowable follows the protocol
```
 onSubscribe onNext* (onError | onComplete)?
```
where the stream can be disposed through theSubscription instance provided to consumers throughSubscriber.onSubscribe(Subscription). Unlike theObservable.subscribe() of version 1.x,subscribe(Subscriber) does not allow external cancellation of a subscription and theSubscriber instance is expected to expose such capability if needed.
Flowables support backpressure and requireSubscribers to signal demand viaSubscription.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 betweenPublishers andSubscribers, so much so that there is a significant performance penalty due certain timing requirements and the need to prepare for invalid request amounts viaSubscription.request(long). Therefore, RxJava has introduced theFlowableSubscriber interface that indicates the consumer can be driven with relaxed rules. All RxJava operators are implemented with these relaxed rules in mind. If the subscribingSubscriber 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 ofReactive Streams rules to be followed to the letter. Seethe wiki for some guidance if such custom implementations are necessary.
The recommended way of creating customFlowables is by using thecreate(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 asFlowable, are generally synchronous and sequential in nature. In the ReactiveX design, the location (thread) where operators run isorthogonal to when the operators can work with data. This means that asynchrony and parallelism has to be explicitly expressed via operators such assubscribeOn(Scheduler),observeOn(Scheduler) andparallel(). In general, operators featuring aScheduler parameter are introducing this type of asynchrony into the flow.
For more information see theReactiveX documentation.
See Also:
Observable,ParallelFlowable,DisposableSubscriber

Constructor Summary
Constructors
Constructor and Description
Flowable()

Constructors
Constructor and Description
`Flowable()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`Single<Boolean>`	`all(Predicate<? superT> 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<? extendsPublisher<? 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<? extendsT> other)` Mirrors the Publisher (current or provided) that first either emits an item or sends a termination notification.
`Single<Boolean>`	`any(Predicate<? superT> 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<? superT> onNext)` Consumes the upstream`Flowable` in a blocking fashion and invokes the given`Consumer` with each upstream item on thecurrent 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<? superT> onNext)` Subscribes to the source and calls the given callbackson the current thread.
`void`	`blockingSubscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError)` Subscribes to the source and calls the given callbackson the current thread.
`void`	`blockingSubscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError,Action onComplete)` Subscribes to the source and calls the given callbackson the current thread.
`void`	`blockingSubscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError,Action onComplete, int bufferSize)` Subscribes to the source and calls the given callbackson the current thread.
`void`	`blockingSubscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError, int bufferSize)` Subscribes to the source and calls the given callbackson the current thread.
`void`	`blockingSubscribe(Consumer<? superT> onNext, int bufferSize)` Subscribes to the source and calls the given callbackson the current thread.
`void`	`blockingSubscribe(Subscriber<? superT> subscriber)` Subscribes to the source and calls the`Subscriber` methodson the current thread.
`<B> Flowable<List<T>>`	`buffer(Callable<? extendsPublisher<B>> boundaryIndicatorSupplier)` Returns a Flowable that emits buffers of items it collects from the source Publisher.
`<B,U extendsCollection<? superT>> Flowable<U>`	`buffer(Callable<? extendsPublisher<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,? extendsPublisher<? extends TClosing>> closingIndicator)` Returns a Flowable that emits buffers of items it collects from the source Publisher.
`<TOpening,TClosing,U extendsCollection<? superT>> Flowable<U>`	`buffer(Flowable<? extends TOpening> openingIndicator,Function<? super TOpening,? extendsPublisher<? 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 extendsCollection<? superT>> 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 extendsCollection<? superT>> 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 extendsCollection<? superT>> 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 extendsCollection<? superT>> 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 extendsCollection<? superT>> 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,? superT> 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,? superT> 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<? superObject[],? 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<? extendsPublisher<? extends T>> sources,Function<? superObject[],? 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<? extendsPublisher<? extends T>> sources,Function<? superObject[],? 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<? superObject[],? 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<? superObject[],? 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<? superObject[],? 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<? superObject[],? 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<? extendsPublisher<? extends T>> sources,Function<? superObject[],? 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<? extendsPublisher<? extends T>> sources,Function<? superObject[],? 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<? superObject[],? 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<? superObject[],? 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<? superT,? extends R> composer)` Transform a Publisher by applying a particular Transformer function to it.
`static <T> Flowable<T>`	`concat(Iterable<? extendsPublisher<? 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<? extendsPublisher<? 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<? extendsPublisher<? 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`Publisher`s 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`Publisher`s eagerly into a single stream of values and delaying any errors until all sources terminate.
`static <T> Flowable<T>`	`concatDelayError(Iterable<? extendsPublisher<? 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<? extendsPublisher<? 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<? extendsPublisher<? 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<? extendsPublisher<? extends T>> sources)` Concatenates a sequence of Publishers eagerly into a single stream of values.
`static <T> Flowable<T>`	`concatEager(Iterable<? extendsPublisher<? 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<? extendsPublisher<? extends T>> sources)` Concatenates a Publisher sequence of Publishers eagerly into a single stream of values.
`static <T> Flowable<T>`	`concatEager(Publisher<? extendsPublisher<? 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<? superT,? extendsPublisher<? 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<? superT,? extendsPublisher<? 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<? superT,? extendsCompletableSource> mapper)` Maps the upstream items into`CompletableSource`s and subscribes to them one after the other completes.
`Completable`	`concatMapCompletable(Function<? superT,? extendsCompletableSource> mapper, int prefetch)` Maps the upstream items into`CompletableSource`s and subscribes to them one after the other completes.
`Completable`	`concatMapCompletableDelayError(Function<? superT,? extendsCompletableSource> mapper)` Maps the upstream items into`CompletableSource`s and subscribes to them one after the other terminates, delaying all errors till both this`Flowable` and all inner`CompletableSource`s terminate.
`Completable`	`concatMapCompletableDelayError(Function<? superT,? extendsCompletableSource> mapper, boolean tillTheEnd)` Maps the upstream items into`CompletableSource`s and subscribes to them one after the other terminates, optionally delaying all errors till both this`Flowable` and all inner`CompletableSource`s terminate.
`Completable`	`concatMapCompletableDelayError(Function<? superT,? extendsCompletableSource> mapper, boolean tillTheEnd, int prefetch)` Maps the upstream items into`CompletableSource`s and subscribes to them one after the other terminates, optionally delaying all errors till both this`Flowable` and all inner`CompletableSource`s terminate.
`<R> Flowable<R>`	`concatMapDelayError(Function<? superT,? extendsPublisher<? 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<? superT,? extendsPublisher<? 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<? superT,? extendsPublisher<? extends R>> mapper)` Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
`<R> Flowable<R>`	`concatMapEager(Function<? superT,? extendsPublisher<? 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<? superT,? extendsPublisher<? 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<? superT,? extendsPublisher<? 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<? superT,? extendsIterable<? 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<? superT,? extendsIterable<? 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<? superT,? extendsMaybeSource<? extends R>> mapper)` Maps the upstream items into`MaybeSource`s 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<? superT,? extendsMaybeSource<? extends R>> mapper, int prefetch)` Maps the upstream items into`MaybeSource`s 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<? superT,? extendsMaybeSource<? extends R>> mapper)` Maps the upstream items into`MaybeSource`s 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`MaybeSource`s terminate.
`<R> Flowable<R>`	`concatMapMaybeDelayError(Function<? superT,? extendsMaybeSource<? extends R>> mapper, boolean tillTheEnd)` Maps the upstream items into`MaybeSource`s 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`MaybeSource`s terminate.
`<R> Flowable<R>`	`concatMapMaybeDelayError(Function<? superT,? extendsMaybeSource<? extends R>> mapper, boolean tillTheEnd, int prefetch)` Maps the upstream items into`MaybeSource`s 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`MaybeSource`s terminate.
`<R> Flowable<R>`	`concatMapSingle(Function<? superT,? extendsSingleSource<? extends R>> mapper)` Maps the upstream items into`SingleSource`s 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<? superT,? extendsSingleSource<? extends R>> mapper, int prefetch)` Maps the upstream items into`SingleSource`s 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<? superT,? extendsSingleSource<? extends R>> mapper)` Maps the upstream items into`SingleSource`s 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`SingleSource`s terminate.
`<R> Flowable<R>`	`concatMapSingleDelayError(Function<? superT,? extendsSingleSource<? extends R>> mapper, boolean tillTheEnd)` Maps the upstream items into`SingleSource`s 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`SingleSource`s terminate.
`<R> Flowable<R>`	`concatMapSingleDelayError(Function<? superT,? extendsSingleSource<? extends R>> mapper, boolean tillTheEnd, int prefetch)` Maps the upstream items into`SingleSource`s 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`SingleSource`s 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<? extendsT> 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<? extendsT> 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<? extendsT> 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<? superT,? extendsPublisher<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<? extendsPublisher<? 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<? superT,? extendsPublisher<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<? superT,? extendsPublisher<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<? superT,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<? superT,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<? superT,K> keySelector,Callable<? extendsCollection<? 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<? superT,? superT> 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<? superT,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<? superT> 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<? superNotification<T>> onNotification)` Modifies the source Publisher so that it invokes an action for each item it emits.
`Flowable<T>`	`doOnEach(Subscriber<? superT> subscriber)` Modifies the source Publisher so that it notifies a Subscriber for each item and terminal event it emits.
`Flowable<T>`	`doOnError(Consumer<? superThrowable> onError)` Modifies the source Publisher so that it invokes an action if it calls`onError`.
`Flowable<T>`	`doOnLifecycle(Consumer<? superSubscription> 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<? superT> 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<? superSubscription> 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<? extendsThrowable> 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<? superT> 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<? superT,? extendsPublisher<? 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<? superT,? extendsPublisher<? 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<? superT,? extendsPublisher<? 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<? superT,? extendsPublisher<? 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<? superT,? extendsPublisher<? extends R>> onNextMapper,Function<? superThrowable,? extendsPublisher<? extends R>> onErrorMapper,Callable<? extendsPublisher<? 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<? superT,? extendsPublisher<? extends R>> onNextMapper,Function<Throwable,? extendsPublisher<? extends R>> onErrorMapper,Callable<? extendsPublisher<? 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<? superT,? extendsPublisher<? 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<? superT,? extendsPublisher<? extends U>> mapper,BiFunction<? superT,? 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<? superT,? extendsPublisher<? extends U>> mapper,BiFunction<? superT,? 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<? superT,? extendsPublisher<? extends U>> mapper,BiFunction<? superT,? 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<? superT,? extendsPublisher<? extends U>> mapper,BiFunction<? superT,? 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<? superT,? extendsPublisher<? extends U>> mapper,BiFunction<? superT,? 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<? superT,? extendsCompletableSource> 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<? superT,? extendsCompletableSource> 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<? superT,? extendsIterable<? 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<? superT,? extendsIterable<? extends U>> mapper,BiFunction<? superT,? 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<? superT,? extendsIterable<? extends U>> mapper,BiFunction<? superT,? 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<? superT,? extendsIterable<? 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<? superT,? extendsMaybeSource<? 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<? superT,? extendsMaybeSource<? 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<? superT,? extendsSingleSource<? 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<? superT,? extendsSingleSource<? 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<? superT> onNext)` Subscribes to the`Publisher` and receives notifications for each element.
`Disposable`	`forEachWhile(Predicate<? superT> onNext)` Subscribes to the`Publisher` and receives notifications for each element until the onNext Predicate returns false.
`Disposable`	`forEachWhile(Predicate<? superT> onNext,Consumer<? superThrowable> onError)` Subscribes to the`Publisher` and receives notifications for each element and error events until the onNext Predicate returns false.
`Disposable`	`forEachWhile(Predicate<? superT> onNext,Consumer<? superThrowable> 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<? superT,? extends K> keySelector)` Groups the items emitted by a`Publisher` according to a specified criterion, and emits these grouped items as`GroupedFlowable`s.
`<K> Flowable<GroupedFlowable<K,T>>`	`groupBy(Function<? superT,? extends K> keySelector, boolean delayError)` Groups the items emitted by a`Publisher` according to a specified criterion, and emits these grouped items as`GroupedFlowable`s.
`<K,V> Flowable<GroupedFlowable<K,V>>`	`groupBy(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector)` Groups the items emitted by a`Publisher` according to a specified criterion, and emits these grouped items as`GroupedFlowable`s.
`<K,V> Flowable<GroupedFlowable<K,V>>`	`groupBy(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector, boolean delayError)` Groups the items emitted by a`Publisher` according to a specified criterion, and emits these grouped items as`GroupedFlowable`s.
`<K,V> Flowable<GroupedFlowable<K,V>>`	`groupBy(Function<? superT,? extends K> keySelector,Function<? superT,? 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`GroupedFlowable`s.
`<K,V> Flowable<GroupedFlowable<K,V>>`	`groupBy(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector, boolean delayError, int bufferSize,Function<? superConsumer<Object>,? extendsMap<K,Object>> evictingMapFactory)` Groups the items emitted by a`Publisher` according to a specified criterion, and emits these grouped items as`GroupedFlowable`s.
`<TRight,TLeftEnd,TRightEnd,R> Flowable<R>`	`groupJoin(Publisher<? extends TRight> other,Function<? superT,? extendsPublisher<TLeftEnd>> leftEnd,Function<? super TRight,? extendsPublisher<TRightEnd>> rightEnd,BiFunction<? superT,? superFlowable<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`.
`staticFlowable<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.
`staticFlowable<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`.
`staticFlowable<Long>`	`interval(long period,TimeUnit unit)` Returns a Flowable that emits a sequential number every specified interval of time.
`staticFlowable<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.
`staticFlowable<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.
`staticFlowable<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<? superT,? extendsPublisher<TLeftEnd>> leftEnd,Function<? super TRight,? extendsPublisher<TRightEnd>> rightEnd,BiFunction<? superT,? 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,? superT> 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<? superT,? 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 emissionsand notifications from the source Publisher into emissions marked with their original types within`Notification` objects.
`static <T> Flowable<T>`	`merge(Iterable<? extendsPublisher<? extends T>> sources)` Flattens an Iterable of Publishers into one Publisher, without any transformation.
`static <T> Flowable<T>`	`merge(Iterable<? extendsPublisher<? 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<? extendsPublisher<? 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<? extendsPublisher<? 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<? extendsPublisher<? 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<? extendsPublisher<? 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<? extendsPublisher<? 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<? extendsPublisher<? 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<? extendsPublisher<? 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<? extendsPublisher<? 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<? extendsT> 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<? extendsT> other)` Flattens this and another Publisher into a single Publisher, without any transformation.
`Flowable<T>`	`mergeWith(SingleSource<? extendsT> 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<? superT> 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<? superThrowable,? extendsPublisher<? extendsT>> resumeFunction)` Instructs a Publisher to pass control to another Publisher rather than invoking`onError` if it encounters an error.
`Flowable<T>`	`onErrorResumeNext(Publisher<? extendsT> next)` Instructs a Publisher to pass control to another Publisher rather than invoking`onError` if it encounters an error.
`Flowable<T>`	`onErrorReturn(Function<? superThrowable,? extendsT> 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<? extendsT> 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`Subscriber`s that have subscribed to it.
`<R> Flowable<R>`	`publish(Function<? superFlowable<T>,? extendsPublisher<? 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<? superFlowable<T>,? extendsPublisher<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`Subscriber`s that have subscribed to it.
`staticFlowable<Integer>`	`range(int start, int count)` Returns a Flowable that emits a sequence of Integers within a specified range.
`staticFlowable<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,? superT,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,? superT,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<? superFlowable<Object>,? extendsPublisher<?>> 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<? superFlowable<T>,? extendsPublisher<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<? superFlowable<T>,? extendsPublisher<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<? superFlowable<T>,? extendsPublisher<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<? superFlowable<T>,? extendsPublisher<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<? superFlowable<T>,? extendsPublisher<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<? superFlowable<T>,? extendsPublisher<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<? superFlowable<T>,? extendsPublisher<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<? superFlowable<T>,? extendsPublisher<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<? superInteger,? superThrowable> 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<? superThrowable> predicate)` Retries at most times or until the predicate returns false, whichever happens first.
`Flowable<T>`	`retry(Predicate<? superThrowable> 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<? superFlowable<Throwable>,? extendsPublisher<?>> handler)` Returns a Flowable that emits the same values as the source Publisher with the exception of an`onError`.
`void`	`safeSubscribe(Subscriber<? superT> 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,? superT,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,? superT,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 obeythe 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<? superT> 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<? superT> 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<? extendsT> 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<? extendsT> 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<? superT> onNext)` Subscribes to a Publisher and provides a callback to handle the items it emits.
`Disposable`	`subscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError)` Subscribes to a Publisher and provides callbacks to handle the items it emits and any error notification it issues.
`Disposable`	`subscribe(Consumer<? superT> onNext,Consumer<? superThrowable> 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<? superT> onNext,Consumer<? superThrowable> onError,Action onComplete,Consumer<? superSubscription> 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<? superT> 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<? superT> s)`
`protected abstract void`	`subscribeActual(Subscriber<? superT> s)` Operator implementations (both source and intermediate) should implement this method that performs the necessary business logic and handles the incoming`Subscriber`s.
`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 extendsSubscriber<? superT>> E`	`subscribeWith(E subscriber)` Subscribes a given Subscriber (subclass) to this Flowable and returns the given Subscriber as is.
`Flowable<T>`	`switchIfEmpty(Publisher<? extendsT> 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<? superT,? extendsPublisher<? 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<? superT,? extendsPublisher<? 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<? superT,? extendsCompletableSource> mapper)` Maps the upstream values into`CompletableSource`s, subscribes to the newer one while disposing the subscription to the previous`CompletableSource`, thus keeping at most one active`CompletableSource` running.
`Completable`	`switchMapCompletableDelayError(Function<? superT,? extendsCompletableSource> mapper)` Maps the upstream values into`CompletableSource`s, 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<? superT,? extendsPublisher<? 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<? superT,? extendsPublisher<? 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<? superT,? extendsMaybeSource<? extends R>> mapper)` Maps the upstream items into`MaybeSource`s 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`MaybeSource`s fail.
`<R> Flowable<R>`	`switchMapMaybeDelayError(Function<? superT,? extendsMaybeSource<? extends R>> mapper)` Maps the upstream items into`MaybeSource`s 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`MaybeSource`s until all terminate.
`<R> Flowable<R>`	`switchMapSingle(Function<? superT,? extendsSingleSource<? extends R>> mapper)` Maps the upstream items into`SingleSource`s 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`SingleSource`s fail.
`<R> Flowable<R>`	`switchMapSingleDelayError(Function<? superT,? extendsSingleSource<? extends R>> mapper)` Maps the upstream items into`SingleSource`s 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`SingleSource`s until all terminate.
`static <T> Flowable<T>`	`switchOnNext(Publisher<? extendsPublisher<? 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<? extendsPublisher<? 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<? extendsPublisher<? 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<? extendsPublisher<? 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<? superT> 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<? superT> 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<? superT,? extendsPublisher<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<? superT,? extendsPublisher<V>> itemTimeoutIndicator,Flowable<? extendsT> 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<? extendsT> 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<? extendsT> 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<? superT,? extendsPublisher<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<? superT,? extendsPublisher<V>> itemTimeoutIndicator,Publisher<? extendsT> 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.
`staticFlowable<Long>`	`timer(long delay,TimeUnit unit)` Returns a Flowable that emits`0L` after a specified delay, and then completes.
`staticFlowable<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<? superFlowable<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 extendsCollection<? superT>> 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<? superT,? 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<? superT,? extends K> keySelector,Function<? superT,? 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<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector,Callable<? extendsMap<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<? superT,? 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<? superT,? extends K> keySelector,Function<? superT,? 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<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector,Callable<? extendsMap<K,Collection<V>>> mapSupplier,Function<? super K,? extendsCollection<? 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<? superT,? extends K> keySelector,Function<? superT,? 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<? superT> 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<? superT> 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 Publisherwhich 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,? extendsPublisher<? 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,? extendsPublisher<? 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<? extendsPublisher<B>> boundaryIndicatorSupplier)` Returns a Flowable that emits windows of items it collects from the source Publisher.
`<B> Flowable<Flowable<T>>`	`window(Callable<? extendsPublisher<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,? extendsPublisher<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,? extendsPublisher<V>> closingIndicator, int bufferSize)` Returns a Flowable that emits windows of items it collects from the source Publisher.
`<R> Flowable<R>`	`withLatestFrom(Iterable<? extendsPublisher<?>> others,Function<? superObject[],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<? superObject[],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<? superT,? 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<? superT,? 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<? superT,? 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<? superT,? 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<? extendsPublisher<? extends T>> sources,Function<? superObject[],? 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<? extendsPublisher<? extends T>> sources,Function<? superObject[],? extends R> zipper)` Returns a Flowable that emits the results of a specified combiner function applied to combinations ofn items emitted, in sequence, by then 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<? superObject[],? 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<? extendsPublisher<? extends T>> sources,Function<? superObject[],? 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<? superT,? 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<? superT,? 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<? superT,? 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<? superT,? 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<? extendsPublisher<? 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 winningPublisher's backpressure behavior.
 Scheduler:
 amb does not operate by default on a particularScheduler.
 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 winningPublisher's backpressure behavior.
 Scheduler:
 ambArray does not operate by default on a particularScheduler.
 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 parameterrx2.buffer-sizebefore 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<? superObject[],? 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 withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.
 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 returnedPublisher honors backpressure from downstream. The sourcePublishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signalMissingBackpressureException) and may lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 combineLatest does not operate by default on a particularScheduler.
 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<? superObject[],? 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 withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.
 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 returnedPublisher honors backpressure from downstream. The sourcePublishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signalMissingBackpressureException) and may lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 combineLatest does not operate by default on a particularScheduler.
 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<? superObject[],? 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 withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.
 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 returnedPublisher honors backpressure from downstream. The sourcePublishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signalMissingBackpressureException) and may lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 combineLatest does not operate by default on a particularScheduler.
 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<? extendsPublisher<? extends T>> sources,Function<? superObject[],? 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 withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.
 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 returnedPublisher honors backpressure from downstream. The sourcePublishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signalMissingBackpressureException) and may lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 combineLatest does not operate by default on a particularScheduler.
 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<? extendsPublisher<? extends T>> sources,Function<? superObject[],? 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 withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.
 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 returnedPublisher honors backpressure from downstream. The sourcePublishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signalMissingBackpressureException) and may lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 combineLatest does not operate by default on a particularScheduler.
 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<? superObject[],? 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 withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.
 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 returnedPublisher honors backpressure from downstream. The sourcePublishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signalMissingBackpressureException) and may lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 combineLatestDelayError does not operate by default on a particularScheduler.
 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<? superObject[],? 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 withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.
 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 returnedPublisher honors backpressure from downstream. The sourcePublishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signalMissingBackpressureException) and may lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 combineLatestDelayError does not operate by default on a particularScheduler.
 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<? superObject[],? 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 withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.
 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 returnedPublisher honors backpressure from downstream. The sourcePublishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signalMissingBackpressureException) and may lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 combineLatestDelayError does not operate by default on a particularScheduler.
 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<? superObject[],? 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 withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.
 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 returnedPublisher honors backpressure from downstream. The sourcePublishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signalMissingBackpressureException) and may lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 combineLatestDelayError does not operate by default on a particularScheduler.
 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<? extendsPublisher<? extends T>> sources,Function<? superObject[],? 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 withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.
 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 returnedPublisher honors backpressure from downstream. The sourcePublishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signalMissingBackpressureException) and may lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 combineLatestDelayError does not operate by default on a particularScheduler.
 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<? extendsPublisher<? extends T>> sources,Function<? superObject[],? 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 withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.
 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 returnedPublisher honors backpressure from downstream. The sourcePublishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signalMissingBackpressureException) and may lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 combineLatestDelayError does not operate by default on a particularScheduler.
 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 returnedPublisher honors backpressure from downstream. The sourcePublishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signalMissingBackpressureException) and may lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 combineLatest does not operate by default on a particularScheduler.
 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 returnedPublisher honors backpressure from downstream. The sourcePublishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signalMissingBackpressureException) and may lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 combineLatest does not operate by default on a particularScheduler.
 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 returnedPublisher honors backpressure from downstream. The sourcePublishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signalMissingBackpressureException) and may lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 combineLatest does not operate by default on a particularScheduler.
 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 returnedPublisher honors backpressure from downstream. The sourcePublishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signalMissingBackpressureException) and may lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 combineLatest does not operate by default on a particularScheduler.
 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 returnedPublisher honors backpressure from downstream. The sourcePublishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signalMissingBackpressureException) and may lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 combineLatest does not operate by default on a particularScheduler.
 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 returnedPublisher honors backpressure from downstream. The sourcePublishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signalMissingBackpressureException) and may lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 combineLatest does not operate by default on a particularScheduler.
 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 returnedPublisher honors backpressure from downstream. The sourcePublishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signalMissingBackpressureException) and may lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 combineLatest does not operate by default on a particularScheduler.
 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 returnedPublisher honors backpressure from downstream. The sourcePublishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signalMissingBackpressureException) and may lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 combineLatest does not operate by default on a particularScheduler.
 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<? extendsPublisher<? 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. ThePublisher sources are expected to honor backpressure as well. If any of the sourcePublishers violate this, itmay throw anIllegalStateException when the sourcePublisher completes.
 Scheduler:
 concat does not operate by default on a particularScheduler.
 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<? extendsPublisher<? 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 innerPublisher sources are expected to honor backpressure as well. If the outer violates this, aMissingBackpressureException is signaled. If any of the innerPublishers violates this, itmay throw anIllegalStateException when an innerPublisher completes.
 Scheduler:
 concat does not operate by default on a particularScheduler.
 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 byPublishers, 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<? extendsPublisher<? 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 innerPublisher sources are expected to honor backpressure as well. If the outer violates this, aMissingBackpressureException is signaled. If any of the innerPublishers violates this, itmay throw anIllegalStateException when an innerPublisher completes.
 Scheduler:
 concat does not operate by default on a particularScheduler.
 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 byPublishers, 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. ThePublisher sources are expected to honor backpressure as well. If any of the sourcePublishers violate this, itmay throw anIllegalStateException when the sourcePublisher completes.
 Scheduler:
 concat does not operate by default on a particularScheduler.
 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. ThePublisher sources are expected to honor backpressure as well. If any of the sourcePublishers violate this, itmay throw anIllegalStateException when the sourcePublisher completes.
 Scheduler:
 concat does not operate by default on a particularScheduler.
 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. ThePublisher sources are expected to honor backpressure as well. If any of the sourcePublishers violate this, itmay throw anIllegalStateException when the sourcePublisher completes.
 Scheduler:
 concat does not operate by default on a particularScheduler.
 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. ThePublisher sources are expected to honor backpressure as well. If any of the sourcePublishers violate this, itmay throw anIllegalStateException when the sourcePublisher completes.
 Scheduler:
 concatArray does not operate by default on a particularScheduler.
 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. ThePublisher sources are expected to honor backpressure as well. If any of the sourcePublishers violate this, itmay throw anIllegalStateException when the sourcePublisher completes.
 Scheduler:
 concatArrayDelayError does not operate by default on a particularScheduler.
 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. ThePublisher sources are expected to honor backpressure as well. If any of the sourcePublishers violate this, the operator will signal aMissingBackpressureException.
 Scheduler:
 This method does not operate by default on a particularScheduler.
 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. ThePublisher sources are expected to honor backpressure as well. If any of the sourcePublishers violate this, the operator will signal aMissingBackpressureException.
 Scheduler:
 This method does not operate by default on a particularScheduler.
 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 ofPublishers 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 sourcePublishers. The operator buffers the values emitted by thesePublishers and then drains them in order, each one after the previous one completes.
 Backpressure:
 The operator honors backpressure from downstream. ThePublisher sources are expected to honor backpressure as well. If any of the sourcePublishers violate this, the operator will signal aMissingBackpressureException.
 Scheduler:
 This method does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - an array ofPublishers 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 ofPublishers 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 sourcePublishers. The operator buffers the values emitted by thesePublishers and then drains them in order, each one after the previous one completes.
 Backpressure:
 The operator honors backpressure from downstream. ThePublisher sources are expected to honor backpressure as well. If any of the sourcePublishers violate this, the operator will signal aMissingBackpressureException.
 Scheduler:
 This method does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - an array ofPublishers 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 eachPublisher 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<? extendsPublisher<? 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 innerPublisher sources are expected to honor backpressure as well. If the outer violates this, aMissingBackpressureException is signaled. If any of the innerPublishers violates this, itmay throw anIllegalStateException when an innerPublisher completes.
 Scheduler:
 concatDelayError does not operate by default on a particularScheduler.
 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<? extendsPublisher<? 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 particularScheduler.
 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<? extendsPublisher<? 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 particularScheduler.
 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<? extendsPublisher<? 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 signalMissingBackpressureException.
 Scheduler:
 This method does not operate by default on a particularScheduler.
 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<? extendsPublisher<? 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 signalMissingBackpressureException.
 Scheduler:
 This method does not operate by default on a particularScheduler.
 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<? extendsPublisher<? 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 signalMissingBackpressureException.
 Scheduler:
 This method does not operate by default on a particularScheduler.
 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<? extendsPublisher<? 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 signalMissingBackpressureException.
 Scheduler:
 This method does not operate by default on a particularScheduler.
 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 themode parameter.
 Scheduler:
 create does not operate by default on a particularScheduler.
 Type Parameters:
 T - the element type
 Parameters:
 source - the emitter that is called when a Subscriber subscribes to the returnedFlowable
 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<? extendsPublisher<? 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 aSubscriber to easily obtain updates or a refreshed version of the sequence.
 Backpressure:
 The operator itself doesn't interfere with backpressure which is determined by thePublisher returned by thesupplier.
 Scheduler:
 defer does not operate by default on a particularScheduler.
 Type Parameters:
 T - the type of the items emitted by the Publisher
 Parameters:
 supplier - the Publisher factory function to invoke for eachSubscriber that subscribes to the resulting Publisher
 Returns:
 a Flowable whoseSubscribers' 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 theSubscriber and immediately invokes itsonComplete method.
 Backpressure:
 This source doesn't produce any elements and effectively ignores downstream backpressure.
 Scheduler:
 empty does not operate by default on a particularScheduler.
 Type Parameters:
 T - the type of the items (ostensibly) emitted by the Publisher
 Returns:
 a Flowable that emits no items to theSubscriber but immediately invokes theSubscriber'sonComplete method
 See Also:
 ReactiveX operators documentation: Empty
 - error
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public static <T> Flowable<T> error(Callable<? extendsThrowable> supplier)
```
 Returns a Flowable that invokes aSubscriber'sonError 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 particularScheduler.
 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 theSubscriber'sonError 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 aSubscriber'sonError 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 particularScheduler.
 Type Parameters:
 T - the type of the items (ostensibly) emitted by the Publisher
 Parameters:
 throwable - the particular Throwable to pass toonError
 Returns:
 a Flowable that invokes theSubscriber'sonError 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 givenarray on demand (i.e., when requested).
 Scheduler:
 fromArray does not operate by default on a particularScheduler.
 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 particularScheduler.
 Error handling:
 If theCallable throws an exception, the respectiveThrowable is delivered to the downstream viaSubscriber.onError(Throwable), except when the downstream has canceled thisFlowable source. In this latter case, theThrowable is delivered to the global error handler viaRxJavaPlugins.onError(Throwable) as anUndeliverableException.
 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 thatfromCallable returns
 Returns:
 a Flowable whoseSubscribers' 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 aFuture into a Publisher.
 You can convert any object that supports theFuture interface into a Publisher that emits the return value of theFuture.get() method of that object by passing the object into thefrom 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 particularScheduler.
 Type Parameters:
 T - the type of object that theFuture returns, and also the type of item to be emitted by the resulting Publisher
 Parameters:
 future - the sourceFuture
 Returns:
 a Flowable that emits the item from the sourceFuture
 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 aFuture into a Publisher, with a timeout on the Future.
 You can convert any object that supports theFuture interface into a Publisher that emits the return value of theFuture.get() method of that object by passing the object into thefromFuture 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 particularScheduler.
 Type Parameters:
 T - the type of object that theFuture returns, and also the type of item to be emitted by the resulting Publisher
 Parameters:
 future - the sourceFuture
 timeout - the maximum time to wait before callingget
 unit - theTimeUnit of thetimeout argument
 Returns:
 a Flowable that emits the item from the sourceFuture
 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 aFuture into a Publisher, with a timeout on the Future.
 You can convert any object that supports theFuture interface into a Publisher that emits the return value of theFuture.get() method of that object by passing the object into thefrom 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 particularScheduler.
 Type Parameters:
 T - the type of object that theFuture returns, and also the type of item to be emitted by the resulting Publisher
 Parameters:
 future - the sourceFuture
 timeout - the maximum time to wait before callingget
 unit - theTimeUnit of thetimeout argument
 scheduler - theScheduler to wait for the Future on. Use a Scheduler such asSchedulers.io() that can block and wait on the Future
 Returns:
 a Flowable that emits the item from the sourceFuture
 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 aFuture, operating on a specifiedScheduler, into a Publisher.
 You can convert any object that supports theFuture interface into a Publisher that emits the return value of theFuture.get() method of that object by passing the object into thefrom 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 whichScheduler this operator will use.
 Type Parameters:
 T - the type of object that theFuture returns, and also the type of item to be emitted by the resulting Publisher
 Parameters:
 future - the sourceFuture
 scheduler - theScheduler to wait for the Future on. Use a Scheduler such asSchedulers.io() that can block and wait on the Future
 Returns:
 a Flowable that emits the item from the sourceFuture
 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 anIterable sequence into a Publisher that emits the items in the sequence.
 Backpressure:
 The operator honors backpressure from downstream and iterates the giveniterable on demand (i.e., when requested).
 Scheduler:
 fromIterable does not operate by default on a particularScheduler.
 Type Parameters:
 T - the type of items in theIterable sequence and the type of items to be emitted by the resulting Publisher
 Parameters:
 source - the sourceIterable sequence
 Returns:
 a Flowable that emits each item in the sourceIterable 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.
 ThePublisher must follow theReactive Streams specification. Violating the specification may result in undefined behavior.
 If possible, usecreate(FlowableOnSubscribe, BackpressureStrategy) to create a source-likeFlowable instead.
 Note that even thoughPublisher 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 particularScheduler.
 Type Parameters:
 T - the value type of the flow
 Parameters:
 source - the Publisher to convert
 Returns:
 the new Flowable instance
 Throws:
 NullPointerException - if thesourcePublisher 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 theEmitter.onNext(T),Emitter.onError(java.lang.Throwable) andEmitter.onComplete() methods provided to the function via theEmitter 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 particularScheduler.
 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 callonNext,onError oronComplete to signal a value or a terminal event. Signaling multipleonNext in a call will make the operator signalIllegalStateException.
 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 theEmitter.onNext(T),Emitter.onError(java.lang.Throwable) andEmitter.onComplete() methods provided to the function via theEmitter 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 particularScheduler.
 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 callonNext,onError oronComplete to signal a value or a terminal event. Signaling multipleonNext in a call will make the operator signalIllegalStateException.
 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 theEmitter.onNext(T),Emitter.onError(java.lang.Throwable) andEmitter.onComplete() methods provided to the function via theEmitter 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 particularScheduler.
 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 callonNext,onError oronComplete to signal a value or a terminal event. Signaling multipleonNext in a call will make the operator signalIllegalStateException.
 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 theEmitter.onNext(T),Emitter.onError(java.lang.Throwable) andEmitter.onComplete() methods provided to the function via theEmitter 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 particularScheduler.
 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 callonNext,onError oronComplete to signal a value or a terminal event and should return a (new) state for the next invocation. Signaling multipleonNext in a call will make the operator signalIllegalStateException.
 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 theEmitter.onNext(T),Emitter.onError(java.lang.Throwable) andEmitter.onComplete() methods provided to the function via theEmitter 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 particularScheduler.
 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 callonNext,onError oronComplete to signal a value or a terminal event and should return a (new) state for the next invocation. Signaling multipleonNext in a call will make the operator signalIllegalStateException.
 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 a0L after theinitialDelay and ever-increasing numbers after eachperiod of time thereafter.
 Backpressure:
 The operator generates values based on time and ignores downstream backpressure which may lead toMissingBackpressureException at some point in the chain. Consumers should consider applying one of theonBackpressureXXX operators as well.
 Scheduler:
 interval operates by default on thecomputationScheduler.
 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 bothinitialDelay andperiod
 Returns:
 a Flowable that emits a 0L after theinitialDelay and ever-increasing numbers after eachperiod 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 a0L after theinitialDelay and ever-increasing numbers after eachperiod of time thereafter, on a specifiedScheduler.
 Backpressure:
 The operator generates values based on time and ignores downstream backpressure which may lead toMissingBackpressureException at some point in the chain. Consumers should consider applying one of theonBackpressureXXX operators as well.
 Scheduler:
 You specify whichScheduler 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 bothinitialDelay andperiod
 scheduler - the Scheduler on which the waiting happens and items are emitted
 Returns:
 a Flowable that emits a 0L after theinitialDelay and ever-increasing numbers after eachperiod 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 aMissingBackpressureException if the downstream is not ready to receive the next value.
 Scheduler:
 interval operates by default on thecomputationScheduler.
 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 toMissingBackpressureException at some point in the chain. Consumers should consider applying one of theonBackpressureXXX operators as well.
 Scheduler:
 You specify whichScheduler 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 aMissingBackpressureException if the downstream can't keep up.
 Scheduler:
 intervalRange by default operates on thecomputationScheduler.
 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 aMissingBackpressureException if the downstream can't keep up.
 Scheduler:
 you provide theScheduler.
 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 byjust. UsefromCallable(Callable) to generate a single item on demand (whenSubscribers subscribe to it).
 See the multi-parameter overloads ofjust to emit more than one (constant reference) items one after the other. UsefromArray(Object...) to emit an arbitrary number of items that are known upfront.
 To emit the items of anIterable sequence (such as aList), usefromIterable(Iterable).
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 just does not operate by default on a particularScheduler.
 Type Parameters:
 T - the type of that item
 Parameters:
 item - the item to emit
 Returns:
 a Flowable that emitsvalue 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 particularScheduler.
 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 particularScheduler.
 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 particularScheduler.
 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 particularScheduler.
 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 particularScheduler.
 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 particularScheduler.
 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 particularScheduler.
 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 particularScheduler.
 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 particularScheduler.
 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<? extendsPublisher<? 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 themerge method.
 Backpressure:
 The operator honors backpressure from downstream. The sourcePublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 merge does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourcePublishers signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourcePublishers are canceled. If more than onePublisher signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException 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 viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(Iterable, int, int) to merge sources and terminate only when all sourcePublishers 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 - ifmaxConcurrency 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 themerge method.
 Backpressure:
 The operator honors backpressure from downstream. The sourcePublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 mergeArray does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourcePublishers signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourcePublishers are canceled. If more than onePublisher signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException 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 viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. UsemergeArrayDelayError(int, int, Publisher[]) to merge sources and terminate only when all sourcePublishers 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 - ifmaxConcurrency 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<? extendsPublisher<? 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 themerge method.
 Backpressure:
 The operator honors backpressure from downstream. The sourcePublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 merge does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourcePublishers signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourcePublishers are canceled. If more than onePublisher signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException 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 viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(Iterable) to merge sources and terminate only when all sourcePublishers 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<? extendsPublisher<? 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 themerge method.
 Backpressure:
 The operator honors backpressure from downstream. The sourcePublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 merge does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourcePublishers signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourcePublishers are canceled. If more than onePublisher signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException 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 viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(Iterable, int) to merge sources and terminate only when all sourcePublishers 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 - ifmaxConcurrency 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<? extendsPublisher<? 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 themerge method.
 Backpressure:
 The operator honors backpressure from downstream. The outerPublisher is consumed in unbounded mode (i.e., no backpressure is applied to it). The innerPublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 merge does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourcePublishers signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourcePublishers are canceled. If more than onePublisher signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException 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 viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(Publisher) to merge sources and terminate only when all sourcePublishers 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 thesource Publisher
 See Also:
 ReactiveX operators documentation: Merge,mergeDelayError(Publisher)
 - merge
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public static <T> Flowable<T> merge(Publisher<? extendsPublisher<? 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 themerge method.
 Backpressure:
 The operator honors backpressure from downstream. Both the outer and innerPublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 merge does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourcePublishers signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourcePublishers are canceled. If more than onePublisher signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException 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 viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(Publisher, int) to merge sources and terminate only when all sourcePublishers 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 thesource Publisher
 Throws:
 IllegalArgumentException - ifmaxConcurrency 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 themerge method.
 Backpressure:
 The operator honors backpressure from downstream. The sourcePublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 mergeArray does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourcePublishers signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourcePublishers are canceled. If more than onePublisher signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException 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 viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. UsemergeArrayDelayError(Publisher...) to merge sources and terminate only when all sourcePublishers 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 themerge method.
 Backpressure:
 The operator honors backpressure from downstream. The sourcePublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 merge does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourcePublishers signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourcePublishers are canceled. If more than onePublisher signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException 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 viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(Publisher, Publisher) to merge sources and terminate only when all sourcePublishers 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 themerge method.
 Backpressure:
 The operator honors backpressure from downstream. The sourcePublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 merge does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourcePublishers signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourcePublishers are canceled. If more than onePublisher signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException 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 viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(Publisher, Publisher, Publisher) to merge sources and terminate only when all sourcePublishers 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 themerge method.
 Backpressure:
 The operator honors backpressure from downstream. The sourcePublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 merge does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourcePublishers signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourcePublishers are canceled. If more than onePublisher signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException 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 viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(Publisher, Publisher, Publisher, Publisher) to merge sources and terminate only when all sourcePublishers 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<? extendsPublisher<? 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 likemerge(Publisher) except that if any of the merged Publishers notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.
 Even if multiple merged Publishers sendonError notifications,mergeDelayError will only invoke theonError method of its Subscribers once.
 Backpressure:
 The operator honors backpressure from downstream. All innerPublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 mergeDelayError does not operate by default on a particularScheduler.
 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<? extendsPublisher<? 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 likemerge(Publisher) except that if any of the merged Publishers notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.
 Even if multiple merged Publishers sendonError notifications,mergeDelayError will only invoke theonError method of its Subscribers once.
 Backpressure:
 The operator honors backpressure from downstream. All innerPublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 mergeDelayError does not operate by default on a particularScheduler.
 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 likemerge(Publisher) except that if any of the merged Publishers notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.
 Even if multiple merged Publishers sendonError notifications,mergeDelayError will only invoke theonError method of its Subscribers once.
 Backpressure:
 The operator honors backpressure from downstream. All sourcePublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 mergeArrayDelayError does not operate by default on a particularScheduler.
 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<? extendsPublisher<? 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 likemerge(Publisher) except that if any of the merged Publishers notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.
 Even if multiple merged Publishers sendonError notifications,mergeDelayError will only invoke theonError method of its Subscribers once.
 Backpressure:
 The operator honors backpressure from downstream. All innerPublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 mergeDelayError does not operate by default on a particularScheduler.
 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<? extendsPublisher<? 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 likemerge(Publisher) except that if any of the merged Publishers notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.
 Even if multiple merged Publishers sendonError notifications,mergeDelayError will only invoke theonError method of its Subscribers once.
 Backpressure:
 The operator honors backpressure from downstream. The outerPublisher is consumed in unbounded mode (i.e., no backpressure is applied to it). The innerPublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 mergeDelayError does not operate by default on a particularScheduler.
 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 thesource Publisher
 See Also:
 ReactiveX operators documentation: Merge
 - mergeDelayError
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public static <T> Flowable<T> mergeDelayError(Publisher<? extendsPublisher<? 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 likemerge(Publisher) except that if any of the merged Publishers notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.
 Even if multiple merged Publishers sendonError notifications,mergeDelayError will only invoke theonError method of its Subscribers once.
 Backpressure:
 The operator honors backpressure from downstream. Both the outer and innerPublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 mergeDelayError does not operate by default on a particularScheduler.
 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 thesource 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 likemerge(Publisher) except that if any of the merged Publishers notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.
 Even if multiple merged Publishers sendonError notifications,mergeDelayError will only invoke theonError method of its Subscribers once.
 Backpressure:
 The operator honors backpressure from downstream. Both the outer and innerPublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 mergeArrayDelayError does not operate by default on a particularScheduler.
 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 likemerge(Publisher, Publisher) except that if any of the merged Publishers notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.
 Even if both merged Publishers sendonError notifications,mergeDelayError will only invoke theonError method of its Subscribers once.
 Backpressure:
 The operator honors backpressure from downstream. The sourcePublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 mergeDelayError does not operate by default on a particularScheduler.
 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 likemerge(Publisher, Publisher, Publisher) except that if any of the merged Publishers notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.
 Even if multiple merged Publishers sendonError notifications,mergeDelayError will only invoke theonError method of its Subscribers once.
 Backpressure:
 The operator honors backpressure from downstream. The sourcePublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 mergeDelayError does not operate by default on a particularScheduler.
 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 likemerge(Publisher, Publisher, Publisher, Publisher) except that if any of the merged Publishers notify of an error viaonError,mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.
 Even if multiple merged Publishers sendonError notifications,mergeDelayError will only invoke theonError method of its Subscribers once.
 Backpressure:
 The operator honors backpressure from downstream. The sourcePublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 mergeDelayError does not operate by default on a particularScheduler.
 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 aSubscriber.
 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 particularScheduler.
 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 aSubscriber
 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 particularScheduler.
 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 - ifcount is less than zero, or ifstart +count − 1 exceedsInteger.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 particularScheduler.
 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 - ifcount is less than zero, or ifstart +count − 1 exceedsLong.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 particularScheduler.
 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 sourcePublishers are expected to honor backpressure; if violated, the operator signals aMissingBackpressureException.
 Scheduler:
 sequenceEqual does not operate by default on a particularScheduler.
 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 sourcePublishers are expected to honor backpressure; if violated, the operator signals aMissingBackpressureException.
 Scheduler:
 sequenceEqual does not operate by default on a particularScheduler.
 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 particularScheduler.
 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<? extendsPublisher<? 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 byswitchOnNext 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 outerPublisher is consumed in an unbounded manner (i.e., without backpressure) and the innerPublishers are expected to honor backpressure but it is not enforced; the operator won't signal aMissingBackpressureException but the violationmay lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 switchOnNext does not operate by default on a particularScheduler.
 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<? extendsPublisher<? 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 byswitchOnNext 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 outerPublisher is consumed in an unbounded manner (i.e., without backpressure) and the innerPublishers are expected to honor backpressure but it is not enforced; the operator won't signal aMissingBackpressureException but the violationmay lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 switchOnNext does not operate by default on a particularScheduler.
 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<? extendsPublisher<? 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 byswitchOnNext 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 outerPublisher is consumed in an unbounded manner (i.e., without backpressure) and the innerPublishers are expected to honor backpressure but it is not enforced; the operator won't signal aMissingBackpressureException but the violationmay lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 switchOnNextDelayError does not operate by default on a particularScheduler.
 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<? extendsPublisher<? 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 byswitchOnNext 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 outerPublisher is consumed in an unbounded manner (i.e., without backpressure) and the innerPublishers are expected to honor backpressure but it is not enforced; the operator won't signal aMissingBackpressureException but the violationmay lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 switchOnNextDelayError does not operate by default on a particularScheduler.
 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 emits0L 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 likeonBackpressureDrop().
 Scheduler:
 timer operates by default on thecomputationScheduler.
 Parameters:
 delay - the initial delay before emitting a single0L
 unit - time units to use fordelay
 Returns:
 a Flowable that emits0L 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 emits0L 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 likeonBackpressureDrop().
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 delay - the initial delay before emitting a single 0L
 unit - time units to use fordelay
 scheduler - theScheduler to use for scheduling the item
 Returns:
 a Flowable that emits0L 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 Publisherwhich 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 particularScheduler.
 Type Parameters:
 T - the value type emitted
 Parameters:
 onSubscribe - the Publisher instance to wrap
 Returns:
 the new Flowable instance
 Throws:
 IllegalArgumentException - ifonSubscribe is a subclass ofFlowable; such instances don't need conversion and is possibly a port remnant from 1.x or one should usehide() instead.
 - using
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public static <T,D> Flowable<T> using(Callable<? extends D> resourceSupplier,Function<? super D,? extendsPublisher<? 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 theresourceFactory.
 Scheduler:
 using does not operate by default on a particularScheduler.
 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,? extendsPublisher<? 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 setdisposeEagerly totrue 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 theresourceFactory.
 Scheduler:
 using does not operate by default on a particularScheduler.
 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 - iftrue then disposal will happen either on cancellation or just before emission of a terminal event (onComplete oronError).
 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<? extendsPublisher<? extends T>> sources,Function<? superObject[],? 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 resultingPublisher<R> returned fromzip will invokeonNext as many times as the number ofonNext 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 callingdoOnComplete()). 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 butaction2 won't.
 To work around this termination property, usedoOnCancel(Action) as well or useusing() 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 withinterval(long, TimeUnit) may result in MissingBackpressureException, use one of theonBackpressureX to handle similar, backpressure-ignoring sources.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 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<? extendsPublisher<? extends T>> sources,Function<? superObject[],? extends R> zipper)
```
 Returns a Flowable that emits the results of a specified combiner function applied to combinations ofn items emitted, in sequence, by then 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 resultingPublisher<R> returned fromzip will invokeonNext as many times as the number ofonNext 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 callingdoOnComplete()). 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 butaction2 won't.
 To work around this termination property, usedoOnCancel(Action) as well or useusing() 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 withinterval(long, TimeUnit) may result in MissingBackpressureException, use one of theonBackpressureX to handle similar, backpressure-ignoring sources.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 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 byws, 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 byo1 and the first item emitted byo2; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted byo1 and the second item emitted byo2; and so forth.
 The resultingPublisher<R> returned fromzip will invokeonNext as many times as the number ofonNext 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 callingdoOnComplete()). 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 butaction2 won't.
 To work around this termination property, usedoOnCancel(Action) as well or useusing() 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 withinterval(long, TimeUnit) may result in MissingBackpressureException, use one of theonBackpressureX to handle similar, backpressure-ignoring sources.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 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 byo1 and the first item emitted byo2; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted byo1 and the second item emitted byo2; and so forth.
 The resultingPublisher<R> returned fromzip will invokeonNext as many times as the number ofonNext 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 callingdoOnComplete()). 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 butaction2 won't.
 To work around this termination property, usedoOnCancel(Action) as well or useusing() 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 withinterval(long, TimeUnit) may result in MissingBackpressureException, use one of theonBackpressureX to handle similar, backpressure-ignoring sources.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 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 byo1 and the first item emitted byo2; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted byo1 and the second item emitted byo2; and so forth.
 The resultingPublisher<R> returned fromzip will invokeonNext as many times as the number ofonNext 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 callingdoOnComplete()). 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 butaction2 won't.
 To work around this termination property, usedoOnCancel(Action) as well or useusing() 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 withinterval(long, TimeUnit) may result in MissingBackpressureException, use one of theonBackpressureX to handle similar, backpressure-ignoring sources.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 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 byo1, the first item emitted byo2, and the first item emitted byo3; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted byo1, the second item emitted byo2, and the second item emitted byo3; and so forth.
 The resultingPublisher<R> returned fromzip will invokeonNext as many times as the number ofonNext 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 callingdoOnComplete()). 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 butaction2 won't.
 To work around this termination property, usedoOnCancel(Action) as well or useusing() 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 withinterval(long, TimeUnit) may result in MissingBackpressureException, use one of theonBackpressureX to handle similar, backpressure-ignoring sources.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 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 byo1, the first item emitted byo2, the first item emitted byo3, and the first item emitted by04; 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 resultingPublisher<R> returned fromzip will invokeonNext as many times as the number ofonNext 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 callingdoOnComplete()). 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 butaction2 won't.
 To work around this termination property, usedoOnCancel(Action) as well or useusing() 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 withinterval(long, TimeUnit) may result in MissingBackpressureException, use one of theonBackpressureX to handle similar, backpressure-ignoring sources.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 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 byo1, the first item emitted byo2, the first item emitted byo3, the first item emitted byo4, and the first item emitted byo5; 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 resultingPublisher<R> returned fromzip will invokeonNext as many times as the number ofonNext 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 callingdoOnComplete()). 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 butaction2 won't.
 To work around this termination property, usedoOnCancel(Action) as well or useusing() 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 withinterval(long, TimeUnit) may result in MissingBackpressureException, use one of theonBackpressureX to handle similar, backpressure-ignoring sources.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 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 resultingPublisher<R> returned fromzip will invokeonNext as many times as the number ofonNext 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 callingdoOnComplete()). 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 butaction2 won't.
 To work around this termination property, usedoOnCancel(Action) as well or useusing() 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 withinterval(long, TimeUnit) may result in MissingBackpressureException, use one of theonBackpressureX to handle similar, backpressure-ignoring sources.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 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 resultingPublisher<R> returned fromzip will invokeonNext as many times as the number ofonNext 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 callingdoOnComplete()). 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 butaction2 won't.
 To work around this termination property, usedoOnCancel(Action) as well or useusing() 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 withinterval(long, TimeUnit) may result in MissingBackpressureException, use one of theonBackpressureX to handle similar, backpressure-ignoring sources.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 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 resultingPublisher<R> returned fromzip will invokeonNext as many times as the number ofonNext 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 callingdoOnComplete()). 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 butaction2 won't.
 To work around this termination property, usedoOnCancel(Action) as well or useusing() 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 withinterval(long, TimeUnit) may result in MissingBackpressureException, use one of theonBackpressureX to handle similar, backpressure-ignoring sources.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 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 resultingPublisher<R> returned fromzip will invokeonNext as many times as the number ofonNext 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 callingdoOnComplete()). 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 butaction2 won't.
 To work around this termination property, usedoOnCancel(Action) as well or useusing() 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 withinterval(long, TimeUnit) may result in MissingBackpressureException, use one of theonBackpressureX to handle similar, backpressure-ignoring sources.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 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<? superObject[],? 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 resultingPublisher<R> returned fromzip will invokeonNext as many times as the number ofonNext 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 callingdoOnComplete()). 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 butaction2 won't.
 To work around this termination property, usedoOnCancel(Action) as well or useusing() 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 withinterval(long, TimeUnit) may result in MissingBackpressureException, use one of theonBackpressureX to handle similar, backpressure-ignoring sources.
 Scheduler:
 zipArray does not operate by default on a particularScheduler.
 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<? extendsPublisher<? extends T>> sources,Function<? superObject[],? 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 resultingPublisher<R> returned fromzip will invokeonNext as many times as the number ofonNext 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 callingdoOnComplete()). 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 butaction2 won't.
 To work around this termination property, usedoOnCancel(Action) as well or useusing() 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 withinterval(long, TimeUnit) may result in MissingBackpressureException, use one of theonBackpressureX to handle similar, backpressure-ignoring sources.
 Scheduler:
 zipIterable does not operate by default on a particularScheduler.
 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<? superT> 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 sourcePublisher in an unbounded manner (i.e., without applying backpressure).
 Scheduler:
 all does not operate by default on a particularScheduler.
 Parameters:
 predicate - a function that evaluates an item and returns a Boolean
 Returns:
 a Single that emitstrue 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<? extendsT> 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 winningPublisher's backpressure behavior.
 Scheduler:
 ambWith does not operate by default on a particularScheduler.
 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<? superT> predicate)
```
 Returns a Single that emitstrue if any item emitted by the source Publisher satisfies a specified condition, otherwisefalse.Note: this always emitsfalse if the source Publisher is empty.
 In Rx.Net this is theany operator but we renamed it in RxJava to better match Java naming idioms.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 any does not operate by default on a particularScheduler.
 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 thepredicate
 See Also:
 ReactiveX operators documentation: Contains
 - as
```
@CheckReturnValue@BackpressureSupport(value=SPECIAL)@SchedulerSupport(value="none")public final <R> R as(@NonNullFlowableConverter<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 theconverter function.
 Scheduler:
 as does not operate by default on a particularScheduler.
 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 thisFlowable, or throwsNoSuchElementException if it emits no items.
 Backpressure:
 The operator consumes the sourceFlowable in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 blockingFirst does not operate by default on a particularScheduler.
 Error handling:
 If the source signals an error, the operator wraps a checkedException intoRuntimeException and throws that. Otherwise,RuntimeExceptions andErrors are rethrown as they are.
 Returns:
 the first item emitted by thisFlowable
 Throws:
 NoSuchElementException - if thisFlowable 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 thisFlowable, or a default value if it emits no items.
 Backpressure:
 The operator consumes the sourceFlowable in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 blockingFirst does not operate by default on a particularScheduler.
 Error handling:
 If the source signals an error, the operator wraps a checkedException intoRuntimeException and throws that. Otherwise,RuntimeExceptions andErrors are rethrown as they are.
 Parameters:
 defaultItem - a default value to return if thisFlowable emits no items
 Returns:
 the first item emitted by thisFlowable, 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<? superT> onNext)
```
 Consumes the upstreamFlowable in a blocking fashion and invokes the givenConsumer with each upstream item on thecurrent thread until the upstream terminates.
 Note: the method will only return if the upstream terminates or the current thread is interrupted.
 This method executes theConsumer on the current thread whilesubscribe(Consumer) executes the consumer on the original caller thread of the sequence.
 Backpressure:
 The operator consumes the sourceFlowable in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 blockingForEach does not operate by default on a particularScheduler.
 Error handling:
 If the source signals an error, the operator wraps a checkedException intoRuntimeException and throws that. Otherwise,RuntimeExceptions andErrors are rethrown as they are.
 Parameters:
 onNext - theConsumer to invoke for each item emitted by theFlowable
 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 thisFlowable into anIterable.
 Backpressure:
 The operator expects the upstream to honor backpressure otherwise the returned Iterable's iterator will throw aMissingBackpressureException.
 Scheduler:
 blockingIterable does not operate by default on a particularScheduler.
 Returns:
 anIterable version of thisFlowable
 See Also:
 ReactiveX documentation: To
 - blockingIterable
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Iterable<T> blockingIterable(int bufferSize)
```
 Converts thisFlowable into anIterable.
 Backpressure:
 The operator expects the upstream to honor backpressure otherwise the returned Iterable's iterator will throw aMissingBackpressureException.
 Scheduler:
 blockingIterable does not operate by default on a particularScheduler.
 Parameters:
 bufferSize - the number of items to prefetch from the current Flowable
 Returns:
 anIterable version of thisFlowable
 See Also:
 ReactiveX documentation: To
 - blockingLast
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final T blockingLast()
```
 Returns the last item emitted by thisFlowable, or throwsNoSuchElementException if thisFlowable emits no items.
 Backpressure:
 The operator consumes the sourceFlowable in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 blockingLast does not operate by default on a particularScheduler.
 Error handling:
 If the source signals an error, the operator wraps a checkedException intoRuntimeException and throws that. Otherwise,RuntimeExceptions andErrors are rethrown as they are.
 Returns:
 the last item emitted by thisFlowable
 Throws:
 NoSuchElementException - if thisFlowable 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 thisFlowable, or a default value if it emits no items.
 Backpressure:
 The operator consumes the sourceFlowable in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 blockingLast does not operate by default on a particularScheduler.
 Error handling:
 If the source signals an error, the operator wraps a checkedException intoRuntimeException and throws that. Otherwise,RuntimeExceptions andErrors are rethrown as they are.
 Parameters:
 defaultItem - a default value to return if thisFlowable emits no items
 Returns:
 the last item emitted by theFlowable, or the default value if it emits no items
 See Also:
 ReactiveX documentation: Last
 - blockingLatest
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final Iterable<T> blockingLatest()
```
 Returns anIterable that returns the latest item emitted by thisFlowable, waiting if necessary for one to become available.
 If thisFlowable produces items faster thanIterator.next takes them,onNext events might be skipped, butonError oronComplete events are not.
 Note also that anonNext directly followed byonComplete might hide theonNext event.
 Backpressure:
 The operator consumes the sourceFlowable in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 blockingLatest does not operate by default on a particularScheduler.
 Returns:
 an Iterable that always returns the latest item emitted by thisFlowable
 See Also:
 ReactiveX documentation: First
 - blockingMostRecent
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final Iterable<T> blockingMostRecent(T initialItem)
```
 Returns anIterable that always returns the item most recently emitted by thisFlowable.
 Backpressure:
 The operator consumes the sourceFlowable in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 blockingMostRecent does not operate by default on a particularScheduler.
 Parameters:
 initialItem - the initial item that theIterable sequence will yield if thisFlowable has not yet emitted an item
 Returns:
 anIterable that on each iteration returns the item that thisFlowable has most recently emitted
 See Also:
 ReactiveX documentation: First
 - blockingNext
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final Iterable<T> blockingNext()
```
 Returns anIterable that blocks until thisFlowable emits another item, then returns that item.
 Backpressure:
 The operator consumes the sourceFlowable in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 blockingNext does not operate by default on a particularScheduler.
 Returns:
 anIterable that blocks upon each iteration until thisFlowable emits a new item, whereupon the Iterable returns that item
 See Also:
 ReactiveX documentation: TakeLast
 - blockingSingle
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final T blockingSingle()
```
 If thisFlowable completes after emitting a single item, return that item, otherwise throw aNoSuchElementException.
 Backpressure:
 The operator consumes the sourceFlowable in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 blockingSingle does not operate by default on a particularScheduler.
 Error handling:
 If the source signals an error, the operator wraps a checkedException intoRuntimeException and throws that. Otherwise,RuntimeExceptions andErrors are rethrown as they are.
 Returns:
 the single item emitted by thisFlowable
 See Also:
 ReactiveX documentation: First
 - blockingSingle
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final T blockingSingle(T defaultItem)
```
 If thisFlowable completes after emitting a single item, return that item; if it emits more than one item, throw anIllegalArgumentException; if it emits no items, return a default value.
 Backpressure:
 The operator consumes the sourceFlowable in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 blockingSingle does not operate by default on a particularScheduler.
 Error handling:
 If the source signals an error, the operator wraps a checkedException intoRuntimeException and throws that. Otherwise,RuntimeExceptions andErrors are rethrown as they are.
 Parameters:
 defaultItem - a default value to return if thisFlowable emits no items
 Returns:
 the single item emitted by thisFlowable, or the default value if it emits no items
 See Also:
 ReactiveX documentation: First
 - toFuture
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final Future<T> toFuture()
```
 Returns aFuture representing the only value emitted by thisFlowable.
 If theFlowable emits more than one item,Future will receive anIndexOutOfBoundsException. If theFlowable is empty,Future will receive aNoSuchElementException. TheFlowable source has to terminate in order for the returnedFuture to terminate as well.
 If theFlowable may emit more than one item, useFlowable.toList().toFuture().
 Backpressure:
 The operator consumes the sourceFlowable in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 toFuture does not operate by default on a particularScheduler.
 Returns:
 aFuture that expects a single item to be emitted by thisFlowable
 See Also:
 ReactiveX documentation: To
 - blockingSubscribe
```
@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final void blockingSubscribe()
```
 Runs the source Flowable to a terminal event, ignoring any values and rethrowing any exception.
 Note that calling this method will block the caller thread until the upstream terminates normally or with an error. Therefore, calling this method from special threads such as the Android Main Thread or the Swing Event Dispatch Thread is not recommended.
 Backpressure:
 The operator consumes the sourceFlowable in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 blockingSubscribe does not operate by default on a particularScheduler.
 Since:
 2.0
 See Also:
 blockingSubscribe(Consumer),blockingSubscribe(Consumer, Consumer),blockingSubscribe(Consumer, Consumer, Action)
 - blockingSubscribe
```
@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final void blockingSubscribe(Consumer<? superT> onNext)
```
 Subscribes to the source and calls the given callbackson the current thread.
 If the Flowable emits an error, it is wrapped into anOnErrorNotImplementedException and routed to the RxJavaPlugins.onError handler. Using the overloadsblockingSubscribe(Consumer, Consumer) orblockingSubscribe(Consumer, Consumer, Action) instead is recommended.
 Note that calling this method will block the caller thread until the upstream terminates normally or with an error. Therefore, calling this method from special threads such as the Android Main Thread or the Swing Event Dispatch Thread is not recommended.
 Backpressure:
 The operator consumes the sourceFlowable in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 blockingSubscribe does not operate by default on a particularScheduler.
 Parameters:
 onNext - the callback action for each source value
 Since:
 2.0
 See Also:
 blockingSubscribe(Consumer, Consumer),blockingSubscribe(Consumer, Consumer, Action)
 - blockingSubscribe
```
@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final void blockingSubscribe(Consumer<? superT> onNext, int bufferSize)
```
 Subscribes to the source and calls the given callbackson the current thread.
 If the Flowable emits an error, it is wrapped into anOnErrorNotImplementedException and routed to the RxJavaPlugins.onError handler. Using the overloadsblockingSubscribe(Consumer, Consumer) orblockingSubscribe(Consumer, Consumer, Action) instead is recommended.
 Note that calling this method will block the caller thread until the upstream terminates normally or with an error. Therefore, calling this method from special threads such as the Android Main Thread or the Swing Event Dispatch Thread is not recommended.
 Backpressure:
 The operator consumes the sourceFlowable in an bounded manner (up to bufferSize outstanding request amount for items).
 Scheduler:
 blockingSubscribe does not operate by default on a particularScheduler.
 History: 2.1.15 - experimental
 Parameters:
 onNext - the callback action for each source value
 bufferSize - the size of the buffer
 Since:
 2.2
 See Also:
 blockingSubscribe(Consumer, Consumer),blockingSubscribe(Consumer, Consumer, Action)
 - blockingSubscribe
```
@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final void blockingSubscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError)
```
 Subscribes to the source and calls the given callbackson the current thread.
 Note that calling this method will block the caller thread until the upstream terminates normally or with an error. Therefore, calling this method from special threads such as the Android Main Thread or the Swing Event Dispatch Thread is not recommended.
 Backpressure:
 The operator consumes the sourceFlowable in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 blockingSubscribe does not operate by default on a particularScheduler.
 Parameters:
 onNext - the callback action for each source value
 onError - the callback action for an error event
 Since:
 2.0
 See Also:
 blockingSubscribe(Consumer, Consumer, Action)
 - blockingSubscribe
```
@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final void blockingSubscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError, int bufferSize)
```
 Subscribes to the source and calls the given callbackson the current thread.
 Note that calling this method will block the caller thread until the upstream terminates normally or with an error. Therefore, calling this method from special threads such as the Android Main Thread or the Swing Event Dispatch Thread is not recommended.
 Backpressure:
 The operator consumes the sourceFlowable in an bounded manner (up to bufferSize outstanding request amount for items).
 Scheduler:
 blockingSubscribe does not operate by default on a particularScheduler.
 History: 2.1.15 - experimental
 Parameters:
 onNext - the callback action for each source value
 onError - the callback action for an error event
 bufferSize - the size of the buffer
 Since:
 2.2
 See Also:
 blockingSubscribe(Consumer, Consumer, Action)
 - blockingSubscribe
```
@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final void blockingSubscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError,Action onComplete)
```
 Subscribes to the source and calls the given callbackson the current thread.
 Note that calling this method will block the caller thread until the upstream terminates normally or with an error. Therefore, calling this method from special threads such as the Android Main Thread or the Swing Event Dispatch Thread is not recommended.
 Backpressure:
 The operator consumes the sourceFlowable in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 blockingSubscribe does not operate by default on a particularScheduler.
 Parameters:
 onNext - the callback action for each source value
 onError - the callback action for an error event
 onComplete - the callback action for the completion event.
 Since:
 2.0
 - blockingSubscribe
```
@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final void blockingSubscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError,Action onComplete, int bufferSize)
```
 Subscribes to the source and calls the given callbackson the current thread.
 Note that calling this method will block the caller thread until the upstream terminates normally or with an error. Therefore, calling this method from special threads such as the Android Main Thread or the Swing Event Dispatch Thread is not recommended.
 Backpressure:
 The operator consumes the sourceFlowable in an bounded manner (up to bufferSize outstanding request amount for items).
 Scheduler:
 blockingSubscribe does not operate by default on a particularScheduler.
 History: 2.1.15 - experimental
 Parameters:
 onNext - the callback action for each source value
 onError - the callback action for an error event
 onComplete - the callback action for the completion event.
 bufferSize - the size of the buffer
 Since:
 2.2
 - blockingSubscribe
```
@BackpressureSupport(value=SPECIAL)@SchedulerSupport(value="none")public final void blockingSubscribe(Subscriber<? superT> subscriber)
```
 Subscribes to the source and calls theSubscriber methodson the current thread.
 Note that calling this method will block the caller thread until the upstream terminates normally, with an error or theSubscriber cancels theSubscription it receives viaSubscriber.onSubscribe(Subscription). Therefore, calling this method from special threads such as the Android Main Thread or the Swing Event Dispatch Thread is not recommended.
 Backpressure:
 The suppliedSubscriber determines how backpressure is applied.
 Scheduler:
 blockingSubscribe does not operate by default on a particularScheduler.
 The cancellation and backpressure is composed through.
 Parameters:
 subscriber - the subscriber to forward events and calls to in the current thread
 Since:
 2.0
 - buffer
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<List<T>> buffer(int count)
```
 Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping buffers, each containingcount items. When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
 Backpressure:
 The operator honors backpressure from downstream and expects the sourcePublisher to honor it as well, although not enforced; violationmay lead toMissingBackpressureException somewhere downstream.
 Scheduler:
 This version ofbuffer does not operate by default on a particularScheduler.
 Parameters:
 count - the maximum number of items in each buffer before it should be emitted
 Returns:
 a Flowable that emits connected, non-overlapping buffers, each containing at mostcount items from the source Publisher
 See Also:
 ReactiveX operators documentation: Buffer
 - buffer
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<List<T>> buffer(int count, int skip)
```
 Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits buffers everyskip items, each containingcount items. When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
 Backpressure:
 The operator honors backpressure from downstream and expects the sourcePublisher to honor it as well, although not enforced; violationmay lead toMissingBackpressureException somewhere downstream.
 Scheduler:
 This version ofbuffer does not operate by default on a particularScheduler.
 Parameters:
 count - the maximum size of each buffer before it should be emitted
 skip - how many items emitted by the source Publisher should be skipped before starting a new buffer. Note that whenskip andcount are equal, this is the same operation asbuffer(int).
 Returns:
 a Flowable that emits buffers for everyskip item from the source Publisher and containing at mostcount items
 See Also:
 ReactiveX operators documentation: Buffer
 - buffer
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final > Flowable buffer(int count, int skip,Callable bufferSupplier)
```
 Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits buffers everyskip items, each containingcount items. When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
 Backpressure:
 The operator honors backpressure from downstream and expects the sourcePublisher to honor it as well, although not enforced; violationmay lead toMissingBackpressureException somewhere downstream.
 Scheduler:
 This version ofbuffer does not operate by default on a particularScheduler.
 Type Parameters:
 U - the collection subclass type to buffer into
 Parameters:
 count - the maximum size of each buffer before it should be emitted
 skip - how many items emitted by the source Publisher should be skipped before starting a new buffer. Note that whenskip andcount are equal, this is the same operation asbuffer(int).
 bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned as the buffer
 Returns:
 a Flowable that emits buffers for everyskip item from the source Publisher and containing at mostcount items
 See Also:
 ReactiveX operators documentation: Buffer
 - buffer
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final > Flowable buffer(int count,Callable bufferSupplier)
```
 Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping buffers, each containingcount items. When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
 Backpressure:
 The operator honors backpressure from downstream and expects the sourcePublisher to honor it as well, although not enforced; violationmay lead toMissingBackpressureException somewhere downstream.
 Scheduler:
 This version ofbuffer does not operate by default on a particularScheduler.
 Type Parameters:
 U - the collection subclass type to buffer into
 Parameters:
 count - the maximum number of items in each buffer before it should be emitted
 bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned as the buffer
 Returns:
 a Flowable that emits connected, non-overlapping buffers, each containing at mostcount items from the source Publisher
 See Also:
 ReactiveX operators documentation: Buffer
 - buffer
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="io.reactivex:computation")public final Flowable<List<T>> buffer(long timespan, long timeskip,TimeUnit unit)
```
 Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher starts a new buffer periodically, as determined by thetimeskip argument. It emits each buffer after a fixed timespan, specified by thetimespan argument. When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
 Backpressure:
 This operator does not support backpressure as it uses time. It requestsLong.MAX_VALUE upstream and does not obey downstream requests.
 Scheduler:
 This version ofbuffer operates by default on thecomputationScheduler.
 Parameters:
 timespan - the period of time each buffer collects items before it is emitted
 timeskip - the period of time after which a new buffer will be created
 unit - the unit of time that applies to thetimespan andtimeskip arguments
 Returns:
 a Flowable that emits new buffers of items emitted by the source Publisher periodically after a fixed timespan has elapsed
 See Also:
 ReactiveX operators documentation: Buffer
 - buffer
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="custom")public final 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. The resulting Publisher starts a new buffer periodically, as determined by thetimeskip argument, and on the specifiedscheduler. It emits each buffer after a fixed timespan, specified by thetimespan argument. When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
 Backpressure:
 This operator does not support backpressure as it uses time. It requestsLong.MAX_VALUE upstream and does not obey downstream requests.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 timespan - the period of time each buffer collects items before it is emitted
 timeskip - the period of time after which a new buffer will be created
 unit - the unit of time that applies to thetimespan andtimeskip arguments
 scheduler - theScheduler to use when determining the end and start of a buffer
 Returns:
 a Flowable that emits new buffers of items emitted by the source Publisher periodically after a fixed timespan has elapsed
 See Also:
 ReactiveX operators documentation: Buffer
 - buffer
```
@CheckReturnValue@NonNull@BackpressureSupport(value=ERROR)@SchedulerSupport(value="custom")public final > Flowable buffer(long timespan, long timeskip,TimeUnit unit,Scheduler scheduler,Callable bufferSupplier)
```
 Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher starts a new buffer periodically, as determined by thetimeskip argument, and on the specifiedscheduler. It emits each buffer after a fixed timespan, specified by thetimespan argument. When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
 Backpressure:
 This operator does not support backpressure as it uses time. It requestsLong.MAX_VALUE upstream and does not obey downstream requests.
 Scheduler:
 You specify whichScheduler this operator will use.
 Type Parameters:
 U - the collection subclass type to buffer into
 Parameters:
 timespan - the period of time each buffer collects items before it is emitted
 timeskip - the period of time after which a new buffer will be created
 unit - the unit of time that applies to thetimespan andtimeskip arguments
 scheduler - theScheduler to use when determining the end and start of a buffer
 bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned as the buffer
 Returns:
 a Flowable that emits new buffers of items emitted by the source Publisher periodically after a fixed timespan has elapsed
 See Also:
 ReactiveX operators documentation: Buffer
 - buffer
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="io.reactivex:computation")public final Flowable<List<T>> buffer(long timespan,TimeUnit unit)
```
 Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping buffers, each of a fixed duration specified by thetimespan argument. When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
 Backpressure:
 This operator does not support backpressure as it uses time. It requestsLong.MAX_VALUE upstream and does not obey downstream requests.
 Scheduler:
 This version ofbuffer operates by default on thecomputationScheduler.
 Parameters:
 timespan - the period of time each buffer collects items before it is emitted and replaced with a new buffer
 unit - the unit of time that applies to thetimespan argument
 Returns:
 a Flowable that emits connected, non-overlapping buffers of items emitted by the source Publisher within a fixed duration
 See Also:
 ReactiveX operators documentation: Buffer
 - buffer
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="io.reactivex:computation")public final Flowable<List<T>> buffer(long timespan,TimeUnit unit, int count)
```
 Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping buffers, each of a fixed duration specified by thetimespan argument or a maximum size specified by thecount argument (whichever is reached first). When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
 Backpressure:
 This operator does not support backpressure as it uses time. It requestsLong.MAX_VALUE upstream and does not obey downstream requests.
 Scheduler:
 This version ofbuffer operates by default on thecomputationScheduler.
 Parameters:
 timespan - the period of time each buffer collects items before it is emitted and replaced with a new buffer
 unit - the unit of time which applies to thetimespan argument
 count - the maximum size of each buffer before it is emitted
 Returns:
 a Flowable that emits connected, non-overlapping buffers of items emitted by the source Publisher, after a fixed duration or when the buffer reaches maximum capacity (whichever occurs first)
 See Also:
 ReactiveX operators documentation: Buffer
 - buffer
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="custom")public final 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. The resulting Publisher emits connected, non-overlapping buffers, each of a fixed duration specified by thetimespan argument as measured on the specifiedscheduler, or a maximum size specified by thecount argument (whichever is reached first). When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
 Backpressure:
 This operator does not support backpressure as it uses time. It requestsLong.MAX_VALUE upstream and does not obey downstream requests.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 timespan - the period of time each buffer collects items before it is emitted and replaced with a new buffer
 unit - the unit of time which applies to thetimespan argument
 scheduler - theScheduler to use when determining the end and start of a buffer
 count - the maximum size of each buffer before it is emitted
 Returns:
 a Flowable that emits connected, non-overlapping buffers of items emitted by the source Publisher after a fixed duration or when the buffer reaches maximum capacity (whichever occurs first)
 See Also:
 ReactiveX operators documentation: Buffer
 - buffer
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="custom")public final > Flowable buffer(long timespan,TimeUnit unit,Scheduler scheduler, int count,Callable bufferSupplier, boolean restartTimerOnMaxSize)
```
 Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping buffers, each of a fixed duration specified by thetimespan argument as measured on the specifiedscheduler, or a maximum size specified by thecount argument (whichever is reached first). When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
 Backpressure:
 This operator does not support backpressure as it uses time. It requestsLong.MAX_VALUE upstream and does not obey downstream requests.
 Scheduler:
 You specify whichScheduler this operator will use.
 Type Parameters:
 U - the collection subclass type to buffer into
 Parameters:
 timespan - the period of time each buffer collects items before it is emitted and replaced with a new buffer
 unit - the unit of time which applies to thetimespan argument
 scheduler - theScheduler to use when determining the end and start of a buffer
 count - the maximum size of each buffer before it is emitted
 bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned as the buffer
 restartTimerOnMaxSize - if true the time window is restarted when the max capacity of the current buffer is reached
 Returns:
 a Flowable that emits connected, non-overlapping buffers of items emitted by the source Publisher after a fixed duration or when the buffer reaches maximum capacity (whichever occurs first)
 See Also:
 ReactiveX operators documentation: Buffer
 - buffer
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="custom")public final Flowable<List<T>> buffer(long timespan,TimeUnit unit,Scheduler scheduler)
```
 Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping buffers, each of a fixed duration specified by thetimespan argument and on the specifiedscheduler. When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
 Backpressure:
 This operator does not support backpressure as it uses time. It requestsLong.MAX_VALUE upstream and does not obey downstream requests.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 timespan - the period of time each buffer collects items before it is emitted and replaced with a new buffer
 unit - the unit of time which applies to thetimespan argument
 scheduler - theScheduler to use when determining the end and start of a buffer
 Returns:
 a Flowable that emits connected, non-overlapping buffers of items emitted by the source Publisher within a fixed duration
 See Also:
 ReactiveX operators documentation: Buffer
 - buffer
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="none")public final <TOpening,TClosing> Flowable<List<T>> buffer(Flowable<? extends TOpening> openingIndicator,Function<? super TOpening,? extendsPublisher<? extends TClosing>> closingIndicator)
```
 Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits buffers that it creates when the specifiedopeningIndicator Publisher emits an item, and closes when the Publisher returned fromclosingIndicator emits an item. If any of the source Publisher,openingIndicator orclosingIndicator issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
 Backpressure:
 This operator does not support backpressure as it is instead controlled by the given Publishers and buffers data. It requestsLong.MAX_VALUE upstream and does not obey downstream requests.
 Scheduler:
 This version ofbuffer does not operate by default on a particularScheduler.
 Type Parameters:
 TOpening - the element type of the buffer-opening Publisher
 TClosing - the element type of the individual buffer-closing Publishers
 Parameters:
 openingIndicator - the Publisher that, when it emits an item, causes a new buffer to be created
 closingIndicator - theFunction that is used to produce a Publisher for every buffer created. When this Publisher emits an item, the associated buffer is emitted.
 Returns:
 a Flowable that emits buffers, containing items from the source Publisher, that are created and closed when the specified Publishers emit items
 See Also:
 ReactiveX operators documentation: Buffer
 - buffer
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="none")public final <TOpening,TClosing,U extendsCollection<? superT>> Flowable buffer(Flowable<? extends TOpening> openingIndicator,Function<? super TOpening,? extendsPublisher<? extends TClosing>> closingIndicator,Callable bufferSupplier)
```
 Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits buffers that it creates when the specifiedopeningIndicator Publisher emits an item, and closes when the Publisher returned fromclosingIndicator emits an item. If any of the source Publisher,openingIndicator orclosingIndicator issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
 Backpressure:
 This operator does not support backpressure as it is instead controlled by the given Publishers and buffers data. It requestsLong.MAX_VALUE upstream and does not obey downstream requests.
 Scheduler:
 This version ofbuffer does not operate by default on a particularScheduler.
 Type Parameters:
 U - the collection subclass type to buffer into
 TOpening - the element type of the buffer-opening Publisher
 TClosing - the element type of the individual buffer-closing Publishers
 Parameters:
 openingIndicator - the Publisher that, when it emits an item, causes a new buffer to be created
 closingIndicator - theFunction that is used to produce a Publisher for every buffer created. When this Publisher emits an item, the associated buffer is emitted.
 bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned as the buffer
 Returns:
 a Flowable that emits buffers, containing items from the source Publisher, that are created and closed when the specified Publishers emit items
 See Also:
 ReactiveX operators documentation: Buffer
 - buffer
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="none")public final  Flowable<List<T>> buffer(Publisher boundaryIndicator)
```
 Returns a Flowable that emits non-overlapping buffered items from the source Publisher each time the specified boundary Publisher emits an item.
 Completion of either the source or the boundary Publisher causes the returned Publisher to emit the latest buffer and complete. If either the source Publisher or the boundary Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
 Backpressure:
 This operator does not support backpressure as it is instead controlled by thePublisherboundary and buffers data. It requestsLong.MAX_VALUE upstream and does not obey downstream requests.
 Scheduler:
 This version ofbuffer does not operate by default on a particularScheduler.
 Type Parameters:
 B - the boundary value type (ignored)
 Parameters:
 boundaryIndicator - the boundary Publisher
 Returns:
 a Flowable that emits buffered items from the source Publisher when the boundary Publisher emits an item
 See Also:
 buffer(Publisher, int),ReactiveX operators documentation: Buffer
 - buffer
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="none")public final  Flowable<List<T>> buffer(Publisher 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.
 Completion of either the source or the boundary Publisher causes the returned Publisher to emit the latest buffer and complete. If either the source Publisher or the boundary Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
 Backpressure:
 This operator does not support backpressure as it is instead controlled by thePublisherboundary and buffers data. It requestsLong.MAX_VALUE upstream and does not obey downstream requests.
 Scheduler:
 This version ofbuffer does not operate by default on a particularScheduler.
 Type Parameters:
 B - the boundary value type (ignored)
 Parameters:
 boundaryIndicator - the boundary Publisher
 initialCapacity - the initial capacity of each buffer chunk
 Returns:
 a Flowable that emits buffered items from the source Publisher when the boundary Publisher emits an item
 See Also:
 ReactiveX operators documentation: Buffer,buffer(Publisher)
 - buffer
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="none")public final <B,U extendsCollection<? superT>> Flowable buffer(Publisher boundaryIndicator,Callable bufferSupplier)
```
 Returns a Flowable that emits non-overlapping buffered items from the source Publisher each time the specified boundary Publisher emits an item.
 Completion of either the source or the boundary Publisher causes the returned Publisher to emit the latest buffer and complete. If either the source Publisher or the boundary Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
 Backpressure:
 This operator does not support backpressure as it is instead controlled by thePublisherboundary and buffers data. It requestsLong.MAX_VALUE upstream and does not obey downstream requests.
 Scheduler:
 This version ofbuffer does not operate by default on a particularScheduler.
 Type Parameters:
 U - the collection subclass type to buffer into
 B - the boundary value type (ignored)
 Parameters:
 boundaryIndicator - the boundary Publisher
 bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned as the buffer
 Returns:
 a Flowable that emits buffered items from the source Publisher when the boundary Publisher emits an item
 See Also:
 buffer(Publisher, int),ReactiveX operators documentation: Buffer
 - buffer
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="none")public final  Flowable<List<T>> buffer(Callable<? extendsPublisher> boundaryIndicatorSupplier)
```
 Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping buffers. It emits the current buffer and replaces it with a new buffer whenever the Publisher produced by the specifiedboundaryIndicatorSupplier emits an item.
 If either the sourcePublisher or the boundaryPublisher issues anonError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
 Backpressure:
 This operator does not support backpressure as it is instead controlled by the given Publishers and buffers data. It requestsLong.MAX_VALUE upstream and does not obey downstream requests.
 Scheduler:
 This version ofbuffer does not operate by default on a particularScheduler.
 Type Parameters:
 B - the value type of the boundary-providing Publisher
 Parameters:
 boundaryIndicatorSupplier - aCallable that produces a Publisher that governs the boundary between buffers. Whenever the suppliedPublisher emits an item,buffer emits the current buffer and begins to fill a new one
 Returns:
 a Flowable that emits a connected, non-overlapping buffer of items from the source Publisher each time the Publisher created with theclosingIndicator argument emits an item
 See Also:
 ReactiveX operators documentation: Buffer
 - buffer
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="none")public final <B,U extendsCollection<? superT>> Flowable buffer(Callable<? extendsPublisher> boundaryIndicatorSupplier,Callable bufferSupplier)
```
 Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping buffers. It emits the current buffer and replaces it with a new buffer whenever the Publisher produced by the specifiedboundaryIndicatorSupplier emits an item.
 If either the sourcePublisher or the boundaryPublisher issues anonError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
 Backpressure:
 This operator does not support backpressure as it is instead controlled by the given Publishers and buffers data. It requestsLong.MAX_VALUE upstream and does not obey downstream requests.
 Scheduler:
 This version ofbuffer does not operate by default on a particularScheduler.
 Type Parameters:
 U - the collection subclass type to buffer into
 B - the value type of the boundary-providing Publisher
 Parameters:
 boundaryIndicatorSupplier - aCallable that produces a Publisher that governs the boundary between buffers. Whenever the suppliedPublisher emits an item,buffer emits the current buffer and begins to fill a new one
 bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned as the buffer
 Returns:
 a Flowable that emits a connected, non-overlapping buffer of items from the source Publisher each time the Publisher created with theclosingIndicator argument emits an item
 See Also:
 ReactiveX operators documentation: Buffer
 - cache
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final 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.
 This is useful when you want a Publisher to cache responses and you can't control the subscribe/cancel behavior of all theSubscribers.
 The operator subscribes only when the first downstream subscriber subscribes and maintains a single subscription towards this Publisher. In contrast, the operator family ofreplay() that return aConnectableFlowable require an explicit call toConnectableFlowable.connect().
 Note: You sacrifice the ability to cancel the origin when you use thecache Subscriber so be careful not to use this Subscriber on Publishers that emit an infinite or very large number of items that will use up memory. A possible workaround is to apply `takeUntil` with a predicate or another source before (and perhaps after) the application of cache().
```
 AtomicBoolean shouldStop = new AtomicBoolean(); source.takeUntil(v -> shouldStop.get()) .cache() .takeUntil(v -> shouldStop.get()) .subscribe(...);
```
 Since the operator doesn't allow clearing the cached values either, the possible workaround is to forget all references to it viaonTerminateDetach() applied along with the previous workaround:
```
 AtomicBoolean shouldStop = new AtomicBoolean(); source.takeUntil(v -> shouldStop.get()) .onTerminateDetach() .cache() .takeUntil(v -> shouldStop.get()) .onTerminateDetach() .subscribe(...);
```
 Backpressure:
 The operator consumes this Publisher in an unbounded fashion but respects the backpressure of each downstream Subscriber individually.
 Scheduler:
 cache does not operate by default on a particularScheduler.
 Returns:
 a Flowable that, when first subscribed to, caches all of its items and notifications for the benefit of subsequent subscribers
 See Also:
 ReactiveX operators documentation: Replay
 - cacheWithInitialCapacity
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final 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.
 This is useful when you want a Publisher to cache responses and you can't control the subscribe/cancel behavior of all theSubscribers.
 The operator subscribes only when the first downstream subscriber subscribes and maintains a single subscription towards this Publisher. In contrast, the operator family ofreplay() that return aConnectableFlowable require an explicit call toConnectableFlowable.connect().
 Note: You sacrifice the ability to cancel the origin when you use thecache Subscriber so be careful not to use this Subscriber on Publishers that emit an infinite or very large number of items that will use up memory. A possible workaround is to apply `takeUntil` with a predicate or another source before (and perhaps after) the application of cache().
```
 AtomicBoolean shouldStop = new AtomicBoolean(); source.takeUntil(v -> shouldStop.get()) .cache() .takeUntil(v -> shouldStop.get()) .subscribe(...);
```
 Since the operator doesn't allow clearing the cached values either, the possible workaround is to forget all references to it viaonTerminateDetach() applied along with the previous workaround:
```
 AtomicBoolean shouldStop = new AtomicBoolean(); source.takeUntil(v -> shouldStop.get()) .onTerminateDetach() .cache() .takeUntil(v -> shouldStop.get()) .onTerminateDetach() .subscribe(...);
```
 Backpressure:
 The operator consumes this Publisher in an unbounded fashion but respects the backpressure of each downstream Subscriber individually.
 Scheduler:
 cacheWithInitialCapacity does not operate by default on a particularScheduler.
 Note: The capacity hint is not an upper bound on cache size. For that, considerreplay(int) in combination withConnectableFlowable.autoConnect() or similar.
 Parameters:
 initialCapacity - hint for number of items to cache (for optimizing underlying data structure)
 Returns:
 a Flowable that, when first subscribed to, caches all of its items and notifications for the benefit of subsequent subscribers
 See Also:
 ReactiveX operators documentation: Replay
 - cast
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final  Flowable cast(Class clazz)
```
 Returns a Flowable that emits the items emitted by the source Publisher, converted to the specified type.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 cast does not operate by default on a particularScheduler.
 Type Parameters:
 U - the output value type cast to
 Parameters:
 clazz - the target class type thatcast will cast the items emitted by the source Publisher into before emitting them from the resulting Publisher
 Returns:
 a Flowable that emits each item from the source Publisher after converting it to the specified type
 See Also:
 ReactiveX operators documentation: Map
 - collect
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final  Single collect(Callable<? extends U> initialItemSupplier,BiConsumer<? super U,? superT> collector)
```
 Collects items emitted by the finite source Publisher into a single mutable data structure and returns a Single that emits this structure.
 This is a simplified version ofreduce that does not need to return the state on each pass.
 Note that this operator requires the upstream to signalonComplete for the accumulator object to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.
 Backpressure:
 This operator does not support backpressure because by intent it will receive all values and reduce them to a singleonNext.
 Scheduler:
 collect does not operate by default on a particularScheduler.
 Type Parameters:
 U - the accumulator and output type
 Parameters:
 initialItemSupplier - the mutable data structure that will collect the items
 collector - a function that accepts thestate and an emitted item, and modifiesstate accordingly
 Returns:
 a Single that emits the result of collecting the values emitted by the source Publisher into a single mutable data structure
 See Also:
 ReactiveX operators documentation: Reduce
 - collectInto
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final  Single collectInto(U initialItem,BiConsumer<? super U,? superT> collector)
```
 Collects items emitted by the finite source Publisher into a single mutable data structure and returns a Single that emits this structure.
 This is a simplified version ofreduce that does not need to return the state on each pass.
 Note that this operator requires the upstream to signalonComplete for the accumulator object to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.
 Backpressure:
 This operator does not support backpressure because by intent it will receive all values and reduce them to a singleonNext.
 Scheduler:
 collectInto does not operate by default on a particularScheduler.
 Type Parameters:
 U - the accumulator and output type
 Parameters:
 initialItem - the mutable data structure that will collect the items
 collector - a function that accepts thestate and an emitted item, and modifiesstate accordingly
 Returns:
 a Single that emits the result of collecting the values emitted by the source Publisher into a single mutable data structure
 See Also:
 ReactiveX operators documentation: Reduce
 - compose
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final <R> Flowable<R> compose(FlowableTransformer<? superT,? extends R> composer)
```
 Transform a Publisher by applying a particular Transformer function to it.
 This method operates on the Publisher itself whereaslift(io.reactivex.FlowableOperator<? extends R, ? super T>) operates on the Publisher's Subscribers or Subscribers.
 If the operator you are creating is designed to act on the individual items emitted by a source Publisher, uselift(io.reactivex.FlowableOperator<? extends R, ? super T>). If your operator is designed to transform the source Publisher as a whole (for instance, by applying a particular set of existing RxJava operators to it) usecompose.
 Backpressure:
 The operator itself doesn't interfere with the backpressure behavior which only depends on what kind ofPublisher the transformer returns.
 Scheduler:
 compose does not operate by default on a particularScheduler.
 Type Parameters:
 R - the value type of the output Publisher
 Parameters:
 composer - implements the function that transforms the source Publisher
 Returns:
 the source Publisher, transformed by the transformer function
 See Also:
 RxJava wiki: Implementing Your Own Operators
 - concatMap
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> concatMap(Function<? superT,? extendsPublisher<? 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.
 Backpressure:
 The operator honors backpressure from downstream. Both this and the innerPublishers are expected to honor backpressure as well. If the sourcePublisher violates the rule, the operator will signal aMissingBackpressureException. If any of the innerPublishers doesn't honor backpressure, thatmay throw anIllegalStateException when thatPublisher completes.
 Scheduler:
 concatMap does not operate by default on a particularScheduler.
 Type Parameters:
 R - the type of the inner Publisher sources and thus the output type
 Parameters:
 mapper - a function that, when applied to an item emitted by the source Publisher, returns a Publisher
 Returns:
 a Flowable that emits the result of applying the transformation function to each item emitted by the source Publisher and concatenating the Publishers obtained from this transformation
 See Also:
 ReactiveX operators documentation: FlatMap
 - concatMap
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> concatMap(Function<? superT,? extendsPublisher<? 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.
 Backpressure:
 The operator honors backpressure from downstream. Both this and the innerPublishers are expected to honor backpressure as well. If the sourcePublisher violates the rule, the operator will signal aMissingBackpressureException. If any of the innerPublishers doesn't honor backpressure, thatmay throw anIllegalStateException when thatPublisher completes.
 Scheduler:
 concatMap does not operate by default on a particularScheduler.
 Type Parameters:
 R - the type of the inner Publisher sources and thus the output type
 Parameters:
 mapper - a function that, when applied to an item emitted by the source Publisher, returns a Publisher
 prefetch - the number of elements to prefetch from the current Flowable
 Returns:
 a Flowable that emits the result of applying the transformation function to each item emitted by the source Publisher and concatenating the Publishers obtained from this transformation
 See Also:
 ReactiveX operators documentation: FlatMap
 - concatMapCompletable
```
@CheckReturnValue@SchedulerSupport(value="none")@BackpressureSupport(value=FULL)public final Completable concatMapCompletable(Function<? superT,? extendsCompletableSource> mapper)
```
 Maps the upstream items intoCompletableSources and subscribes to them one after the other completes.
 Backpressure:
 The operator expects the upstream to support backpressure. If thisFlowable violates the rule, the operator will signal aMissingBackpressureException.
 Scheduler:
 concatMapCompletable does not operate by default on a particularScheduler.
 History: 2.1.11 - experimental
 Parameters:
 mapper - the function called with the upstream item and should return aCompletableSource to become the next source to be subscribed to
 Returns:
 a new Completable instance
 Since:
 2.2
 See Also:
 concatMapCompletableDelayError(Function)
 - concatMapCompletable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")@BackpressureSupport(value=FULL)public final Completable concatMapCompletable(Function<? superT,? extendsCompletableSource> mapper, int prefetch)
```
 Maps the upstream items intoCompletableSources and subscribes to them one after the other completes.
 Backpressure:
 The operator expects the upstream to support backpressure. If thisFlowable violates the rule, the operator will signal aMissingBackpressureException.
 Scheduler:
 concatMapCompletable does not operate by default on a particularScheduler.
 History: 2.1.11 - experimental
 Parameters:
 mapper - the function called with the upstream item and should return aCompletableSource to become the next source to be subscribed to
 prefetch - The number of upstream items to prefetch so that fresh items are ready to be mapped when a previousCompletableSource terminates. The operator replenishes after half of the prefetch amount has been consumed and turned intoCompletableSources.
 Returns:
 a new Completable instance
 Since:
 2.2
 See Also:
 concatMapCompletableDelayError(Function, boolean, int)
 - concatMapCompletableDelayError
```
@CheckReturnValue@SchedulerSupport(value="none")@BackpressureSupport(value=FULL)public final Completable concatMapCompletableDelayError(Function<? superT,? extendsCompletableSource> mapper)
```
 Maps the upstream items intoCompletableSources and subscribes to them one after the other terminates, delaying all errors till both thisFlowable and all innerCompletableSources terminate.
 Backpressure:
 The operator expects the upstream to support backpressure. If thisFlowable violates the rule, the operator will signal aMissingBackpressureException.
 Scheduler:
 concatMapCompletableDelayError does not operate by default on a particularScheduler.
 History: 2.1.11 - experimental
 Parameters:
 mapper - the function called with the upstream item and should return aCompletableSource to become the next source to be subscribed to
 Returns:
 a new Completable instance
 Since:
 2.2
 See Also:
 concatMapCompletable(Function, int)
 - concatMapCompletableDelayError
```
@CheckReturnValue@SchedulerSupport(value="none")@BackpressureSupport(value=FULL)public final Completable concatMapCompletableDelayError(Function<? superT,? extendsCompletableSource> mapper, boolean tillTheEnd)
```
 Maps the upstream items intoCompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both thisFlowable and all innerCompletableSources terminate.
 Backpressure:
 The operator expects the upstream to support backpressure. If thisFlowable violates the rule, the operator will signal aMissingBackpressureException.
 Scheduler:
 concatMapCompletableDelayError does not operate by default on a particularScheduler.
 History: 2.1.11 - experimental
 Parameters:
 mapper - the function called with the upstream item and should return aCompletableSource to become the next source to be subscribed to
 tillTheEnd - Iftrue, errors from thisFlowable or any of the innerCompletableSources are delayed until all of them terminate. Iffalse, an error from thisFlowable is delayed until the current innerCompletableSource terminates and only then is it emitted to the downstream.
 Returns:
 a new Completable instance
 Since:
 2.2
 See Also:
 concatMapCompletable(Function)
 - concatMapCompletableDelayError
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")@BackpressureSupport(value=FULL)public final Completable concatMapCompletableDelayError(Function<? superT,? extendsCompletableSource> mapper, boolean tillTheEnd, int prefetch)
```
 Maps the upstream items intoCompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both thisFlowable and all innerCompletableSources terminate.
 Backpressure:
 The operator expects the upstream to support backpressure. If thisFlowable violates the rule, the operator will signal aMissingBackpressureException.
 Scheduler:
 concatMapCompletableDelayError does not operate by default on a particularScheduler.
 History: 2.1.11 - experimental
 Parameters:
 mapper - the function called with the upstream item and should return aCompletableSource to become the next source to be subscribed to
 tillTheEnd - Iftrue, errors from thisFlowable or any of the innerCompletableSources are delayed until all of them terminate. Iffalse, an error from thisFlowable is delayed until the current innerCompletableSource terminates and only then is it emitted to the downstream.
 prefetch - The number of upstream items to prefetch so that fresh items are ready to be mapped when a previousCompletableSource terminates. The operator replenishes after half of the prefetch amount has been consumed and turned intoCompletableSources.
 Returns:
 a new Completable instance
 Since:
 2.2
 See Also:
 concatMapCompletable(Function, int)
 - concatMapDelayError
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> concatMapDelayError(Function<? superT,? extendsPublisher<? 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.
 Backpressure:
 The operator honors backpressure from downstream. Both this and the innerPublishers are expected to honor backpressure as well. If the sourcePublisher violates the rule, the operator will signal aMissingBackpressureException. If any of the innerPublishers doesn't honor backpressure, thatmay throw anIllegalStateException when thatPublisher completes.
 Scheduler:
 concatMapDelayError does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result value type
 Parameters:
 mapper - the function that maps the items of this Publisher into the inner Publishers.
 Returns:
 the new Publisher instance with the concatenation behavior
 - concatMapDelayError
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> concatMapDelayError(Function<? superT,? extendsPublisher<? 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.
 Backpressure:
 The operator honors backpressure from downstream. Both this and the innerPublishers are expected to honor backpressure as well. If the sourcePublisher violates the rule, the operator will signal aMissingBackpressureException. If any of the innerPublishers doesn't honor backpressure, thatmay throw anIllegalStateException when thatPublisher completes.
 Scheduler:
 concatMapDelayError does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result value type
 Parameters:
 mapper - the function that maps the items of this Publisher into the inner Publishers.
 prefetch - the number of elements to prefetch from the current Flowable
 tillTheEnd - if true, all errors from the outer and inner Publisher sources are delayed until the end, if false, an error from the main source is signaled when the current Publisher source terminates
 Returns:
 the new Publisher instance with the concatenation behavior
 - concatMapEager
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> concatMapEager(Function<? superT,? extendsPublisher<? extends R>> mapper)
```
 Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
 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, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.
 Scheduler:
 This method does not operate by default on a particularScheduler.
 Type Parameters:
 R - the value type
 Parameters:
 mapper - the function that maps a sequence of values into a sequence of Publishers that will be eagerly concatenated
 Returns:
 the new Publisher instance with the specified concatenation behavior
 Since:
 2.0
 - concatMapEager
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> concatMapEager(Function<? superT,? extendsPublisher<? extends R>> mapper, int maxConcurrency, int prefetch)
```
 Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
 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, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.
 Scheduler:
 This method does not operate by default on a particularScheduler.
 Type Parameters:
 R - the value type
 Parameters:
 mapper - the function that maps a sequence of values into a sequence of Publishers that will be eagerly concatenated
 maxConcurrency - the maximum number of concurrent subscribed Publishers
 prefetch - hints about the number of expected values from each inner Publisher, must be positive
 Returns:
 the new Publisher instance with the specified concatenation behavior
 Since:
 2.0
 - concatMapEagerDelayError
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> concatMapEagerDelayError(Function<? superT,? extendsPublisher<? extends R>> mapper, boolean tillTheEnd)
```
 Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
 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, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.
 Scheduler:
 This method does not operate by default on a particularScheduler.
 Type Parameters:
 R - the value type
 Parameters:
 mapper - the function that maps a sequence of values into a sequence of Publishers that will be eagerly concatenated
 tillTheEnd - if true, all errors from the outer and inner Publisher sources are delayed until the end, if false, an error from the main source is signaled when the current Publisher source terminates
 Returns:
 the new Publisher instance with the specified concatenation behavior
 Since:
 2.0
 - concatMapEagerDelayError
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> concatMapEagerDelayError(Function<? superT,? extendsPublisher<? 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.
 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, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.
 Scheduler:
 This method does not operate by default on a particularScheduler.
 Type Parameters:
 R - the value type
 Parameters:
 mapper - the function that maps a sequence of values into a sequence of Publishers that will be eagerly concatenated
 maxConcurrency - the maximum number of concurrent subscribed Publishers
 prefetch - the number of elements to prefetch from each source Publisher
 tillTheEnd - if true, exceptions from the current Flowable and all the inner Publishers are delayed until all of them terminate, if false, exception from the current Flowable is delayed until the currently running Publisher terminates
 Returns:
 the new Publisher instance with the specified concatenation behavior
 Since:
 2.0
 - concatMapIterable
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final  Flowable concatMapIterable(Function<? superT,? extendsIterable<? 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.
 Backpressure:
 The operator honors backpressure from downstream. The sourcePublishers is expected to honor backpressure as well. If the sourcePublisher violates the rule, the operator will signal aMissingBackpressureException.
 Scheduler:
 concatMapIterable does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of item emitted by the resulting Publisher
 Parameters:
 mapper - a function that returns an Iterable sequence of values for when given an item emitted by the source Publisher
 Returns:
 a Flowable that emits the results of concatenating the items emitted by the source Publisher with the values in the Iterables corresponding to those items, as generated bycollectionSelector
 See Also:
 ReactiveX operators documentation: FlatMap
 - concatMapIterable
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final  Flowable concatMapIterable(Function<? superT,? extendsIterable<? 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.
 Backpressure:
 The operator honors backpressure from downstream. The sourcePublishers is expected to honor backpressure as well. If the sourcePublisher violates the rule, the operator will signal aMissingBackpressureException.
 Scheduler:
 concatMapIterable does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of item emitted by the resulting Publisher
 Parameters:
 mapper - a function that returns an Iterable sequence of values for when given an item emitted by the source Publisher
 prefetch - the number of elements to prefetch from the current Flowable
 Returns:
 a Flowable that emits the results of concatenating the items emitted by the source Publisher with the values in the Iterables corresponding to those items, as generated bycollectionSelector
 See Also:
 ReactiveX operators documentation: FlatMap
 - concatMapMaybe
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> concatMapMaybe(Function<? superT,? extendsMaybeSource<? extends R>> mapper)
```
 Maps the upstream items intoMaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either thisFlowable or the current innerMaybeSource fail.
 Backpressure:
 The operator expects the upstream to support backpressure and honors the backpressure from downstream. If thisFlowable violates the rule, the operator will signal aMissingBackpressureException.
 Scheduler:
 concatMapMaybe does not operate by default on a particularScheduler.
 History: 2.1.11 - experimental
 Type Parameters:
 R - the result type of the innerMaybeSources
 Parameters:
 mapper - the function called with the upstream item and should return aMaybeSource to become the next source to be subscribed to
 Returns:
 a new Flowable instance
 Since:
 2.2
 See Also:
 concatMapMaybeDelayError(Function),concatMapMaybe(Function, int)
 - concatMapMaybe
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> concatMapMaybe(Function<? superT,? extendsMaybeSource<? extends R>> mapper, int prefetch)
```
 Maps the upstream items intoMaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either thisFlowable or the current innerMaybeSource fail.
 Backpressure:
 The operator expects the upstream to support backpressure and honors the backpressure from downstream. If thisFlowable violates the rule, the operator will signal aMissingBackpressureException.
 Scheduler:
 concatMapMaybe does not operate by default on a particularScheduler.
 History: 2.1.11 - experimental
 Type Parameters:
 R - the result type of the innerMaybeSources
 Parameters:
 mapper - the function called with the upstream item and should return aMaybeSource to become the next source to be subscribed to
 prefetch - The number of upstream items to prefetch so that fresh items are ready to be mapped when a previousMaybeSource terminates. The operator replenishes after half of the prefetch amount has been consumed and turned intoMaybeSources.
 Returns:
 a new Flowable instance
 Since:
 2.2
 See Also:
 concatMapMaybe(Function),concatMapMaybeDelayError(Function, boolean, int)
 - concatMapMaybeDelayError
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> concatMapMaybeDelayError(Function<? superT,? extendsMaybeSource<? extends R>> mapper)
```
 Maps the upstream items intoMaybeSources and subscribes to them one after the other terminates, emits their success value if available and delaying all errors till both thisFlowable and all innerMaybeSources terminate.
 Backpressure:
 The operator expects the upstream to support backpressure and honors the backpressure from downstream. If thisFlowable violates the rule, the operator will signal aMissingBackpressureException.
 Scheduler:
 concatMapMaybeDelayError does not operate by default on a particularScheduler.
 History: 2.1.11 - experimental
 Type Parameters:
 R - the result type of the innerMaybeSources
 Parameters:
 mapper - the function called with the upstream item and should return aMaybeSource to become the next source to be subscribed to
 Returns:
 a new Flowable instance
 Since:
 2.2
 See Also:
 concatMapMaybe(Function),concatMapMaybeDelayError(Function, boolean)
 - concatMapMaybeDelayError
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> concatMapMaybeDelayError(Function<? superT,? extendsMaybeSource<? extends R>> mapper, boolean tillTheEnd)
```
 Maps the upstream items intoMaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both thisFlowable and all innerMaybeSources terminate.
 Backpressure:
 The operator expects the upstream to support backpressure and honors the backpressure from downstream. If thisFlowable violates the rule, the operator will signal aMissingBackpressureException.
 Scheduler:
 concatMapMaybeDelayError does not operate by default on a particularScheduler.
 History: 2.1.11 - experimental
 Type Parameters:
 R - the result type of the innerMaybeSources
 Parameters:
 mapper - the function called with the upstream item and should return aMaybeSource to become the next source to be subscribed to
 tillTheEnd - Iftrue, errors from thisFlowable or any of the innerMaybeSources are delayed until all of them terminate. Iffalse, an error from thisFlowable is delayed until the current innerMaybeSource terminates and only then is it emitted to the downstream.
 Returns:
 a new Flowable instance
 Since:
 2.2
 See Also:
 concatMapMaybe(Function, int),concatMapMaybeDelayError(Function, boolean, int)
 - concatMapMaybeDelayError
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> concatMapMaybeDelayError(Function<? superT,? extendsMaybeSource<? extends R>> mapper, boolean tillTheEnd, int prefetch)
```
 Maps the upstream items intoMaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both thisFlowable and all innerMaybeSources terminate.
 Backpressure:
 The operator expects the upstream to support backpressure and honors the backpressure from downstream. If thisFlowable violates the rule, the operator will signal aMissingBackpressureException.
 Scheduler:
 concatMapMaybeDelayError does not operate by default on a particularScheduler.
 History: 2.1.11 - experimental
 Type Parameters:
 R - the result type of the innerMaybeSources
 Parameters:
 mapper - the function called with the upstream item and should return aMaybeSource to become the next source to be subscribed to
 tillTheEnd - Iftrue, errors from thisFlowable or any of the innerMaybeSources are delayed until all of them terminate. Iffalse, an error from thisFlowable is delayed until the current innerMaybeSource terminates and only then is it emitted to the downstream.
 prefetch - The number of upstream items to prefetch so that fresh items are ready to be mapped when a previousMaybeSource terminates. The operator replenishes after half of the prefetch amount has been consumed and turned intoMaybeSources.
 Returns:
 a new Flowable instance
 Since:
 2.2
 See Also:
 concatMapMaybe(Function, int)
 - concatMapSingle
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> concatMapSingle(Function<? superT,? extendsSingleSource<? extends R>> mapper)
```
 Maps the upstream items intoSingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either thisFlowable or the current innerSingleSource fail.
 Backpressure:
 The operator expects the upstream to support backpressure and honors the backpressure from downstream. If thisFlowable violates the rule, the operator will signal aMissingBackpressureException.
 Scheduler:
 concatMapSingle does not operate by default on a particularScheduler.
 History: 2.1.11 - experimental
 Type Parameters:
 R - the result type of the innerSingleSources
 Parameters:
 mapper - the function called with the upstream item and should return aSingleSource to become the next source to be subscribed to
 Returns:
 a new Flowable instance
 Since:
 2.2
 See Also:
 concatMapSingleDelayError(Function),concatMapSingle(Function, int)
 - concatMapSingle
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> concatMapSingle(Function<? superT,? extendsSingleSource<? extends R>> mapper, int prefetch)
```
 Maps the upstream items intoSingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either thisFlowable or the current innerSingleSource fail.
 Backpressure:
 The operator expects the upstream to support backpressure and honors the backpressure from downstream. If thisFlowable violates the rule, the operator will signal aMissingBackpressureException.
 Scheduler:
 concatMapSingle does not operate by default on a particularScheduler.
 History: 2.1.11 - experimental
 Type Parameters:
 R - the result type of the innerSingleSources
 Parameters:
 mapper - the function called with the upstream item and should return aSingleSource to become the next source to be subscribed to
 prefetch - The number of upstream items to prefetch so that fresh items are ready to be mapped when a previousSingleSource terminates. The operator replenishes after half of the prefetch amount has been consumed and turned intoSingleSources.
 Returns:
 a new Flowable instance
 Since:
 2.2
 See Also:
 concatMapSingle(Function),concatMapSingleDelayError(Function, boolean, int)
 - concatMapSingleDelayError
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> concatMapSingleDelayError(Function<? superT,? extendsSingleSource<? extends R>> mapper)
```
 Maps the upstream items intoSingleSources and subscribes to them one after the other succeeds or fails, emits their success values and delays all errors till both thisFlowable and all innerSingleSources terminate.
 Backpressure:
 The operator expects the upstream to support backpressure and honors the backpressure from downstream. If thisFlowable violates the rule, the operator will signal aMissingBackpressureException.
 Scheduler:
 concatMapSingleDelayError does not operate by default on a particularScheduler.
 History: 2.1.11 - experimental
 Type Parameters:
 R - the result type of the innerSingleSources
 Parameters:
 mapper - the function called with the upstream item and should return aSingleSource to become the next source to be subscribed to
 Returns:
 a new Flowable instance
 Since:
 2.2
 See Also:
 concatMapSingle(Function),concatMapSingleDelayError(Function, boolean)
 - concatMapSingleDelayError
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> concatMapSingleDelayError(Function<? superT,? extendsSingleSource<? extends R>> mapper, boolean tillTheEnd)
```
 Maps the upstream items intoSingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays all errors till both thisFlowable and all innerSingleSources terminate.
 Backpressure:
 The operator expects the upstream to support backpressure and honors the backpressure from downstream. If thisFlowable violates the rule, the operator will signal aMissingBackpressureException.
 Scheduler:
 concatMapSingleDelayError does not operate by default on a particularScheduler.
 History: 2.1.11 - experimental
 Type Parameters:
 R - the result type of the innerSingleSources
 Parameters:
 mapper - the function called with the upstream item and should return aSingleSource to become the next source to be subscribed to
 tillTheEnd - Iftrue, errors from thisFlowable or any of the innerSingleSources are delayed until all of them terminate. Iffalse, an error from thisFlowable is delayed until the current innerSingleSource terminates and only then is it emitted to the downstream.
 Returns:
 a new Flowable instance
 Since:
 2.2
 See Also:
 concatMapSingle(Function, int),concatMapSingleDelayError(Function, boolean, int)
 - concatMapSingleDelayError
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> concatMapSingleDelayError(Function<? superT,? extendsSingleSource<? extends R>> mapper, boolean tillTheEnd, int prefetch)
```
 Maps the upstream items intoSingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays errors till both thisFlowable and all innerSingleSources terminate.
 Backpressure:
 The operator expects the upstream to support backpressure and honors the backpressure from downstream. If thisFlowable violates the rule, the operator will signal aMissingBackpressureException.
 Scheduler:
 concatMapSingleDelayError does not operate by default on a particularScheduler.
 History: 2.1.11 - experimental
 Type Parameters:
 R - the result type of the innerSingleSources
 Parameters:
 mapper - the function called with the upstream item and should return aSingleSource to become the next source to be subscribed to
 tillTheEnd - Iftrue, errors from thisFlowable or any of the innerSingleSources are delayed until all of them terminate. Iffalse, an error from thisFlowable is delayed until the current innerSingleSource terminates and only then is it emitted to the downstream.
 prefetch - The number of upstream items to prefetch so that fresh items are ready to be mapped when a previousSingleSource terminates. The operator replenishes after half of the prefetch amount has been consumed and turned intoSingleSources.
 Returns:
 a new Flowable instance
 Since:
 2.2
 See Also:
 concatMapSingle(Function, int)
 - concatWith
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> concatWith(Publisher<? extendsT> other)
```
 Returns a Flowable that emits the items emitted from the current Publisher, then the next, one after the other, without interleaving them.
 Backpressure:
 The operator honors backpressure from downstream. Both this and theotherPublishers are expected to honor backpressure as well. If any of then violates this rule, itmay throw anIllegalStateException when the sourcePublisher completes.
 Scheduler:
 concatWith does not operate by default on a particularScheduler.
 Parameters:
 other - a Publisher to be concatenated after the current
 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
 - concatWith
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> concatWith(@NonNullSingleSource<? extendsT> other)
```
 Returns aFlowable that emits the items from thisFlowable followed by the success item or error event of the otherSingleSource.
 Backpressure:
 The operator supports backpressure and makes sure the success item of the otherSingleSource is only emitted when there is a demand for it.
 Scheduler:
 concatWith does not operate by default on a particularScheduler.
 History: 2.1.10 - experimental
 Parameters:
 other - the SingleSource whose signal should be emitted after thisFlowable completes normally.
 Returns:
 the new Flowable instance
 Since:
 2.2
 - concatWith
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> concatWith(@NonNullMaybeSource<? extendsT> other)
```
 Returns aFlowable that emits the items from thisFlowable followed by the success item or terminal events of the otherMaybeSource.
 Backpressure:
 The operator supports backpressure and makes sure the success item of the otherMaybeSource is only emitted when there is a demand for it.
 Scheduler:
 concatWith does not operate by default on a particularScheduler.
 History: 2.1.10 - experimental
 Parameters:
 other - the MaybeSource whose signal should be emitted after this Flowable completes normally.
 Returns:
 the new Flowable instance
 Since:
 2.2
 - concatWith
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<T> concatWith(@NonNullCompletableSource other)
```
 Returns aFlowable that emits items from thisFlowable and when it completes normally, the otherCompletableSource is subscribed to and the returnedFlowable emits its terminal events.
 Backpressure:
 The operator does not interfere with backpressure between the current Flowable and the downstream consumer (i.e., acts as pass-through). When the operator switches to theCompletable, backpressure is no longer present becauseCompletable doesn't have items to apply backpressure to.
 Scheduler:
 concatWith does not operate by default on a particularScheduler.
 History: 2.1.10 - experimental
 Parameters:
 other - theCompletableSource to subscribe to once the currentFlowable completes normally
 Returns:
 the new Flowable instance
 Since:
 2.2
 - contains
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final Single<Boolean> contains(Object item)
```
 Returns a Single that emits a Boolean that indicates whether the source Publisher emitted a specified item.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure).
 Scheduler:
 contains does not operate by default on a particularScheduler.
 Parameters:
 item - the item to search for in the emissions from the source Publisher
 Returns:
 a Flowable that emitstrue if the specified item is emitted by the source Publisher, orfalse if the source Publisher completes without emitting that item
 See Also:
 ReactiveX operators documentation: Contains
 - count
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final 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.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure).
 Scheduler:
 count does not operate by default on a particularScheduler.
 Returns:
 a Single that emits a single item: the number of items emitted by the source Publisher as a 64-bit Long item
 See Also:
 ReactiveX operators documentation: Count
 - debounce
```
@CheckReturnValue@NonNull@BackpressureSupport(value=ERROR)@SchedulerSupport(value="none")public final  Flowable<T> debounce(Function<? superT,? extendsPublisher> 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.
 The delivery of the item happens on the thread of the firstonNext oronComplete signal of the generatedPublisher sequence, which if takes too long, a newer item may arrive from the upstream, causing the generated sequence to get cancelled, which may also interrupt any downstream blocking operation (yielding anInterruptedException). It is recommended processing items that may take long time to be moved to another thread viaobserveOn(io.reactivex.Scheduler) applied afterdebounce itself.
 Backpressure:
 This operator does not support backpressure as it uses thedebounceSelector to mark boundaries.
 Scheduler:
 This version ofdebounce does not operate by default on a particularScheduler.
 Type Parameters:
 U - the debounce value type (ignored)
 Parameters:
 debounceIndicator - function to retrieve a sequence that indicates the throttle duration for each item
 Returns:
 a Flowable that omits items emitted by the source Publisher that are followed by another item within a computed debounce duration
 See Also:
 ReactiveX operators documentation: Debounce,RxJava wiki: Backpressure
 - debounce
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="io.reactivex:computation")public final 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. The timer resets on each emission.
 Note: If items keep being emitted by the source Publisher faster than the timeout then no items will be emitted by the resulting Publisher.
 Delivery of the item after the grace period happens on thecomputationScheduler'sWorker which if takes too long, a newer item may arrive from the upstream, causing theWorker's task to get disposed, which may also interrupt any downstream blocking operation (yielding anInterruptedException). It is recommended processing items that may take long time to be moved to another thread viaobserveOn(io.reactivex.Scheduler) applied afterdebounce itself.
 Backpressure:
 This operator does not support backpressure as it uses time to control data flow.
 Scheduler:
 debounce operates by default on thecomputationScheduler.
 Parameters:
 timeout - the length of the window of time that must pass after the emission of an item from the source Publisher in which that Publisher emits no items in order for the item to be emitted by the resulting Publisher
 unit - the unit of time for the specifiedtimeout
 Returns:
 a Flowable that filters out items from the source Publisher that are too quickly followed by newer items
 See Also:
 ReactiveX operators documentation: Debounce,RxJava wiki: Backpressure,throttleWithTimeout(long, TimeUnit)
 - debounce
```
@CheckReturnValue@NonNull@BackpressureSupport(value=ERROR)@SchedulerSupport(value="custom")public final 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. The timer resets on each emission.
 Note: If items keep being emitted by the source Publisher faster than the timeout then no items will be emitted by the resulting Publisher.
 Delivery of the item after the grace period happens on the givenScheduler'sWorker which if takes too long, a newer item may arrive from the upstream, causing theWorker's task to get disposed, which may also interrupt any downstream blocking operation (yielding anInterruptedException). It is recommended processing items that may take long time to be moved to another thread viaobserveOn(io.reactivex.Scheduler) applied afterdebounce itself.
 Backpressure:
 This operator does not support backpressure as it uses time to control data flow.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 timeout - the time each item has to be "the most recent" of those emitted by the source Publisher to ensure that it's not dropped
 unit - the unit of time for the specifiedtimeout
 scheduler - theScheduler to use internally to manage the timers that handle the timeout for each item
 Returns:
 a Flowable that filters out items from the source Publisher that are too quickly followed by newer items
 See Also:
 ReactiveX operators documentation: Debounce,RxJava wiki: Backpressure,throttleWithTimeout(long, TimeUnit, Scheduler)
 - defaultIfEmpty
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final 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.
 Backpressure:
 If the sourcePublisher is empty, this operator is guaranteed to honor backpressure from downstream. If the sourcePublisher is non-empty, it is expected to honor backpressure as well; if the rule is violated, aMissingBackpressureExceptionmay get signaled somewhere downstream.
 Scheduler:
 defaultIfEmpty does not operate by default on a particularScheduler.
 Parameters:
 defaultItem - the item to emit if the source Publisher emits no items
 Returns:
 a Flowable that emits either the specified default item if the source Publisher emits no items, or the items emitted by the source Publisher
 See Also:
 ReactiveX operators documentation: DefaultIfEmpty
 - delay
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final  Flowable<T> delay(Function<? superT,? extendsPublisher> itemDelayIndicator)
```
 Returns a Flowable that delays the emissions of the source Publisher via another Publisher on a per-item basis.
 Note: the resulting Publisher will immediately propagate anyonError notification from the source Publisher.
 Backpressure:
 The operator doesn't interfere with the backpressure behavior which is determined by the sourcePublisher. All of the otherPublishers supplied by the function are consumed in an unbounded manner (i.e., no backpressure applied to them).
 Scheduler:
 This version ofdelay does not operate by default on a particularScheduler.
 Type Parameters:
 U - the item delay value type (ignored)
 Parameters:
 itemDelayIndicator - a function that returns a Publisher for each item emitted by the source Publisher, which is then used to delay the emission of that item by the resulting Publisher until the Publisher returned fromitemDelay emits an item
 Returns:
 a Flowable that delays the emissions of the source Publisher via another Publisher on a per-item basis
 See Also:
 ReactiveX operators documentation: Delay
 - delay
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="io.reactivex:computation")public final 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. Error notifications from the source Publisher are not delayed.
 Backpressure:
 The operator doesn't interfere with the backpressure behavior which is determined by the sourcePublisher.
 Scheduler:
 This version ofdelay operates by default on thecomputationScheduler.
 Parameters:
 delay - the delay to shift the source by
 unit - theTimeUnit in whichperiod is defined
 Returns:
 the source Publisher shifted in time by the specified delay
 See Also:
 ReactiveX operators documentation: Delay
 - delay
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="io.reactivex:computation")public final 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. IfdelayError is true, error notifications will also be delayed.
 Backpressure:
 The operator doesn't interfere with the backpressure behavior which is determined by the sourcePublisher.
 Scheduler:
 This version ofdelay operates by default on thecomputationScheduler.
 Parameters:
 delay - the delay to shift the source by
 unit - theTimeUnit in whichperiod is defined
 delayError - if true, the upstream exception is signaled with the given delay, after all preceding normal elements, if false, the upstream exception is signaled immediately
 Returns:
 the source Publisher shifted in time by the specified delay
 See Also:
 ReactiveX operators documentation: Delay
 - delay
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="custom")public final 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. Error notifications from the source Publisher are not delayed.
 Backpressure:
 The operator doesn't interfere with the backpressure behavior which is determined by the sourcePublisher.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 delay - the delay to shift the source by
 unit - the time unit ofdelay
 scheduler - theScheduler to use for delaying
 Returns:
 the source Publisher shifted in time by the specified delay
 See Also:
 ReactiveX operators documentation: Delay
 - delay
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="custom")public final 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. IfdelayError is true, error notifications will also be delayed.
 Backpressure:
 The operator doesn't interfere with the backpressure behavior which is determined by the sourcePublisher.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 delay - the delay to shift the source by
 unit - the time unit ofdelay
 scheduler - theScheduler to use for delaying
 delayError - if true, the upstream exception is signaled with the given delay, after all preceding normal elements, if false, the upstream exception is signaled immediately
 Returns:
 the source Publisher shifted in time by the specified delay
 See Also:
 ReactiveX operators documentation: Delay
 - delay
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <U,V> Flowable<T> delay(Publisher subscriptionIndicator,Function<? superT,? extendsPublisher<V>> itemDelayIndicator)
```
 Returns a Flowable that delays the subscription to and emissions from the source Publisher via another Publisher on a per-item basis.
 Note: the resulting Publisher will immediately propagate anyonError notification from the source Publisher.
 Backpressure:
 The operator doesn't interfere with the backpressure behavior which is determined by the sourcePublisher. All of the otherPublishers supplied by the functions are consumed in an unbounded manner (i.e., no backpressure applied to them).
 Scheduler:
 This version ofdelay does not operate by default on a particularScheduler.
 Type Parameters:
 U - the subscription delay value type (ignored)
 V - the item delay value type (ignored)
 Parameters:
 subscriptionIndicator - a function that returns a Publisher that triggers the subscription to the source Publisher once it emits any item
 itemDelayIndicator - a function that returns a Publisher for each item emitted by the source Publisher, which is then used to delay the emission of that item by the resulting Publisher until the Publisher returned fromitemDelay emits an item
 Returns:
 a Flowable that delays the subscription and emissions of the source Publisher via another Publisher on a per-item basis
 See Also:
 ReactiveX operators documentation: Delay
 - delaySubscription
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final  Flowable<T> delaySubscription(Publisher subscriptionIndicator)
```
 Returns a Flowable that delays the subscription to this Publisher until the other Publisher emits an element or completes normally.
 Backpressure:
 The operator forwards the backpressure requests to this Publisher once the subscription happens and requests Long.MAX_VALUE from the other Publisher
 Scheduler:
 This method does not operate by default on a particularScheduler.
 Type Parameters:
 U - the value type of the other Publisher, irrelevant
 Parameters:
 subscriptionIndicator - the other Publisher that should trigger the subscription to this Publisher.
 Returns:
 a Flowable that delays the subscription to this Publisher until the other Publisher emits an element or completes normally.
 Since:
 2.0
 - delaySubscription
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="io.reactivex:computation")public final Flowable<T> delaySubscription(long delay,TimeUnit unit)
```
 Returns a Flowable that delays the subscription to the source Publisher by a given amount of time.
 Backpressure:
 The operator doesn't interfere with the backpressure behavior which is determined by the sourcePublisher.
 Scheduler:
 This version ofdelaySubscription operates by default on thecomputationScheduler.
 Parameters:
 delay - the time to delay the subscription
 unit - the time unit ofdelay
 Returns:
 a Flowable that delays the subscription to the source Publisher by the given amount
 See Also:
 ReactiveX operators documentation: Delay
 - delaySubscription
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="custom")public final 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.
 Backpressure:
 The operator doesn't interfere with the backpressure behavior which is determined by the sourcePublisher.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 delay - the time to delay the subscription
 unit - the time unit ofdelay
 scheduler - the Scheduler on which the waiting and subscription will happen
 Returns:
 a Flowable that delays the subscription to the source Publisher by a given amount, waiting and subscribing on the given Scheduler
 See Also:
 ReactiveX operators documentation: Delay
 - dematerialize
```
@CheckReturnValue@SchedulerSupport(value="none")@BackpressureSupport(value=PASS_THROUGH)@Deprecatedpublic final <T2> Flowable<T2> dematerialize()
```
 Deprecated. in 2.2.4; inherently type-unsafe as it overrides the output generic type. Usedematerialize(Function) instead.
 Returns a Flowable that reverses the effect ofmaterialize by transforming theNotification objects emitted by the source Publisher into the items or notifications they represent.
 When the upstream signals anonError oronComplete item, the returned Flowable cancels the flow and terminates with that type of terminal event:
```
 Flowable.just(createOnNext(1), createOnComplete(), createOnNext(2)) .doOnCancel(() -> System.out.println("Cancelled!")); .dematerialize() .test() .assertResult(1);
```
 If the upstream signalsonError oronComplete directly, the flow is terminated with the same event.
```
 Flowable.just(createOnNext(1), createOnNext(2)) .dematerialize() .test() .assertResult(1, 2);
```
 If this behavior is not desired, the completion can be suppressed by applyingconcatWith(Publisher) with anever() source.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 dematerialize does not operate by default on a particularScheduler.
 Type Parameters:
 T2 - the output value type
 Returns:
 a Flowable that emits the items and notifications embedded in theNotification objects emitted by the source Publisher
 See Also:
 ReactiveX operators documentation: Dematerialize,dematerialize(Function)
 - dematerialize
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")@BackpressureSupport(value=PASS_THROUGH)public final <R> Flowable<R> dematerialize(Function<? superT,Notification<R>> selector)
```
 Returns a Flowable that reverses the effect ofmaterialize by transforming theNotification objects extracted from the source items via a selector function into their respectiveSubscriber signal types.
 The intended use of theselector function is to perform a type-safe identity mapping (see example) on a source that is already of typeNotification<T>. The Java language doesn't allow limiting instance methods to a certain generic argument shape, therefore, a function is used to ensure the conversion remains type safe.
 When the upstream signals anonError oronComplete item, the returned Flowable cancels of the flow and terminates with that type of terminal event:
```
 Flowable.just(createOnNext(1), createOnComplete(), createOnNext(2)) .doOnCancel(() -> System.out.println("Canceled!")); .dematerialize(notification -> notification) .test() .assertResult(1);
```
 If the upstream signalsonError oronComplete directly, the flow is terminated with the same event.
```
 Flowable.just(createOnNext(1), createOnNext(2)) .dematerialize(notification -> notification) .test() .assertResult(1, 2);
```
 If this behavior is not desired, the completion can be suppressed by applyingconcatWith(Publisher) with anever() source.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 dematerialize does not operate by default on a particularScheduler.
 Type Parameters:
 R - the output value type
 Parameters:
 selector - function that returns the upstream item and should return a Notification to signal the correspondingSubscriber event to the downstream.
 Returns:
 a Flowable that emits the items and notifications embedded in theNotification objects selected from the items emitted by the source Flowable
 Since:
 2.2.4 - experimental
 See Also:
 ReactiveX operators documentation: Dematerialize
 - distinct
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> distinct()
```
 Returns a Flowable that emits all items emitted by the source Publisher that are distinct based onObject.equals(Object) comparison.
 It is recommended the elements' classT in the flow overrides the defaultObject.equals() andObject.hashCode() to provide a meaningful comparison between items as the default Java implementation only considers reference equivalence.
 By default,distinct() uses an internalHashSet per Subscriber to remember previously seen items and usesSet.add(Object) returningfalse as the indicator for duplicates.
 Note that this internalHashSet may grow unbounded as items won't be removed from it by the operator. Therefore, using very long or infinite upstream (with very distinct elements) may lead toOutOfMemoryError.
 Customizing the retention policy can happen only by providing a customCollection implementation to thedistinct(Function, Callable) overload.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 distinct does not operate by default on a particularScheduler.
 Returns:
 a Flowable that emits only those items emitted by the source Publisher that are distinct from each other
 See Also:
 ReactiveX operators documentation: Distinct,distinct(Function),distinct(Function, Callable)
 - distinct
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <K> Flowable<T> distinct(Function<? superT,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 onObject.equals(Object) comparison of the objects returned by the key selector function.
 It is recommended the keys' classK overrides the defaultObject.equals() andObject.hashCode() to provide a meaningful comparison between the key objects as the default Java implementation only considers reference equivalence.
 By default,distinct() uses an internalHashSet per Subscriber to remember previously seen keys and usesSet.add(Object) returningfalse as the indicator for duplicates.
 Note that this internalHashSet may grow unbounded as keys won't be removed from it by the operator. Therefore, using very long or infinite upstream (with very distinct keys) may lead toOutOfMemoryError.
 Customizing the retention policy can happen only by providing a customCollection implementation to thedistinct(Function, Callable) overload.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 distinct does not operate by default on a particularScheduler.
 Type Parameters:
 K - the key type
 Parameters:
 keySelector - a function that projects an emitted item to a key value that is used to decide whether an item is distinct from another one or not
 Returns:
 a Flowable that emits those items emitted by the source Publisher that have distinct keys
 See Also:
 ReactiveX operators documentation: Distinct,distinct(Function, Callable)
 - distinct
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <K> Flowable<T> distinct(Function<? superT,K> keySelector,Callable<? extendsCollection<? 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 onObject.equals(Object) comparison of the objects returned by the key selector function.
 It is recommended the keys' classK overrides the defaultObject.equals() andObject.hashCode() to provide a meaningful comparison between the key objects as the default Java implementation only considers reference equivalence.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 distinct does not operate by default on a particularScheduler.
 Type Parameters:
 K - the key type
 Parameters:
 keySelector - a function that projects an emitted item to a key value that is used to decide whether an item is distinct from another one or not
 collectionSupplier - function called for each individual Subscriber to return a Collection subtype for holding the extracted keys and whose add() method's return indicates uniqueness.
 Returns:
 a Flowable that emits those items emitted by the source Publisher that have distinct keys
 See Also:
 ReactiveX operators documentation: Distinct
 - distinctUntilChanged
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> distinctUntilChanged()
```
 Returns a Flowable that emits all items emitted by the source Publisher that are distinct from their immediate predecessors based onObject.equals(Object) comparison.
 It is recommended the elements' classT in the flow overrides the defaultObject.equals() to provide a meaningful comparison between items as the default Java implementation only considers reference equivalence. Alternatively, use thedistinctUntilChanged(BiPredicate) overload and provide a comparison function in case the classT can't be overridden with customequals() or the comparison itself should happen on different terms or properties of the classT.
 Note that the operator always retains the latest item from upstream regardless of the comparison result and uses it in the next comparison with the next upstream item.
 Note that if element typeT in the flow is mutable, the comparison of the previous and current item may yield unexpected results if the items are mutated externally. Common cases are mutableCharSequences orLists where the objects will actually have the same references when they are modified anddistinctUntilChanged will evaluate subsequent items as same. To avoid such situation, it is recommended that mutable data is converted to an immutable one, for example usingmap(CharSequence::toString) ormap(list -> Collections.unmodifiableList(new ArrayList<>(list))).
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 distinctUntilChanged does not operate by default on a particularScheduler.
 Returns:
 a Flowable that emits those items from the source Publisher that are distinct from their immediate predecessors
 See Also:
 ReactiveX operators documentation: Distinct,distinctUntilChanged(BiPredicate)
 - distinctUntilChanged
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <K> Flowable<T> distinctUntilChanged(Function<? superT,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 onObject.equals(Object) comparison of those objects returned by the key selector function.
 It is recommended the keys' classK overrides the defaultObject.equals() to provide a meaningful comparison between the key objects as the default Java implementation only considers reference equivalence. Alternatively, use thedistinctUntilChanged(BiPredicate) overload and provide a comparison function in case the classK can't be overridden with customequals() or the comparison itself should happen on different terms or properties of the item classT (for which the keys can be derived via a similar selector).
 Note that the operator always retains the latest key from upstream regardless of the comparison result and uses it in the next comparison with the next key derived from the next upstream item.
 Note that if element typeT in the flow is mutable, the comparison of the previous and current item may yield unexpected results if the items are mutated externally. Common cases are mutableCharSequences orLists where the objects will actually have the same references when they are modified anddistinctUntilChanged will evaluate subsequent items as same. To avoid such situation, it is recommended that mutable data is converted to an immutable one, for example usingmap(CharSequence::toString) ormap(list -> Collections.unmodifiableList(new ArrayList<>(list))).
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 distinctUntilChanged does not operate by default on a particularScheduler.
 Type Parameters:
 K - the key type
 Parameters:
 keySelector - a function that projects an emitted item to a key value that is used to decide whether an item is distinct from another one or not
 Returns:
 a Flowable that emits those items from the source Publisher whose keys are distinct from those of their immediate predecessors
 See Also:
 ReactiveX operators documentation: Distinct
 - distinctUntilChanged
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> distinctUntilChanged(BiPredicate<? superT,? superT> 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.
 Note that the operator always retains the latest item from upstream regardless of the comparison result and uses it in the next comparison with the next upstream item.
 Note that if element typeT in the flow is mutable, the comparison of the previous and current item may yield unexpected results if the items are mutated externally. Common cases are mutableCharSequences orLists where the objects will actually have the same references when they are modified anddistinctUntilChanged will evaluate subsequent items as same. To avoid such situation, it is recommended that mutable data is converted to an immutable one, for example usingmap(CharSequence::toString) ormap(list -> Collections.unmodifiableList(new ArrayList<>(list))).
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 distinctUntilChanged does not operate by default on a particularScheduler.
 Parameters:
 comparer - the function that receives the previous item and the current item and is expected to return true if the two are equal, thus skipping the current value.
 Returns:
 a Flowable that emits those items from the source Publisher that are distinct from their immediate predecessors
 Since:
 2.0
 See Also:
 ReactiveX operators documentation: Distinct
 - doFinally
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<T> doFinally(Action onFinally)
```
 Calls the specified action after this Flowable signals onError or onCompleted or gets canceled by the downstream.
 In case of a race between a terminal event and a cancellation, the providedonFinally action is executed once per subscription.
 Note that theonFinally action is shared between subscriptions and as such should be thread-safe.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 doFinally does not operate by default on a particularScheduler.
 Operator-fusion:
 This operator supports normal and conditional Subscribers as well as boundary-limited synchronous or asynchronous queue-fusion.
 History: 2.0.1 - experimental
 Parameters:
 onFinally - the action called when this Flowable terminates or gets canceled
 Returns:
 the new Flowable instance
 Since:
 2.1
 - doAfterNext
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<T> doAfterNext(Consumer<? superT> onAfterNext)
```
 Calls the specified consumer with the current item after this item has been emitted to the downstream.
 Note that theonAfterNext action is shared between subscriptions and as such should be thread-safe.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 doAfterNext does not operate by default on a particularScheduler.
 Operator-fusion:
 This operator supports normal and conditional Subscribers as well as boundary-limited synchronous or asynchronous queue-fusion.
 History: 2.0.1 - experimental
 Parameters:
 onAfterNext - the Consumer that will be called after emitting an item from upstream to the downstream
 Returns:
 the new Flowable instance
 Since:
 2.1
 - doAfterTerminate
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<T> doAfterTerminate(Action onAfterTerminate)
```
 Registers anAction to be called when this Publisher invokes eitheronComplete oronError.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 doAfterTerminate does not operate by default on a particularScheduler.
 Parameters:
 onAfterTerminate - anAction to be invoked when the source Publisher finishes
 Returns:
 a Flowable that emits the same items as the source Publisher, then invokes theAction
 See Also:
 ReactiveX operators documentation: Do,doOnTerminate(Action)
 - doOnCancel
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<T> doOnCancel(Action onCancel)
```
 Calls the cancelAction if the downstream cancels the sequence.
 The action is shared between subscriptions and thus may be called concurrently from multiple threads; the action must be thread-safe.
 If the action throws a runtime exception, that exception is rethrown by theonCancel() call, sometimes as aCompositeException if there were multiple exceptions along the way.
 Note that terminal events trigger the action unless thePublisher is subscribed to viaunsafeSubscribe().
 Backpressure:
 doOnCancel does not interact with backpressure requests or value delivery; backpressure behavior is preserved between its upstream and its downstream.
 Scheduler:
 doOnCancel does not operate by default on a particularScheduler.
 Parameters:
 onCancel - the action that gets called when the sourcePublisher's Subscription is canceled
 Returns:
 the sourcePublisher modified so as to call this Action when appropriate
 See Also:
 ReactiveX operators documentation: Do
 - doOnComplete
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<T> doOnComplete(Action onComplete)
```
 Modifies the source Publisher so that it invokes an action when it callsonComplete.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 doOnComplete does not operate by default on a particularScheduler.
 Parameters:
 onComplete - the action to invoke when the source Publisher callsonComplete
 Returns:
 the source Publisher with the side-effecting behavior applied
 See Also:
 ReactiveX operators documentation: Do
 - doOnEach
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<T> doOnEach(Consumer<? superNotification<T>> onNotification)
```
 Modifies the source Publisher so that it invokes an action for each item it emits.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 doOnEach does not operate by default on a particularScheduler.
 Parameters:
 onNotification - the action to invoke for each item emitted by the source Publisher
 Returns:
 the source Publisher with the side-effecting behavior applied
 See Also:
 ReactiveX operators documentation: Do
 - doOnEach
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<T> doOnEach(Subscriber<? superT> subscriber)
```
 Modifies the source Publisher so that it notifies a Subscriber for each item and terminal event it emits.
 In case theonError of the supplied Subscriber throws, the downstream will receive a composite exception containing the original exception and the exception thrown byonError. If either theonNext or theonComplete method of the supplied Subscriber throws, the downstream will be terminated and will receive this thrown exception.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 doOnEach does not operate by default on a particularScheduler.
 Parameters:
 subscriber - the Subscriber to be notified about onNext, onError and onComplete events on its respective methods before the actual downstream Subscriber gets notified.
 Returns:
 the source Publisher with the side-effecting behavior applied
 See Also:
 ReactiveX operators documentation: Do
 - doOnError
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<T> doOnError(Consumer<? superThrowable> onError)
```
 Modifies the source Publisher so that it invokes an action if it callsonError.
 In case theonError action throws, the downstream will receive a composite exception containing the original exception and the exception thrown byonError.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 doOnError does not operate by default on a particularScheduler.
 Parameters:
 onError - the action to invoke if the source Publisher callsonError
 Returns:
 the source Publisher with the side-effecting behavior applied
 See Also:
 ReactiveX operators documentation: Do
 - doOnLifecycle
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<T> doOnLifecycle(Consumer<? superSubscription> onSubscribe,LongConsumer onRequest,Action onCancel)
```
 Calls the appropriate onXXX method (shared between all Subscribers) for the lifecycle events of the sequence (subscription, cancellation, requesting).
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 doOnLifecycle does not operate by default on a particularScheduler.
 Parameters:
 onSubscribe - a Consumer called with the Subscription sent via Subscriber.onSubscribe()
 onRequest - a LongConsumer called with the request amount sent via Subscription.request()
 onCancel - called when the downstream cancels the Subscription via cancel()
 Returns:
 the source Publisher with the side-effecting behavior applied
 See Also:
 ReactiveX operators documentation: Do
 - doOnNext
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<T> doOnNext(Consumer<? superT> onNext)
```
 Modifies the source Publisher so that it invokes an action when it callsonNext.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 doOnNext does not operate by default on a particularScheduler.
 Parameters:
 onNext - the action to invoke when the source Publisher callsonNext
 Returns:
 the source Publisher with the side-effecting behavior applied
 See Also:
 ReactiveX operators documentation: Do
 - doOnRequest
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<T> doOnRequest(LongConsumer onRequest)
```
 Modifies the sourcePublisher so that it invokes the given action when it receives a request for more items.
 Note: This operator is for tracing the internal behavior of back-pressure request patterns and generally intended for debugging use.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 doOnRequest does not operate by default on a particularScheduler.
 Parameters:
 onRequest - the action that gets called when a Subscriber requests items from thisPublisher
 Returns:
 the sourcePublisher modified so as to call this Action when appropriate
 Since:
 2.0
 See Also:
 ReactiveX operators documentation: Do
 - doOnSubscribe
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<T> doOnSubscribe(Consumer<? superSubscription> onSubscribe)
```
 Modifies the sourcePublisher so that it invokes the given action when it is subscribed from its subscribers. Each subscription will result in an invocation of the given action except when the sourcePublisher is reference counted, in which case the sourcePublisher will invoke the given action for the first subscription.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 doOnSubscribe does not operate by default on a particularScheduler.
 Parameters:
 onSubscribe - the Consumer that gets called when a Subscriber subscribes to the currentFlowable
 Returns:
 the sourcePublisher modified so as to call this Consumer when appropriate
 See Also:
 ReactiveX operators documentation: Do
 - doOnTerminate
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<T> doOnTerminate(Action onTerminate)
```
 Modifies the source Publisher so that it invokes an action when it callsonComplete oronError.
 This differs fromdoAfterTerminate in that this happensbefore theonComplete oronError notification.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 doOnTerminate does not operate by default on a particularScheduler.
 Parameters:
 onTerminate - the action to invoke when the source Publisher callsonComplete oronError
 Returns:
 the source Publisher with the side-effecting behavior applied
 See Also:
 ReactiveX operators documentation: Do,doAfterTerminate(Action)
 - elementAt
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final 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.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 elementAt does not operate by default on a particularScheduler.
 Parameters:
 index - the zero-based index of the item to retrieve
 Returns:
 a Maybe that emits a single item: the item at the specified position in the sequence of those emitted by the source Publisher
 See Also:
 ReactiveX operators documentation: ElementAt
 - elementAt
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final 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.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 elementAt does not operate by default on a particularScheduler.
 Parameters:
 index - the zero-based index of the item to retrieve
 defaultItem - the default item
 Returns:
 a Single that emits the item at the specified position in the sequence emitted by the source Publisher, or the default item if that index is outside the bounds of the source sequence
 Throws:
 IndexOutOfBoundsException - ifindex is less than 0
 See Also:
 ReactiveX operators documentation: ElementAt
 - elementAtOrError
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final 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 aNoSuchElementException if this Flowable has fewer elements than index.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 elementAtOrError does not operate by default on a particularScheduler.
 Parameters:
 index - the zero-based index of the item to retrieve
 Returns:
 a Single that emits the item at the specified position in the sequence emitted by the source Publisher, or the default item if that index is outside the bounds of the source sequence
 Throws:
 IndexOutOfBoundsException - ifindex is less than 0
 See Also:
 ReactiveX operators documentation: ElementAt
 - filter
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<T> filter(Predicate<? superT> predicate)
```
 Filters items emitted by a Publisher by only emitting those that satisfy a specified predicate.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 filter does not operate by default on a particularScheduler.
 Parameters:
 predicate - a function that evaluates each item emitted by the source Publisher, returningtrue if it passes the filter
 Returns:
 a Flowable that emits only those items emitted by the source Publisher that the filter evaluates astrue
 See Also:
 ReactiveX operators documentation: Filter
 - firstElement
```
@CheckReturnValue@BackpressureSupport(value=SPECIAL)@SchedulerSupport(value="none")public final Maybe<T> firstElement()
```
 Returns a Maybe that emits only the very first item emitted by this Flowable or completes if this Flowable is empty.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure).
 Scheduler:
 firstElement does not operate by default on a particularScheduler.
 Returns:
 the new Maybe instance
 See Also:
 ReactiveX operators documentation: First
 - first
```
@CheckReturnValue@BackpressureSupport(value=SPECIAL)@SchedulerSupport(value="none")public final 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.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure).
 Scheduler:
 first does not operate by default on a particularScheduler.
 Parameters:
 defaultItem - the default item to emit if the source Publisher doesn't emit anything
 Returns:
 a Single that emits only the very first item from the source, or a default item if the source Publisher completes without emitting any items
 See Also:
 ReactiveX operators documentation: First
 - firstOrError
```
@CheckReturnValue@BackpressureSupport(value=SPECIAL)@SchedulerSupport(value="none")public final Single<T> firstOrError()
```
 Returns a Single that emits only the very first item emitted by this Flowable or signals aNoSuchElementException if this Flowable is empty.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure).
 Scheduler:
 firstOrError does not operate by default on a particularScheduler.
 Returns:
 the new Single instance
 See Also:
 ReactiveX operators documentation: First
 - flatMap
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> flatMap(Function<? superT,? extendsPublisher<? 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.
 Backpressure:
 The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up tobufferSize() outstanding request amount for items). The innerPublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 flatMap does not operate by default on a particularScheduler.
 Type Parameters:
 R - the value type of the inner Publishers and the output type
 Parameters:
 mapper - a function that, when applied to an item emitted by the source Publisher, returns a Publisher
 Returns:
 a Flowable that emits the result of applying the transformation function to each item emitted by the source Publisher and merging the results of the Publishers obtained from this transformation
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMap
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> flatMap(Function<? superT,? extendsPublisher<? 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.
 Backpressure:
 The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up tobufferSize() outstanding request amount for items). The innerPublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 flatMap does not operate by default on a particularScheduler.
 Type Parameters:
 R - the value type of the inner Publishers and the output type
 Parameters:
 mapper - a function that, when applied to an item emitted by the source Publisher, returns a Publisher
 delayErrors - if true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate if false, the first one signaling an exception will terminate the whole sequence immediately
 Returns:
 a Flowable that emits the result of applying the transformation function to each item emitted by the source Publisher and merging the results of the Publishers obtained from this transformation
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMap
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> flatMap(Function<? superT,? extendsPublisher<? 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.
 Backpressure:
 The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up tomaxConcurrency outstanding request amount for items). The innerPublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 flatMap does not operate by default on a particularScheduler.
 Type Parameters:
 R - the value type of the inner Publishers and the output type
 Parameters:
 mapper - a function that, when applied to an item emitted by the source Publisher, returns a Publisher
 maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
 Returns:
 a Flowable that emits the result of applying the transformation function to each item emitted by the source Publisher and merging the results of the Publishers obtained from this transformation
 Since:
 2.0
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMap
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> flatMap(Function<? superT,? extendsPublisher<? 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.
 Backpressure:
 The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up tomaxConcurrency outstanding request amount for items). The innerPublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 flatMap does not operate by default on a particularScheduler.
 Type Parameters:
 R - the value type of the inner Publishers and the output type
 Parameters:
 mapper - a function that, when applied to an item emitted by the source Publisher, returns a Publisher
 maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
 delayErrors - if true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate if false, the first one signaling an exception will terminate the whole sequence immediately
 Returns:
 a Flowable that emits the result of applying the transformation function to each item emitted by the source Publisher and merging the results of the Publishers obtained from this transformation
 Since:
 2.0
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMap
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> flatMap(Function<? superT,? extendsPublisher<? 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.
 Backpressure:
 The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up tomaxConcurrency outstanding request amount for items). The innerPublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 flatMap does not operate by default on a particularScheduler.
 Type Parameters:
 R - the value type of the inner Publishers and the output type
 Parameters:
 mapper - a function that, when applied to an item emitted by the source Publisher, returns a Publisher
 maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
 delayErrors - if true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate if false, the first one signaling an exception will terminate the whole sequence immediately
 bufferSize - the number of elements to prefetch from each inner Publisher
 Returns:
 a Flowable that emits the result of applying the transformation function to each item emitted by the source Publisher and merging the results of the Publishers obtained from this transformation
 Since:
 2.0
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMap
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> flatMap(Function<? superT,? extendsPublisher<? extends R>> onNextMapper,Function<? superThrowable,? extendsPublisher<? extends R>> onErrorMapper,Callable<? extendsPublisher<? 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.
 Backpressure:
 The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up tobufferSize() outstanding request amount for items). The innerPublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 flatMap does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result type
 Parameters:
 onNextMapper - a function that returns a Publisher to merge for each item emitted by the source Publisher
 onErrorMapper - a function that returns a Publisher to merge for an onError notification from the source Publisher
 onCompleteSupplier - a function that returns a Publisher to merge for an onComplete notification from the source Publisher
 Returns:
 a Flowable that emits the results of merging the Publishers returned from applying the specified functions to the emissions and notifications of the source Publisher
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMap
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> flatMap(Function<? superT,? extendsPublisher<? extends R>> onNextMapper,Function<Throwable,? extendsPublisher<? extends R>> onErrorMapper,Callable<? extendsPublisher<? 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.
 Backpressure:
 The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up tomaxConcurrency outstanding request amount for items). The innerPublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 flatMap does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result type
 Parameters:
 onNextMapper - a function that returns a Publisher to merge for each item emitted by the source Publisher
 onErrorMapper - a function that returns a Publisher to merge for an onError notification from the source Publisher
 onCompleteSupplier - a function that returns a Publisher to merge for an onComplete notification from the source Publisher
 maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
 Returns:
 a Flowable that emits the results of merging the Publishers returned from applying the specified functions to the emissions and notifications of the source Publisher
 Since:
 2.0
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMap
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <U,R> Flowable<R> flatMap(Function<? superT,? extendsPublisher<? extends U>> mapper,BiFunction<? superT,? 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.
 Backpressure:
 The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up tomaxConcurrency outstanding request amount for items). The innerPublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 flatMap does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of items emitted by the inner Publishers
 R - the type of items emitted by the combiner function
 Parameters:
 mapper - a function that returns a Publisher for each item emitted by the source Publisher
 combiner - a function that combines one item emitted by each of the source and collection Publishers and returns an item to be emitted by the resulting Publisher
 Returns:
 a Flowable that emits the results of applying a function to a pair of values emitted by the source Publisher and the collection Publisher
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMap
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <U,R> Flowable<R> flatMap(Function<? superT,? extendsPublisher<? extends U>> mapper,BiFunction<? superT,? 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.
 Backpressure:
 The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up tobufferSize() outstanding request amount for items). The innerPublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 flatMap does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of items emitted by the inner Publishers
 R - the type of items emitted by the combiner functions
 Parameters:
 mapper - a function that returns a Publisher for each item emitted by the source Publisher
 combiner - a function that combines one item emitted by each of the source and collection Publishers and returns an item to be emitted by the resulting Publisher
 delayErrors - if true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate if false, the first one signaling an exception will terminate the whole sequence immediately
 Returns:
 a Flowable that emits the results of applying a function to a pair of values emitted by the source Publisher and the collection Publisher
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMap
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <U,R> Flowable<R> flatMap(Function<? superT,? extendsPublisher<? extends U>> mapper,BiFunction<? superT,? 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.
 Backpressure:
 The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up tomaxConcurrency outstanding request amount for items). The innerPublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 flatMap does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of items emitted by the inner Publishers
 R - the type of items emitted by the combiner function
 Parameters:
 mapper - a function that returns a Publisher for each item emitted by the source Publisher
 combiner - a function that combines one item emitted by each of the source and collection Publishers and returns an item to be emitted by the resulting Publisher
 maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
 delayErrors - if true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate if false, the first one signaling an exception will terminate the whole sequence immediately
 Returns:
 a Flowable that emits the results of applying a function to a pair of values emitted by the source Publisher and the collection Publisher
 Since:
 2.0
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMap
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <U,R> Flowable<R> flatMap(Function<? superT,? extendsPublisher<? extends U>> mapper,BiFunction<? superT,? 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.
 Backpressure:
 The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up tomaxConcurrency outstanding request amount for items). The innerPublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 flatMap does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of items emitted by the inner Publishers
 R - the type of items emitted by the combiner function
 Parameters:
 mapper - a function that returns a Publisher for each item emitted by the source Publisher
 combiner - a function that combines one item emitted by each of the source and collection Publishers and returns an item to be emitted by the resulting Publisher
 maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
 delayErrors - if true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate if false, the first one signaling an exception will terminate the whole sequence immediately
 bufferSize - the number of elements to prefetch from the inner Publishers.
 Returns:
 a Flowable that emits the results of applying a function to a pair of values emitted by the source Publisher and the collection Publisher
 Since:
 2.0
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMap
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <U,R> Flowable<R> flatMap(Function<? superT,? extendsPublisher<? extends U>> mapper,BiFunction<? superT,? 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.
 Backpressure:
 The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up tobufferSize() outstanding request amount for items). The innerPublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 flatMap does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of items emitted by the inner Publishers
 R - the type of items emitted by the combiner function
 Parameters:
 mapper - a function that returns a Publisher for each item emitted by the source Publisher
 combiner - a function that combines one item emitted by each of the source and collection Publishers and returns an item to be emitted by the resulting Publisher
 maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
 Returns:
 a Flowable that emits the results of applying a function to a pair of values emitted by the source Publisher and the collection Publisher
 Since:
 2.0
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMapCompletable
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final Completable flatMapCompletable(Function<? superT,? extendsCompletableSource> mapper)
```
 Maps each element of the upstream Flowable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete.
 Backpressure:
 The operator consumes the upstream in an unbounded manner.
 Scheduler:
 flatMapCompletable does not operate by default on a particularScheduler.
 Parameters:
 mapper - the function that received each source value and transforms them into CompletableSources.
 Returns:
 the new Completable instance
 - flatMapCompletable
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final Completable flatMapCompletable(Function<? superT,? extendsCompletableSource> 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.
 Backpressure:
 IfmaxConcurrency == Integer.MAX_VALUE the operator consumes the upstream in an unbounded manner. Otherwise, the operator expects the upstream to honor backpressure. If the upstream doesn't support backpressure the operator behaves as ifmaxConcurrency == Integer.MAX_VALUE was used.
 Scheduler:
 flatMapCompletable does not operate by default on a particularScheduler.
 Parameters:
 mapper - the function that received each source value and transforms them into CompletableSources.
 delayErrors - if true errors from the upstream and inner CompletableSources are delayed until each of them terminates.
 maxConcurrency - the maximum number of active subscriptions to the CompletableSources.
 Returns:
 the new Completable instance
 - flatMapIterable
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final  Flowable flatMapIterable(Function<? superT,? extendsIterable<? 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.
 Backpressure:
 The operator honors backpressure from downstream. The sourcePublishers is expected to honor backpressure as well. If the sourcePublisher violates the rule, the operator will signal aMissingBackpressureException.
 Scheduler:
 flatMapIterable does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of item emitted by the resulting Iterable
 Parameters:
 mapper - a function that returns an Iterable sequence of values for when given an item emitted by the source Publisher
 Returns:
 a Flowable that emits the results of merging the items emitted by the source Publisher with the values in the Iterables corresponding to those items, as generated bycollectionSelector
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMapIterable
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final  Flowable flatMapIterable(Function<? superT,? extendsIterable<? 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.
 Backpressure:
 The operator honors backpressure from downstream. The sourcePublishers is expected to honor backpressure as well. If the sourcePublisher violates the rule, the operator will signal aMissingBackpressureException.
 Scheduler:
 flatMapIterable does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of item emitted by the resulting Iterable
 Parameters:
 mapper - a function that returns an Iterable sequence of values for when given an item emitted by the source Publisher
 bufferSize - the number of elements to prefetch from the current Flowable
 Returns:
 a Flowable that emits the results of merging the items emitted by the source Publisher with the values in the Iterables corresponding to those items, as generated bycollectionSelector
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMapIterable
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <U,V> Flowable<V> flatMapIterable(Function<? superT,? extendsIterable<? extends U>> mapper,BiFunction<? superT,? 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.
 Backpressure:
 The operator honors backpressure from downstream and the sourcePublishers is consumed in an unbounded manner (i.e., no backpressure is applied to it).
 Scheduler:
 flatMapIterable does not operate by default on a particularScheduler.
 Type Parameters:
 U - the collection element type
 V - the type of item emitted by the resulting Iterable
 Parameters:
 mapper - a function that returns an Iterable sequence of values for each item emitted by the source Publisher
 resultSelector - a function that returns an item based on the item emitted by the source Publisher and the Iterable returned for that item by thecollectionSelector
 Returns:
 a Flowable that emits the items returned byresultSelector for each item in the source Publisher
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMapIterable
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <U,V> Flowable<V> flatMapIterable(Function<? superT,? extendsIterable<? extends U>> mapper,BiFunction<? superT,? 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.
 Backpressure:
 The operator honors backpressure from downstream. The sourcePublishers is expected to honor backpressure as well. If the sourcePublisher violates the rule, the operator will signal aMissingBackpressureException.
 Scheduler:
 flatMapIterable does not operate by default on a particularScheduler.
 Type Parameters:
 U - the element type of the inner Iterable sequences
 V - the type of item emitted by the resulting Publisher
 Parameters:
 mapper - a function that returns an Iterable sequence of values for when given an item emitted by the source Publisher
 resultSelector - a function that returns an item based on the item emitted by the source Publisher and the Iterable returned for that item by thecollectionSelector
 prefetch - the number of elements to prefetch from the current Flowable
 Returns:
 a Flowable that emits the results of merging the items emitted by the source Publisher with the values in the Iterables corresponding to those items, as generated bycollectionSelector
 Since:
 2.0
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMapMaybe
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final <R> Flowable<R> flatMapMaybe(Function<? superT,? extendsMaybeSource<? 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.
 Backpressure:
 The operator consumes the upstream in an unbounded manner.
 Scheduler:
 flatMapMaybe does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result value type
 Parameters:
 mapper - the function that received each source value and transforms them into MaybeSources.
 Returns:
 the new Flowable instance
 - flatMapMaybe
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final <R> Flowable<R> flatMapMaybe(Function<? superT,? extendsMaybeSource<? extends R>> mapper, boolean delayErrors, int maxConcurrency)
```
 Maps each element of the upstream Flowable into MaybeSources, subscribes to at mostmaxConcurrency MaybeSources at a time and merges their onSuccess values, in no particular order, into a single Flowable sequence, optionally delaying all errors.
 Backpressure:
 IfmaxConcurrency == Integer.MAX_VALUE the operator consumes the upstream in an unbounded manner. Otherwise, the operator expects the upstream to honor backpressure. If the upstream doesn't support backpressure the operator behaves as ifmaxConcurrency == Integer.MAX_VALUE was used.
 Scheduler:
 flatMapMaybe does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result value type
 Parameters:
 mapper - the function that received each source value and transforms them into MaybeSources.
 delayErrors - if true errors from the upstream and inner MaybeSources are delayed until each of them terminates.
 maxConcurrency - the maximum number of active subscriptions to the MaybeSources.
 Returns:
 the new Flowable instance
 - flatMapSingle
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final <R> Flowable<R> flatMapSingle(Function<? superT,? extendsSingleSource<? 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.
 Backpressure:
 The operator consumes the upstream in an unbounded manner.
 Scheduler:
 flatMapSingle does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result value type
 Parameters:
 mapper - the function that received each source value and transforms them into SingleSources.
 Returns:
 the new Flowable instance
 - flatMapSingle
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final <R> Flowable<R> flatMapSingle(Function<? superT,? extendsSingleSource<? extends R>> mapper, boolean delayErrors, int maxConcurrency)
```
 Maps each element of the upstream Flowable into SingleSources, subscribes to at mostmaxConcurrency SingleSources at a time and merges their onSuccess values, in no particular order, into a single Flowable sequence, optionally delaying all errors.
 Backpressure:
 IfmaxConcurrency == Integer.MAX_VALUE the operator consumes the upstream in an unbounded manner. Otherwise, the operator expects the upstream to honor backpressure. If the upstream doesn't support backpressure the operator behaves as ifmaxConcurrency == Integer.MAX_VALUE was used.
 Scheduler:
 flatMapSingle does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result value type
 Parameters:
 mapper - the function that received each source value and transforms them into SingleSources.
 delayErrors - if true errors from the upstream and inner SingleSources are delayed until each of them terminates.
 maxConcurrency - the maximum number of active subscriptions to the SingleSources.
 Returns:
 the new Flowable instance
 - forEach
```
@CheckReturnValue@BackpressureSupport(value=NONE)@SchedulerSupport(value="none")public final Disposable forEach(Consumer<? superT> onNext)
```
 Subscribes to thePublisher and receives notifications for each element.
 Alias tosubscribe(Consumer)
 Backpressure:
 The operator consumes the sourcePublisher in an unbounded manner (i.e., no backpressure is applied to it).
 Scheduler:
 forEach does not operate by default on a particularScheduler.
 Parameters:
 onNext -Consumer to execute for each item.
 Returns:
 a Disposable that allows canceling an asynchronous sequence
 Throws:
 NullPointerException - ifonNext is null
 See Also:
 ReactiveX operators documentation: Subscribe
 - forEachWhile
```
@CheckReturnValue@BackpressureSupport(value=NONE)@SchedulerSupport(value="none")public final Disposable forEachWhile(Predicate<? superT> onNext)
```
 Subscribes to thePublisher and receives notifications for each element until the onNext Predicate returns false.
 If the Flowable emits an error, it is wrapped into anOnErrorNotImplementedException and routed to the RxJavaPlugins.onError handler.
 Backpressure:
 The operator consumes the sourcePublisher in an unbounded manner (i.e., no backpressure is applied to it).
 Scheduler:
 forEachWhile does not operate by default on a particularScheduler.
 Parameters:
 onNext -Predicate to execute for each item.
 Returns:
 aDisposable that allows canceling an asynchronous sequence
 Throws:
 NullPointerException - ifonNext is null
 See Also:
 ReactiveX operators documentation: Subscribe
 - forEachWhile
```
@CheckReturnValue@BackpressureSupport(value=NONE)@SchedulerSupport(value="none")public final Disposable forEachWhile(Predicate<? superT> onNext,Consumer<? superThrowable> onError)
```
 Subscribes to thePublisher and receives notifications for each element and error events until the onNext Predicate returns false.
 Backpressure:
 The operator consumes the sourcePublisher in an unbounded manner (i.e., no backpressure is applied to it).
 Scheduler:
 forEachWhile does not operate by default on a particularScheduler.
 Parameters:
 onNext -Predicate to execute for each item.
 onError -Consumer to execute when an error is emitted.
 Returns:
 aDisposable that allows canceling an asynchronous sequence
 Throws:
 NullPointerException - ifonNext is null, or ifonError is null
 See Also:
 ReactiveX operators documentation: Subscribe
 - forEachWhile
```
@CheckReturnValue@NonNull@BackpressureSupport(value=NONE)@SchedulerSupport(value="none")public final Disposable forEachWhile(Predicate<? superT> onNext,Consumer<? superThrowable> onError,Action onComplete)
```
 Subscribes to thePublisher and receives notifications for each element and the terminal events until the onNext Predicate returns false.
 Backpressure:
 The operator consumes the sourcePublisher in an unbounded manner (i.e., no backpressure is applied to it).
 Scheduler:
 forEachWhile does not operate by default on a particularScheduler.
 Parameters:
 onNext -Predicate to execute for each item.
 onError -Consumer to execute when an error is emitted.
 onComplete -Action to execute when completion is signaled.
 Returns:
 aDisposable that allows canceling an asynchronous sequence
 Throws:
 NullPointerException - ifonNext is null, or ifonError is null, or ifonComplete is null
 See Also:
 ReactiveX operators documentation: Subscribe
 - groupBy
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <K> Flowable<GroupedFlowable<K,T>> groupBy(Function<? superT,? extends K> keySelector)
```
 Groups the items emitted by aPublisher according to a specified criterion, and emits these grouped items asGroupedFlowables. The emittedGroupedPublisher allows only a singleSubscriber during its lifetime and if thisSubscriber cancels before the source terminates, the next emission by the source having the same key will trigger a newGroupedPublisher emission.
 Note: AGroupedFlowable will cache the items it is to emit until such time as it is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore thoseGroupedPublishers that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator likeignoreElements() to them.
 Note that theGroupedFlowables should be subscribed to as soon as possible, otherwise, the unconsumed groups may starve other groups due to the internal backpressure coordination of thegroupBy operator. Such hangs can be usually avoided by usingflatMap(Function, int) orconcatMapEager(Function, int, int) and overriding the default maximum concurrency value to be greater or equal to the expected number of groups, possibly usingInteger.MAX_VALUE if the number of expected groups is unknown.
 Backpressure:
 Both the returned and its innerPublishers honor backpressure and the sourcePublisher is consumed in a bounded mode (i.e., requested a fixed amount upfront and replenished based on downstream consumption). Note that both the returned and its innerPublishers use unbounded internal buffers and if the sourcePublisher doesn't honor backpressure, thatmay lead toOutOfMemoryError.
 Scheduler:
 groupBy does not operate by default on a particularScheduler.
 Type Parameters:
 K - the key type
 Parameters:
 keySelector - a function that extracts the key for each item
 Returns:
 aPublisher that emitsGroupedFlowables, each of which corresponds to a unique key value and each of which emits those items from the source Publisher that share that key value
 See Also:
 ReactiveX operators documentation: GroupBy
 - groupBy
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <K> Flowable<GroupedFlowable<K,T>> groupBy(Function<? superT,? extends K> keySelector, boolean delayError)
```
 Groups the items emitted by aPublisher according to a specified criterion, and emits these grouped items asGroupedFlowables. The emittedGroupedPublisher allows only a singleSubscriber during its lifetime and if thisSubscriber cancels before the source terminates, the next emission by the source having the same key will trigger a newGroupedPublisher emission.
 Note: AGroupedFlowable will cache the items it is to emit until such time as it is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore thoseGroupedPublishers that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator likeignoreElements() to them.
 Note that theGroupedFlowables should be subscribed to as soon as possible, otherwise, the unconsumed groups may starve other groups due to the internal backpressure coordination of thegroupBy operator. Such hangs can be usually avoided by usingflatMap(Function, int) orconcatMapEager(Function, int, int) and overriding the default maximum concurrency value to be greater or equal to the expected number of groups, possibly usingInteger.MAX_VALUE if the number of expected groups is unknown.
 Backpressure:
 Both the returned and its innerPublishers honor backpressure and the sourcePublisher is consumed in a bounded mode (i.e., requested a fixed amount upfront and replenished based on downstream consumption). Note that both the returned and its innerPublishers use unbounded internal buffers and if the sourcePublisher doesn't honor backpressure, thatmay lead toOutOfMemoryError.
 Scheduler:
 groupBy does not operate by default on a particularScheduler.
 Type Parameters:
 K - the key type
 Parameters:
 keySelector - a function that extracts the key for each item
 delayError - if true, the exception from the current Flowable is delayed in each group until that specific group emitted the normal values; if false, the exception bypasses values in the groups and is reported immediately.
 Returns:
 aPublisher that emitsGroupedFlowables, each of which corresponds to a unique key value and each of which emits those items from the source Publisher that share that key value
 See Also:
 ReactiveX operators documentation: GroupBy
 - groupBy
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <K,V> Flowable<GroupedFlowable<K,V>> groupBy(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector)
```
 Groups the items emitted by aPublisher according to a specified criterion, and emits these grouped items asGroupedFlowables. The emittedGroupedPublisher allows only a singleSubscriber during its lifetime and if thisSubscriber cancels before the source terminates, the next emission by the source having the same key will trigger a newGroupedPublisher emission.
 Note: AGroupedFlowable will cache the items it is to emit until such time as it is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore thoseGroupedPublishers that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator likeignoreElements() to them.
 Note that theGroupedFlowables should be subscribed to as soon as possible, otherwise, the unconsumed groups may starve other groups due to the internal backpressure coordination of thegroupBy operator. Such hangs can be usually avoided by usingflatMap(Function, int) orconcatMapEager(Function, int, int) and overriding the default maximum concurrency value to be greater or equal to the expected number of groups, possibly usingInteger.MAX_VALUE if the number of expected groups is unknown.
 Backpressure:
 Both the returned and its innerPublishers honor backpressure and the sourcePublisher is consumed in a bounded mode (i.e., requested a fixed amount upfront and replenished based on downstream consumption). Note that both the returned and its innerPublishers use unbounded internal buffers and if the sourcePublisher doesn't honor backpressure, thatmay lead toOutOfMemoryError.
 Scheduler:
 groupBy does not operate by default on a particularScheduler.
 Type Parameters:
 K - the key type
 V - the element type
 Parameters:
 keySelector - a function that extracts the key for each item
 valueSelector - a function that extracts the return element for each item
 Returns:
 aPublisher that emitsGroupedFlowables, each of which corresponds to a unique key value and each of which emits those items from the source Publisher that share that key value
 See Also:
 ReactiveX operators documentation: GroupBy
 - groupBy
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <K,V> Flowable<GroupedFlowable<K,V>> groupBy(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector, boolean delayError)
```
 Groups the items emitted by aPublisher according to a specified criterion, and emits these grouped items asGroupedFlowables. The emittedGroupedPublisher allows only a singleSubscriber during its lifetime and if thisSubscriber cancels before the source terminates, the next emission by the source having the same key will trigger a newGroupedPublisher emission.
 Note: AGroupedFlowable will cache the items it is to emit until such time as it is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore thoseGroupedPublishers that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator likeignoreElements() to them.
 Note that theGroupedFlowables should be subscribed to as soon as possible, otherwise, the unconsumed groups may starve other groups due to the internal backpressure coordination of thegroupBy operator. Such hangs can be usually avoided by usingflatMap(Function, int) orconcatMapEager(Function, int, int) and overriding the default maximum concurrency value to be greater or equal to the expected number of groups, possibly usingInteger.MAX_VALUE if the number of expected groups is unknown.
 Backpressure:
 Both the returned and its innerPublishers honor backpressure and the sourcePublisher is consumed in a bounded mode (i.e., requested a fixed amount upfront and replenished based on downstream consumption). Note that both the returned and its innerPublishers use unbounded internal buffers and if the sourcePublisher doesn't honor backpressure, thatmay lead toOutOfMemoryError.
 Scheduler:
 groupBy does not operate by default on a particularScheduler.
 Type Parameters:
 K - the key type
 V - the element type
 Parameters:
 keySelector - a function that extracts the key for each item
 valueSelector - a function that extracts the return element for each item
 delayError - if true, the exception from the current Flowable is delayed in each group until that specific group emitted the normal values; if false, the exception bypasses values in the groups and is reported immediately.
 Returns:
 aPublisher that emitsGroupedFlowables, each of which corresponds to a unique key value and each of which emits those items from the source Publisher that share that key value
 See Also:
 ReactiveX operators documentation: GroupBy
 - groupBy
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <K,V> Flowable<GroupedFlowable<K,V>> groupBy(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector, boolean delayError, int bufferSize)
```
 Groups the items emitted by aPublisher according to a specified criterion, and emits these grouped items asGroupedFlowables. The emittedGroupedPublisher allows only a singleSubscriber during its lifetime and if thisSubscriber cancels before the source terminates, the next emission by the source having the same key will trigger a newGroupedPublisher emission.
 Note: AGroupedFlowable will cache the items it is to emit until such time as it is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore thoseGroupedPublishers that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator likeignoreElements() to them.
 Note that theGroupedFlowables should be subscribed to as soon as possible, otherwise, the unconsumed groups may starve other groups due to the internal backpressure coordination of thegroupBy operator. Such hangs can be usually avoided by usingflatMap(Function, int) orconcatMapEager(Function, int, int) and overriding the default maximum concurrency value to be greater or equal to the expected number of groups, possibly usingInteger.MAX_VALUE if the number of expected groups is unknown.
 Backpressure:
 Both the returned and its innerPublishers honor backpressure and the sourcePublisher is consumed in a bounded mode (i.e., requested a fixed amount upfront and replenished based on downstream consumption). Note that both the returned and its innerPublishers use unbounded internal buffers and if the sourcePublisher doesn't honor backpressure, thatmay lead toOutOfMemoryError.
 Scheduler:
 groupBy does not operate by default on a particularScheduler.
 Type Parameters:
 K - the key type
 V - the element type
 Parameters:
 keySelector - a function that extracts the key for each item
 valueSelector - a function that extracts the return element for each item
 delayError - if true, the exception from the current Flowable is delayed in each group until that specific group emitted the normal values; if false, the exception bypasses values in the groups and is reported immediately.
 bufferSize - the hint for how manyGroupedFlowables and element in eachGroupedFlowable should be buffered
 Returns:
 aPublisher that emitsGroupedFlowables, each of which corresponds to a unique key value and each of which emits those items from the source Publisher that share that key value
 See Also:
 ReactiveX operators documentation: GroupBy
 - groupBy
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <K,V> Flowable<GroupedFlowable<K,V>> groupBy(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector, boolean delayError, int bufferSize,Function<? superConsumer<Object>,? extendsMap<K,Object>> evictingMapFactory)
```
 Groups the items emitted by aPublisher according to a specified criterion, and emits these grouped items asGroupedFlowables. The emittedGroupedFlowable allows only a singleSubscriber during its lifetime and if thisSubscriber cancels before the source terminates, the next emission by the source having the same key will trigger a newGroupedPublisher emission. TheevictingMapFactory is used to create a map that will be used to hold theGroupedFlowables by key. The evicting map created by this factory must notify the providedConsumer<Object> with the entry value (not the key!) when an entry in this map has been evicted. The next source emission will bring about the completion of the evictedGroupedFlowables and the arrival of an item with the same key as a completedGroupedFlowable will prompt the creation and emission of a newGroupedFlowable with that key.
 A use case for specifying anevictingMapFactory is where the source is infinite and fast and over time the number of keys grows enough to be a concern in terms of the memory footprint of the internal hash map containing theGroupedFlowables.
 The map created by anevictingMapFactory must be thread-safe.
 An example of anevictingMapFactory usingCacheBuilder from the Guava library is below:
```
 Function<Consumer<Object>, Map<Integer, Object>> evictingMapFactory = notify -> CacheBuilder .newBuilder() .maximumSize(3) .removalListener(entry -> { try { // emit the value not the key! notify.accept(entry.getValue()); } catch (Exception e) { throw new RuntimeException(e); } }) .<Integer, Object> build() .asMap(); // Emit 1000 items but ensure that the // internal map never has more than 3 items in it Flowable .range(1, 1000) // note that number of keys is 10 .groupBy(x -> x % 10, x -> x, true, 16, evictingMapFactory) .flatMap(g -> g) .forEach(System.out::println);
```
 Note: AGroupedFlowable will cache the items it is to emit until such time as it is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore thoseGroupedFlowables that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator likeignoreElements() to them.
 Note that theGroupedFlowables should be subscribed to as soon as possible, otherwise, the unconsumed groups may starve other groups due to the internal backpressure coordination of thegroupBy operator. Such hangs can be usually avoided by usingflatMap(Function, int) orconcatMapEager(Function, int, int) and overriding the default maximum concurrency value to be greater or equal to the expected number of groups, possibly usingInteger.MAX_VALUE if the number of expected groups is unknown.
 Backpressure:
 Both the returned and its innerGroupedFlowables honor backpressure and the sourcePublisher is consumed in a bounded mode (i.e., requested a fixed amount upfront and replenished based on downstream consumption). Note that both the returned and its innerGroupedFlowables use unbounded internal buffers and if the sourcePublisher doesn't honor backpressure, thatmay lead toOutOfMemoryError.
 Scheduler:
 groupBy does not operate by default on a particularScheduler.
 History: 2.1.10 - beta
 Type Parameters:
 K - the key type
 V - the element type
 Parameters:
 keySelector - a function that extracts the key for each item
 valueSelector - a function that extracts the return element for each item
 delayError - if true, the exception from the current Flowable is delayed in each group until that specific group emitted the normal values; if false, the exception bypasses values in the groups and is reported immediately.
 bufferSize - the hint for how manyGroupedFlowables and element in eachGroupedFlowable should be buffered
 evictingMapFactory - The factory used to create a map that will be used by the implementation to hold theGroupedFlowables. The evicting map created by this factory must notify the providedConsumer<Object> with the entry value (not the key!) when an entry in this map has been evicted. The next source emission will bring about the completion of the evictedGroupedFlowables. See example above.
 Returns:
 aPublisher that emitsGroupedFlowables, each of which corresponds to a unique key value and each of which emits those items from the source Publisher that share that key value
 Since:
 2.2
 See Also:
 ReactiveX operators documentation: GroupBy
 - groupJoin
```
@CheckReturnValue@NonNull@BackpressureSupport(value=ERROR)@SchedulerSupport(value="none")public final <TRight,TLeftEnd,TRightEnd,R> Flowable<R> groupJoin(Publisher<? extends TRight> other,Function<? superT,? extendsPublisher<TLeftEnd>> leftEnd,Function<? super TRight,? extendsPublisher<TRightEnd>> rightEnd,BiFunction<? superT,? superFlowable<TRight>,? extends R> resultSelector)
```
 Returns a Flowable that correlates two Publishers when they overlap in time and groups the results.
 There are no guarantees in what order the items get combined when multiple items from one or both source Publishers overlap.
 Backpressure:
 The operator doesn't support backpressure and consumes all participatingPublishers in an unbounded mode (i.e., not applying any backpressure to them).
 Scheduler:
 groupJoin does not operate by default on a particularScheduler.
 Type Parameters:
 TRight - the value type of the right Publisher source
 TLeftEnd - the element type of the left duration Publishers
 TRightEnd - the element type of the right duration Publishers
 R - the result type
 Parameters:
 other - the other Publisher to correlate items from the source Publisher with
 leftEnd - a function that returns a Publisher whose emissions indicate the duration of the values of the source Publisher
 rightEnd - a function that returns a Publisher whose emissions indicate the duration of the values of theright Publisher
 resultSelector - a function that takes an item emitted by each Publisher and returns the value to be emitted by the resulting Publisher
 Returns:
 a Flowable that emits items based on combining those items emitted by the source Publishers whose durations overlap
 See Also:
 ReactiveX operators documentation: Join
 - hide
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<T> hide()
```
 Hides the identity of this Flowable and its Subscription.
 Allows hiding extra features such asProcessor'sSubscriber methods or preventing certain identity-based optimizations (fusion).
 Backpressure:
 The operator is a pass-through for backpressure, the behavior is determined by the upstream's backpressure behavior.
 Scheduler:
 hide does not operate by default on a particularScheduler.
 Returns:
 the new Flowable instance
 Since:
 2.0
 - ignoreElements
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final Completable ignoreElements()
```
 Ignores all items emitted by the source Publisher and only callsonComplete oronError.
 Backpressure:
 This operator ignores backpressure as it doesn't emit any elements and consumes the sourcePublisher in an unbounded manner (i.e., no backpressure is applied to it).
 Scheduler:
 ignoreElements does not operate by default on a particularScheduler.
 Returns:
 a Completable that only callsonComplete oronError, based on which one is called by the source Publisher
 See Also:
 ReactiveX operators documentation: IgnoreElements
 - isEmpty
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final Single<Boolean> isEmpty()
```
 Returns a Single that emitstrue if the source Publisher is empty, otherwisefalse.
 In Rx.Net this is negated as theany Subscriber but we renamed this in RxJava to better match Java naming idioms.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure).
 Scheduler:
 isEmpty does not operate by default on a particularScheduler.
 Returns:
 a Flowable that emits a Boolean
 See Also:
 ReactiveX operators documentation: Contains
 - join
```
@CheckReturnValue@NonNull@BackpressureSupport(value=ERROR)@SchedulerSupport(value="none")public final <TRight,TLeftEnd,TRightEnd,R> Flowable<R> join(Publisher<? extends TRight> other,Function<? superT,? extendsPublisher<TLeftEnd>> leftEnd,Function<? super TRight,? extendsPublisher<TRightEnd>> rightEnd,BiFunction<? superT,? super TRight,? extends R> resultSelector)
```
 Correlates the items emitted by two Publishers based on overlapping durations.
 There are no guarantees in what order the items get combined when multiple items from one or both source Publishers overlap.
 Backpressure:
 The operator doesn't support backpressure and consumes all participatingPublishers in an unbounded mode (i.e., not applying any backpressure to them).
 Scheduler:
 join does not operate by default on a particularScheduler.
 Type Parameters:
 TRight - the value type of the right Publisher source
 TLeftEnd - the element type of the left duration Publishers
 TRightEnd - the element type of the right duration Publishers
 R - the result type
 Parameters:
 other - the second Publisher to join items from
 leftEnd - a function to select a duration for each item emitted by the source Publisher, used to determine overlap
 rightEnd - a function to select a duration for each item emitted by theright Publisher, used to determine overlap
 resultSelector - a function that computes an item to be emitted by the resulting Publisher for any two overlapping items emitted by the two Publishers
 Returns:
 a Flowable that emits items correlating to items emitted by the source Publishers that have overlapping durations
 See Also:
 ReactiveX operators documentation: Join
 - lastElement
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final Maybe<T> lastElement()
```
 Returns a Maybe that emits the last item emitted by this Flowable or completes if this Flowable is empty.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure).
 Scheduler:
 lastElement does not operate by default on a particularScheduler.
 Returns:
 a new Maybe instance
 See Also:
 ReactiveX operators documentation: Last
 - last
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final 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.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure).
 Scheduler:
 last does not operate by default on a particularScheduler.
 Parameters:
 defaultItem - the default item to emit if the source Publisher is empty
 Returns:
 the new Single instance
 See Also:
 ReactiveX operators documentation: Last
 - lastOrError
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final Single<T> lastOrError()
```
 Returns a Single that emits only the last item emitted by this Flowable or signals aNoSuchElementException if this Flowable is empty.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure).
 Scheduler:
 lastOrError does not operate by default on a particularScheduler.
 Returns:
 the new Single instance
 See Also:
 ReactiveX operators documentation: Last
 - lift
```
@CheckReturnValue@NonNull@BackpressureSupport(value=SPECIAL)@SchedulerSupport(value="none")public final <R> Flowable<R> lift(FlowableOperator<? extends R,? superT> lifter)
```
 This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns aFlowable which, when subscribed to, invokes theapply(Subscriber) method of the providedFlowableOperator for each individual downstreamSubscriber and allows the insertion of a custom operator by accessing the downstream'sSubscriber during this subscription phase and providing a newSubscriber, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.
 Generally, such a newSubscriber will wrap the downstream'sSubscriber and forwards theonNext,onError andonComplete events from the upstream directly or according to the emission pattern the custom operator's business logic requires. In addition, such operator can intercept the flow control calls ofcancel andrequest that would have traveled upstream and perform additional actions depending on the same business logic requirements.
 Example:
```
 // Step 1: Create the consumer type that will be returned by the FlowableOperator.apply(): public final class CustomSubscriber<T> implements FlowableSubscriber<T>, Subscription { // The downstream's Subscriber that will receive the onXXX events final Subscriber<? super String> downstream; // The connection to the upstream source that will call this class' onXXX methods Subscription upstream; // The constructor takes the downstream subscriber and usually any other parameters public CustomSubscriber(Subscriber<? super String> downstream) { this.downstream = downstream; } // In the subscription phase, the upstream sends a Subscription to this class // and subsequently this class has to send a Subscription to the downstream. // Note that relaying the upstream's Subscription instance directly is not allowed in RxJava @Override public void onSubscribe(Subscription s) { if (upstream != null) { s.cancel(); } else { upstream = s; downstream.onSubscribe(this); } } // The upstream calls this with the next item and the implementation's // responsibility is to emit an item to the downstream based on the intended // business logic, or if it can't do so for the particular item, // request more from the upstream @Override public void onNext(T item) { String str = item.toString(); if (str.length() < 2) { downstream.onNext(str); } else { upstream.request(1); } } // Some operators may handle the upstream's error while others // could just forward it to the downstream. @Override public void onError(Throwable throwable) { downstream.onError(throwable); } // When the upstream completes, usually the downstream should complete as well. @Override public void onComplete() { downstream.onComplete(); } // Some operators have to intercept the downstream's request calls to trigger // the emission of queued items while others can simply forward the request // amount as is. @Override public void request(long n) { upstream.request(n); } // Some operators may use their own resources which should be cleaned up if // the downstream cancels the flow before it completed. Operators without // resources can simply forward the cancellation to the upstream. // In some cases, a canceled flag may be set by this method so that other parts // of this class may detect the cancellation and stop sending events // to the downstream. @Override public void cancel() { upstream.cancel(); } } // Step 2: Create a class that implements the FlowableOperator interface and // returns the custom consumer type from above in its apply() method. // Such class may define additional parameters to be submitted to // the custom consumer type. final class CustomOperator<T> implements FlowableOperator<String> { @Override public Subscriber<? super String> apply(Subscriber<? super T> upstream) { return new CustomSubscriber<T>(upstream); } } // Step 3: Apply the custom operator via lift() in a flow by creating an instance of it // or reusing an existing one. Flowable.range(5, 10) .lift(new CustomOperator<Integer>()) .test() .assertResult("5", "6", "7", "8", "9");
```
 Creating custom operators can be complicated and it is recommended one consults theRxJava wiki: Writing operators page about the tools, requirements, rules, considerations and pitfalls of implementing them.
 Note that implementing custom operators via thislift() method adds slightly more overhead by requiring an additional allocation and indirection per assembled flows. Instead, extending the abstractFlowable class and creating aFlowableTransformer with it is recommended.
 Note also that it is not possible to stop the subscription phase inlift() as theapply() method requires a non-nullSubscriber instance to be returned, which is then unconditionally subscribed to the upstreamFlowable. For example, if the operator decided there is no reason to subscribe to the upstream source because of some optimization possibility or a failure to prepare the operator, it still has to return aSubscriber that should immediately cancel the upstream'sSubscription in itsonSubscribe method. Again, using aFlowableTransformer and extending theFlowable is a better option assubscribeActual(org.reactivestreams.Subscriber<? super T>) can decide to not subscribe to its upstream after all.
 Backpressure:
 TheSubscriber instance returned by theFlowableOperator is responsible to be backpressure-aware or document the fact that the consumer of the returnedPublisher has to apply one of theonBackpressureXXX operators.
 Scheduler:
 lift does not operate by default on a particularScheduler, however, theFlowableOperator may use aScheduler to support its own asynchronous behavior.
 Type Parameters:
 R - the output value type
 Parameters:
 lifter - theFlowableOperator that receives the downstream'sSubscriber and should return aSubscriber with custom behavior to be used as the consumer for the currentFlowable.
 Returns:
 the new Flowable instance
 See Also:
 RxJava wiki: Writing operators,compose(FlowableTransformer)
 - limit
```
@BackpressureSupport(value=SPECIAL)@SchedulerSupport(value="none")@CheckReturnValuepublic final 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.
 The operator requests at most the givencount of items from upstream even if the downstream requests more than that. For example, given alimit(5), if the downstream requests 1, a request of 1 is submitted to the upstream and the operator remembers that only 4 items can be requested now on. A request of 5 at this point will request 4 from the upstream and any subsequent requests will be ignored.
 Note that requests are negotiated on an operator boundary andlimit's amount may not be preserved further upstream. For example,source.observeOn(Schedulers.computation()).limit(5) will still request the default (128) elements from the givensource.
 The main use of this operator is with sources that are async boundaries that don't interfere with request amounts, such as certainFlowable-based network endpoints that relay downstream request amounts unchanged and are, therefore, prone to trigger excessive item creation/transmission over the network.
 Backpressure:
 The operator requests a total of the givencount items from the upstream.
 Scheduler:
 limit does not operate by default on a particularScheduler.
 History: 2.1.6 - experimental
 Parameters:
 count - the maximum number of items and the total request amount, non-negative. Zero will immediately cancel the upstream on subscription and complete the downstream.
 Returns:
 the new Flowable instance
 Since:
 2.2
 See Also:
 take(long),rebatchRequests(int)
 - map
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final <R> Flowable<R> map(Function<? superT,? 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.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 map does not operate by default on a particularScheduler.
 Type Parameters:
 R - the output type
 Parameters:
 mapper - a function to apply to each item emitted by the Publisher
 Returns:
 a Flowable that emits the items from the source Publisher, transformed by the specified function
 See Also:
 ReactiveX operators documentation: Map
 - materialize
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<Notification<T>> materialize()
```
 Returns a Flowable that represents all of the emissionsand notifications from the source Publisher into emissions marked with their original types withinNotification objects.
 Backpressure:
 The operator honors backpressure from downstream and expects it from the sourcePublisher. If this expectation is violated, the operatormay throw anIllegalStateException.
 Scheduler:
 materialize does not operate by default on a particularScheduler.
 Returns:
 a Flowable that emits items that are the result of materializing the items and notifications of the source Publisher
 See Also:
 ReactiveX operators documentation: Materialize,dematerialize(Function)
 - mergeWith
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> mergeWith(Publisher<? extendsT> other)
```
 Flattens this and another Publisher 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 themergeWith method.
 Backpressure:
 The operator honors backpressure from downstream. This and the otherPublishers are expected to honor backpressure; if violated, the operatormay signalMissingBackpressureException.
 Scheduler:
 mergeWith does not operate by default on a particularScheduler.
 Parameters:
 other - 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
 - mergeWith
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> mergeWith(@NonNullSingleSource<? extendsT> other)
```
 Merges the sequence of items of this Flowable with the success value of the other SingleSource.
 The success value of the otherSingleSource can get interleaved at any point of thisFlowable sequence.
 Backpressure:
 The operator honors backpressure from downstream and ensures the success item from theSingleSource is emitted only when there is a downstream demand.
 Scheduler:
 mergeWith does not operate by default on a particularScheduler.
 History: 2.1.10 - experimental
 Parameters:
 other - theSingleSource whose success value to merge with
 Returns:
 the new Flowable instance
 Since:
 2.2
 - mergeWith
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> mergeWith(@NonNullMaybeSource<? extendsT> 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.
 The success value of the otherMaybeSource can get interleaved at any point of thisFlowable sequence.
 Backpressure:
 The operator honors backpressure from downstream and ensures the success item from theMaybeSource is emitted only when there is a downstream demand.
 Scheduler:
 mergeWith does not operate by default on a particularScheduler.
 History: 2.1.10 - experimental
 Parameters:
 other - theMaybeSource which provides a success value to merge with or completes
 Returns:
 the new Flowable instance
 Since:
 2.2
 - mergeWith
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<T> mergeWith(@NonNullCompletableSource other)
```
 Relays the items of this Flowable and completes only when the other CompletableSource completes as well.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 mergeWith does not operate by default on a particularScheduler.
 History: 2.1.10 - experimental
 Parameters:
 other - theCompletableSource to await for completion
 Returns:
 the new Flowable instance
 Since:
 2.2
 - observeOn
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="custom")public final Flowable<T> observeOn(Scheduler scheduler)
```
 Modifies a Publisher to perform its emissions and notifications on a specifiedScheduler, asynchronously with a bounded buffer ofbufferSize() slots.
 Note that onError notifications will cut ahead of onNext notifications on the emission thread if Scheduler is truly asynchronous. If strict event ordering is required, consider using theobserveOn(Scheduler, boolean) overload.
 This operator keeps emitting as many signals as it can on the given Scheduler's Worker thread, which may result in a longer than expected occupation of this thread. In other terms, it does not allow per-signal fairness in case the worker runs on a shared underlying thread. If such fairness and signal/work interleaving is preferred, use the delay operator with zero time instead.
 Backpressure:
 This operator honors backpressure from downstream and expects it from the sourcePublisher. Violating this expectation will lead toMissingBackpressureException. This is the most common operator where the exception pops up; look for sources up the chain that don't support backpressure, such asinterval,timer, {code PublishSubject} orBehaviorSubject and apply any of theonBackpressureXXX operatorsbefore applyingobserveOn itself.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 scheduler - theScheduler to notifySubscribers on
 Returns:
 the source Publisher modified so that itsSubscribers are notified on the specifiedScheduler
 See Also:
 ReactiveX operators documentation: ObserveOn,RxJava Threading Examples,subscribeOn(io.reactivex.Scheduler),observeOn(Scheduler, boolean),observeOn(Scheduler, boolean, int),delay(long, TimeUnit, Scheduler)
 - observeOn
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="custom")public final Flowable<T> observeOn(Scheduler scheduler, boolean delayError)
```
 Modifies a Publisher to perform its emissions and notifications on a specifiedScheduler, asynchronously with a bounded buffer and optionally delays onError notifications.
 This operator keeps emitting as many signals as it can on the given Scheduler's Worker thread, which may result in a longer than expected occupation of this thread. In other terms, it does not allow per-signal fairness in case the worker runs on a shared underlying thread. If such fairness and signal/work interleaving is preferred, use the delay operator with zero time instead.
 Backpressure:
 This operator honors backpressure from downstream and expects it from the sourcePublisher. Violating this expectation will lead toMissingBackpressureException. This is the most common operator where the exception pops up; look for sources up the chain that don't support backpressure, such asinterval,timer, {code PublishSubject} orBehaviorSubject and apply any of theonBackpressureXXX operatorsbefore applyingobserveOn itself.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 scheduler - theScheduler to notifySubscribers on
 delayError - indicates if the onError notification may not cut ahead of onNext notification on the other side of the scheduling boundary. If true a sequence ending in onError will be replayed in the same order as was received from upstream
 Returns:
 the source Publisher modified so that itsSubscribers are notified on the specifiedScheduler
 See Also:
 ReactiveX operators documentation: ObserveOn,RxJava Threading Examples,subscribeOn(io.reactivex.Scheduler),observeOn(Scheduler),observeOn(Scheduler, boolean, int),delay(long, TimeUnit, Scheduler, boolean)
 - observeOn
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="custom")public final Flowable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize)
```
 Modifies a Publisher to perform its emissions and notifications on a specifiedScheduler, asynchronously with a bounded buffer of configurable size and optionally delays onError notifications.
 This operator keeps emitting as many signals as it can on the given Scheduler's Worker thread, which may result in a longer than expected occupation of this thread. In other terms, it does not allow per-signal fairness in case the worker runs on a shared underlying thread. If such fairness and signal/work interleaving is preferred, use the delay operator with zero time instead.
 Backpressure:
 This operator honors backpressure from downstream and expects it from the sourcePublisher. Violating this expectation will lead toMissingBackpressureException. This is the most common operator where the exception pops up; look for sources up the chain that don't support backpressure, such asinterval,timer, {code PublishSubject} orBehaviorSubject and apply any of theonBackpressureXXX operatorsbefore applyingobserveOn itself.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 scheduler - theScheduler to notifySubscribers on
 delayError - indicates if the onError notification may not cut ahead of onNext notification on the other side of the scheduling boundary. If true a sequence ending in onError will be replayed in the same order as was received from upstream
 bufferSize - the size of the buffer.
 Returns:
 the source Publisher modified so that itsSubscribers are notified on the specifiedScheduler
 See Also:
 ReactiveX operators documentation: ObserveOn,RxJava Threading Examples,subscribeOn(io.reactivex.Scheduler),observeOn(Scheduler),observeOn(Scheduler, boolean),delay(long, TimeUnit, Scheduler, boolean)
 - ofType
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final  Flowable ofType(Class clazz)
```
 Filters the items emitted by a Publisher, only emitting those of the specified type.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 ofType does not operate by default on a particularScheduler.
 Type Parameters:
 U - the output type
 Parameters:
 clazz - the class type to filter the items emitted by the source Publisher
 Returns:
 a Flowable that emits items from the source Publisher of typeclazz
 See Also:
 ReactiveX operators documentation: Filter
 - onBackpressureBuffer
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final 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.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., not applying backpressure to it).
 Scheduler:
 onBackpressureBuffer does not operate by default on a particularScheduler.
 Returns:
 the source Publisher modified to buffer items to the extent system resources allow
 See Also:
 ReactiveX operators documentation: backpressure operators
 - onBackpressureBuffer
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final 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.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., not applying backpressure to it).
 Scheduler:
 onBackpressureBuffer does not operate by default on a particularScheduler.
 Parameters:
 delayError - if true, an exception from the current Flowable is delayed until all buffered elements have been consumed by the downstream; if false, an exception is immediately signaled to the downstream, skipping any buffered element
 Returns:
 the source Publisher modified to buffer items to the extent system resources allow
 See Also:
 ReactiveX operators documentation: backpressure operators
 - onBackpressureBuffer
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="none")public final 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. The resulting Publisher will signal aBufferOverflowException viaonError as soon as the buffer's capacity is exceeded, dropping all undelivered items, and canceling the source.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., not applying backpressure to it).
 Scheduler:
 onBackpressureBuffer does not operate by default on a particularScheduler.
 Parameters:
 capacity - number of slots available in the buffer.
 Returns:
 the sourcePublisher modified to buffer items up to the given capacity.
 Since:
 1.1.0
 See Also:
 ReactiveX operators documentation: backpressure operators
 - onBackpressureBuffer
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="none")public final 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. The resulting Publisher will signal aBufferOverflowException viaonError as soon as the buffer's capacity is exceeded, dropping all undelivered items, and canceling the source.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., not applying backpressure to it).
 Scheduler:
 onBackpressureBuffer does not operate by default on a particularScheduler.
 Parameters:
 capacity - number of slots available in the buffer.
 delayError - if true, an exception from the current Flowable is delayed until all buffered elements have been consumed by the downstream; if false, an exception is immediately signaled to the downstream, skipping any buffered element
 Returns:
 the sourcePublisher modified to buffer items up to the given capacity.
 Since:
 1.1.0
 See Also:
 ReactiveX operators documentation: backpressure operators
 - onBackpressureBuffer
```
@CheckReturnValue@BackpressureSupport(value=SPECIAL)@SchedulerSupport(value="none")public final 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. The resulting Publisher will signal aBufferOverflowException viaonError as soon as the buffer's capacity is exceeded, dropping all undelivered items, and canceling the source.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., not applying backpressure to it).
 Scheduler:
 onBackpressureBuffer does not operate by default on a particularScheduler.
 Parameters:
 capacity - number of slots available in the buffer.
 delayError - if true, an exception from the current Flowable is delayed until all buffered elements have been consumed by the downstream; if false, an exception is immediately signaled to the downstream, skipping any buffered element
 unbounded - if true, the capacity value is interpreted as the internal "island" size of the unbounded buffer
 Returns:
 the sourcePublisher modified to buffer items up to the given capacity.
 Since:
 1.1.0
 See Also:
 ReactiveX operators documentation: backpressure operators
 - onBackpressureBuffer
```
@CheckReturnValue@NonNull@BackpressureSupport(value=SPECIAL)@SchedulerSupport(value="none")public final 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. The resulting Publisher will signal aBufferOverflowException viaonError as soon as the buffer's capacity is exceeded, dropping all undelivered items, canceling the source, and notifying the producer withonOverflow.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., not applying backpressure to it).
 Scheduler:
 onBackpressureBuffer does not operate by default on a particularScheduler.
 Parameters:
 capacity - number of slots available in the buffer.
 delayError - if true, an exception from the current Flowable is delayed until all buffered elements have been consumed by the downstream; if false, an exception is immediately signaled to the downstream, skipping any buffered element
 unbounded - if true, the capacity value is interpreted as the internal "island" size of the unbounded buffer
 onOverflow - action to execute if an item needs to be buffered, but there are no available slots. Null is allowed.
 Returns:
 the sourcePublisher modified to buffer items up to the given capacity
 Since:
 1.1.0
 See Also:
 ReactiveX operators documentation: backpressure operators
 - onBackpressureBuffer
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="none")public final 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. The resulting Publisher will signal aBufferOverflowException viaonError as soon as the buffer's capacity is exceeded, dropping all undelivered items, canceling the source, and notifying the producer withonOverflow.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., not applying backpressure to it).
 Scheduler:
 onBackpressureBuffer does not operate by default on a particularScheduler.
 Parameters:
 capacity - number of slots available in the buffer.
 onOverflow - action to execute if an item needs to be buffered, but there are no available slots. Null is allowed.
 Returns:
 the sourcePublisher modified to buffer items up to the given capacity
 Since:
 1.1.0
 See Also:
 ReactiveX operators documentation: backpressure operators
 - onBackpressureBuffer
```
@CheckReturnValue@NonNull@BackpressureSupport(value=SPECIAL)@SchedulerSupport(value="none")public final 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. The resulting Publisher will behave as determined byoverflowStrategy if the buffer capacity is exceeded.
 - BackpressureOverflow.Strategy.ON_OVERFLOW_ERROR (default) will callonError dropping all undelivered items, canceling the source, and notifying the producer withonOverflow.
 - BackpressureOverflow.Strategy.ON_OVERFLOW_DROP_LATEST will drop any new items emitted by the producer while the buffer is full, without generating anyonError. Each drop will, however, invokeonOverflow to signal the overflow to the producer.
 - BackpressureOverflow.Strategy.ON_OVERFLOW_DROP_OLDEST will drop the oldest items in the buffer in order to make room for newly emitted ones. Overflow will not generate anonError, but each drop will invokeonOverflow to signal the overflow to the producer.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., not applying backpressure to it).
 Scheduler:
 onBackpressureBuffer does not operate by default on a particularScheduler.
 Parameters:
 capacity - number of slots available in the buffer.
 onOverflow - action to execute if an item needs to be buffered, but there are no available slots. Null is allowed.
 overflowStrategy - how should thePublisher react to buffer overflows. Null is not allowed.
 Returns:
 the sourceFlowable modified to buffer items up to the given capacity
 Since:
 2.0
 See Also:
 ReactiveX operators documentation: backpressure operators
 - onBackpressureDrop
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final 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.
 If the downstream request count hits 0 then the Publisher will refrain from callingonNext until the Subscriber invokesrequest(n) again to increase the request count.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., not applying backpressure to it).
 Scheduler:
 onBackpressureDrop does not operate by default on a particularScheduler.
 Returns:
 the source Publisher modified to droponNext notifications on overflow
 See Also:
 ReactiveX operators documentation: backpressure operators
 - onBackpressureDrop
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final Flowable<T> onBackpressureDrop(Consumer<? superT> 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.
 If the downstream request count hits 0 then the Publisher will refrain from callingonNext until the Subscriber invokesrequest(n) again to increase the request count.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., not applying backpressure to it).
 Scheduler:
 onBackpressureDrop does not operate by default on a particularScheduler.
 Parameters:
 onDrop - the action to invoke for each item dropped. onDrop action should be fast and should never block.
 Returns:
 the source Publisher modified to droponNext notifications on overflow
 Since:
 1.1.0
 See Also:
 ReactiveX operators documentation: backpressure operators
 - onBackpressureLatest
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final 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.
 Its behavior is logically equivalent toblockingLatest() with the exception that the downstream is not blocking while requesting more values.
 Note that if the upstream Publisher does support backpressure, this operator ignores that capability and doesn't propagate any backpressure requests from downstream.
 Note that due to the nature of how backpressure requests are propagated through subscribeOn/observeOn, requesting more than 1 from downstream doesn't guarantee a continuous delivery of onNext events.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., not applying backpressure to it).
 Scheduler:
 onBackpressureLatest does not operate by default on a particularScheduler.
 Returns:
 the source Publisher modified so that it emits the most recently-received item upon request
 Since:
 1.1.0
 - onErrorResumeNext
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> onErrorResumeNext(Function<? superThrowable,? extendsPublisher<? extendsT>> resumeFunction)
```
 Instructs a Publisher to pass control to another Publisher rather than invokingonError if it encounters an error.
 By default, when a Publisher encounters an error that prevents it from emitting the expected item to itsSubscriber, the Publisher invokes its Subscriber'sonError method, and then quits without invoking any more of its Subscriber's methods. TheonErrorResumeNext method changes this behavior. If you pass a function that returns a Publisher (resumeFunction) toonErrorResumeNext, if the original Publisher encounters an error, instead of invoking its Subscriber'sonError method, it will instead relinquish control to the Publisher returned fromresumeFunction, which will invoke the Subscriber'sonNext method if it is able to do so. In such a case, because no Publisher necessarily invokesonError, the Subscriber may never know that an error happened.
 You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.
 Backpressure:
 The operator honors backpressure from downstream. This and the resumingPublishers are expected to honor backpressure as well. If any of them violate this expectation, the operatormay throw anIllegalStateException when the sourcePublisher completes or aMissingBackpressureException is signaled somewhere downstream.
 Scheduler:
 onErrorResumeNext does not operate by default on a particularScheduler.
 Parameters:
 resumeFunction - a function that returns a Publisher that will take over if the source Publisher encounters an error
 Returns:
 the original Publisher, with appropriately modified behavior
 See Also:
 ReactiveX operators documentation: Catch
 - onErrorResumeNext
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> onErrorResumeNext(Publisher<? extendsT> next)
```
 Instructs a Publisher to pass control to another Publisher rather than invokingonError if it encounters an error.
 By default, when a Publisher encounters an error that prevents it from emitting the expected item to itsSubscriber, the Publisher invokes its Subscriber'sonError method, and then quits without invoking any more of its Subscriber's methods. TheonErrorResumeNext method changes this behavior. If you pass another Publisher (resumeSequence) to a Publisher'sonErrorResumeNext method, if the original Publisher encounters an error, instead of invoking its Subscriber'sonError method, it will instead relinquish control toresumeSequence which will invoke the Subscriber'sonNext method if it is able to do so. In such a case, because no Publisher necessarily invokesonError, the Subscriber may never know that an error happened.
 You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.
 Backpressure:
 The operator honors backpressure from downstream. This and the resumingPublishers are expected to honor backpressure as well. If any of them violate this expectation, the operatormay throw anIllegalStateException when the sourcePublisher completes orMissingBackpressureException is signaled somewhere downstream.
 Scheduler:
 onErrorResumeNext does not operate by default on a particularScheduler.
 Parameters:
 next - the next Publisher source that will take over if the source Publisher encounters an error
 Returns:
 the original Publisher, with appropriately modified behavior
 See Also:
 ReactiveX operators documentation: Catch
 - onErrorReturn
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> onErrorReturn(Function<? superThrowable,? extendsT> valueSupplier)
```
 Instructs a Publisher to emit an item (returned by a specified function) rather than invokingonError if it encounters an error.
 By default, when a Publisher encounters an error that prevents it from emitting the expected item to itsSubscriber, the Publisher invokes its Subscriber'sonError method, and then quits without invoking any more of its Subscriber's methods. TheonErrorReturn method changes this behavior. If you pass a function (resumeFunction) to a Publisher'sonErrorReturn method, if the original Publisher encounters an error, instead of invoking its Subscriber'sonError method, it will instead emit the return value ofresumeFunction.
 You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.
 Backpressure:
 The operator honors backpressure from downstream. The sourcePublishers is expected to honor backpressure as well. If it this expectation is violated, the operatormay throwIllegalStateException when the sourcePublisher completes orMissingBackpressureException is signaled somewhere downstream.
 Scheduler:
 onErrorReturn does not operate by default on a particularScheduler.
 Parameters:
 valueSupplier - a function that returns a single value that will be emitted along with a regular onComplete in case the current Flowable signals an onError event
 Returns:
 the original Publisher with appropriately modified behavior
 See Also:
 ReactiveX operators documentation: Catch
 - onErrorReturnItem
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> onErrorReturnItem(T item)
```
 Instructs a Publisher to emit an item (returned by a specified function) rather than invokingonError if it encounters an error.
 By default, when a Publisher encounters an error that prevents it from emitting the expected item to itsSubscriber, the Publisher invokes its Subscriber'sonError method, and then quits without invoking any more of its Subscriber's methods. TheonErrorReturn method changes this behavior. If you pass a function (resumeFunction) to a Publisher'sonErrorReturn method, if the original Publisher encounters an error, instead of invoking its Subscriber'sonError method, it will instead emit the return value ofresumeFunction.
 You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.
 Backpressure:
 The operator honors backpressure from downstream. The sourcePublishers is expected to honor backpressure as well. If it this expectation is violated, the operatormay throwIllegalStateException when the sourcePublisher completes orMissingBackpressureException is signaled somewhere downstream.
 Scheduler:
 onErrorReturnItem does not operate by default on a particularScheduler.
 Parameters:
 item - the value that is emitted along with a regular onComplete in case the current Flowable signals an exception
 Returns:
 the original Publisher with appropriately modified behavior
 See Also:
 ReactiveX operators documentation: Catch
 - onExceptionResumeNext
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> onExceptionResumeNext(Publisher<? extendsT> next)
```
 Instructs a Publisher to pass control to another Publisher rather than invokingonError if it encounters anException.
 This differs fromonErrorResumeNext(io.reactivex.functions.Function<? super java.lang.Throwable, ? extends org.reactivestreams.Publisher<? extends T>>) in that this one does not handleThrowable orError but lets those continue through.
 By default, when a Publisher encounters an exception that prevents it from emitting the expected item to itsSubscriber, the Publisher invokes its Subscriber'sonError method, and then quits without invoking any more of its Subscriber's methods. TheonExceptionResumeNext method changes this behavior. If you pass another Publisher (resumeSequence) to a Publisher'sonExceptionResumeNext method, if the original Publisher encounters an exception, instead of invoking its Subscriber'sonError method, it will instead relinquish control toresumeSequence which will invoke the Subscriber'sonNext method if it is able to do so. In such a case, because no Publisher necessarily invokesonError, the Subscriber may never know that an exception happened.
 You can use this to prevent exceptions from propagating or to supply fallback data should exceptions be encountered.
 Backpressure:
 The operator honors backpressure from downstream. This and the resumingPublishers are expected to honor backpressure as well. If any of them violate this expectation, the operatormay throw anIllegalStateException when the sourcePublisher completes orMissingBackpressureException is signaled somewhere downstream.
 Scheduler:
 onExceptionResumeNext does not operate by default on a particularScheduler.
 Parameters:
 next - the next Publisher that will take over if the source Publisher encounters an exception
 Returns:
 the original Publisher, with appropriately modified behavior
 See Also:
 ReactiveX operators documentation: Catch
 - onTerminateDetach
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<T> onTerminateDetach()
```
 Nulls out references to the upstream producer and downstream Subscriber if the sequence is terminated or downstream cancels.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 onTerminateDetach does not operate by default on a particularScheduler.
 Returns:
 a Flowable which nulls out references to the upstream producer and downstream Subscriber if the sequence is terminated or downstream cancels
 Since:
 2.0
 - parallel
```
@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")@CheckReturnValuepublic final 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.
 Note that the rails don't execute in parallel on their own and one needs to applyParallelFlowable.runOn(Scheduler) to specify the Scheduler where each rail will execute.
 To merge the parallel 'rails' back into a single sequence, useParallelFlowable.sequential().
 Backpressure:
 The operator requires the upstream to honor backpressure and each 'rail' honors backpressure as well.
 Scheduler:
 parallel does not operate by default on a particularScheduler.
 History: 2.0.5 - experimental; 2.1 - beta
 Returns:
 the new ParallelFlowable instance
 Since:
 2.2
 - parallel
```
@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")@CheckReturnValuepublic final 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.
 Note that the rails don't execute in parallel on their own and one needs to applyParallelFlowable.runOn(Scheduler) to specify the Scheduler where each rail will execute.
 To merge the parallel 'rails' back into a single sequence, useParallelFlowable.sequential().
 Backpressure:
 The operator requires the upstream to honor backpressure and each 'rail' honors backpressure as well.
 Scheduler:
 parallel does not operate by default on a particularScheduler.
 History: 2.0.5 - experimental; 2.1 - beta
 Parameters:
 parallelism - the number of 'rails' to use
 Returns:
 the new ParallelFlowable instance
 Since:
 2.2
 - parallel
```
@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")@CheckReturnValuepublic final 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.
 Note that the rails don't execute in parallel on their own and one needs to applyParallelFlowable.runOn(Scheduler) to specify the Scheduler where each rail will execute.
 To merge the parallel 'rails' back into a single sequence, useParallelFlowable.sequential().
 Backpressure:
 The operator requires the upstream to honor backpressure and each 'rail' honors backpressure as well.
 Scheduler:
 parallel does not operate by default on a particularScheduler.
 History: 2.0.5 - experimental; 2.1 - beta
 Parameters:
 parallelism - the number of 'rails' to use
 prefetch - the number of items each 'rail' should prefetch
 Returns:
 the new ParallelFlowable instance
 Since:
 2.2
 - publish
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final ConnectableFlowable<T> publish()
```
 Returns aConnectableFlowable, which is a variety of Publisher that waits until itsconnect method is called before it begins emitting items to thoseSubscribers that have subscribed to it.
 Backpressure:
 The returnedConnectableFlowable honors backpressure for each of itsSubscribers and expects the sourcePublisher to honor backpressure as well. If this expectation is violated, the operator will signal aMissingBackpressureException to itsSubscribers and disconnect.
 Scheduler:
 publish does not operate by default on a particularScheduler.
 Returns:
 aConnectableFlowable that upon connection causes the source Publisher to emit items to itsSubscribers
 See Also:
 ReactiveX operators documentation: Publish
 - publish
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> publish(Function<? superFlowable<T>,? extendsPublisher<R>> selector)
```
 Returns a Flowable that emits the results of invoking a specified selector on items emitted by aConnectableFlowable that shares a single subscription to the underlying sequence.
 Backpressure:
 The operator expects the sourcePublisher to honor backpressure and if this expectation is violated, the operator will signal aMissingBackpressureException through thePublisher provided to the function. Since thePublisher returned by theselector may be independent of the providedPublisher to the function, the output's backpressure behavior is determined by this returnedPublisher.
 Scheduler:
 publish does not operate by default on a particularScheduler.
 Type Parameters:
 R - the type of items emitted by the resulting Publisher
 Parameters:
 selector - a function that can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all notifications of the source from the time of the subscription forward.
 Returns:
 a Flowable that emits the results of invoking the selector on the items emitted by aConnectableFlowable that shares a single subscription to the underlying sequence
 See Also:
 ReactiveX operators documentation: Publish
 - publish
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> publish(Function<? superFlowable<T>,? extendsPublisher<? extends R>> selector, int prefetch)
```
 Returns a Flowable that emits the results of invoking a specified selector on items emitted by aConnectableFlowable that shares a single subscription to the underlying sequence.
 Backpressure:
 The operator expects the sourcePublisher to honor backpressure and if this expectation is violated, the operator will signal aMissingBackpressureException through thePublisher provided to the function. Since thePublisher returned by theselector may be independent of the providedPublisher to the function, the output's backpressure behavior is determined by this returnedPublisher.
 Scheduler:
 publish does not operate by default on a particularScheduler.
 Type Parameters:
 R - the type of items emitted by the resulting Publisher
 Parameters:
 selector - a function that can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all notifications of the source from the time of the subscription forward.
 prefetch - the number of elements to prefetch from the current Flowable
 Returns:
 a Flowable that emits the results of invoking the selector on the items emitted by aConnectableFlowable that shares a single subscription to the underlying sequence
 See Also:
 ReactiveX operators documentation: Publish
 - publish
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final ConnectableFlowable<T> publish(int bufferSize)
```
 Returns aConnectableFlowable, which is a variety of Publisher that waits until itsconnect method is called before it begins emitting items to thoseSubscribers that have subscribed to it.
 Backpressure:
 The returnedConnectableFlowable honors backpressure for each of itsSubscribers and expects the sourcePublisher to honor backpressure as well. If this expectation is violated, the operator will signal aMissingBackpressureException to itsSubscribers and disconnect.
 Scheduler:
 publish does not operate by default on a particularScheduler.
 Parameters:
 bufferSize - the number of elements to prefetch from the current Flowable
 Returns:
 aConnectableFlowable that upon connection causes the source Publisher to emit items to itsSubscribers
 See Also:
 ReactiveX operators documentation: Publish
 - rebatchRequests
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> rebatchRequests(int n)
```
 Requestsn initially from the upstream and then 75% ofn subsequently after 75% ofn values have been emitted to the downstream.
 This operator allows preventing the downstream to trigger unbounded mode viarequest(Long.MAX_VALUE) or compensate for the per-item overhead of small and frequent requests.
 Backpressure:
 The operator expects backpressure from upstream and honors backpressure from downstream.
 Scheduler:
 rebatchRequests does not operate by default on a particularScheduler.
 Parameters:
 n - the initial request amount, further request will happen after 75% of this value
 Returns:
 the Publisher that rebatches request amounts from downstream
 Since:
 2.0
 - reduce
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final 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.
 This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate," "compress," or "inject" in other programming contexts. Groovy, for instance, has aninject method that does a similar operation on lists.
 Note that this operator requires the upstream to signalonComplete for the accumulator object to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.
 Backpressure:
 The operator honors backpressure of its downstream consumer and consumes the upstream source in unbounded mode.
 Scheduler:
 reduce does not operate by default on a particularScheduler.
 Parameters:
 reducer - an accumulator function to be invoked on each item emitted by the source Publisher, whose result will be used in the next accumulator call
 Returns:
 a Maybe that emits a single item that is the result of accumulating the items emitted by the source Flowable
 See Also:
 ReactiveX operators documentation: Reduce,Wikipedia: Fold (higher-order function)
 - reduce
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final <R> Single<R> reduce(R seed,BiFunction<R,? superT,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.
 This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate," "compress," or "inject" in other programming contexts. Groovy, for instance, has aninject method that does a similar operation on lists.
 Note that theseed is shared among all subscribers to the resulting Publisher and may cause problems if it is mutable. To make sure each subscriber gets its own value, defer the application of this operator viadefer(Callable):
```
 Publisher<T> source = ... Single.defer(() -> source.reduce(new ArrayList<>(), (list, item) -> list.add(item))); // alternatively, by using compose to stay fluent source.compose(o -> Flowable.defer(() -> o.reduce(new ArrayList<>(), (list, item) -> list.add(item)).toFlowable()) ).firstOrError(); // or, by using reduceWith instead of reduce source.reduceWith(() -> new ArrayList<>(), (list, item) -> list.add(item)));
```
 Note that this operator requires the upstream to signalonComplete for the accumulator object to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.
 Backpressure:
 The operator honors backpressure of its downstream consumer and consumes the upstream source in unbounded mode.
 Scheduler:
 reduce does not operate by default on a particularScheduler.
 Type Parameters:
 R - the accumulator and output value type
 Parameters:
 seed - the initial (seed) accumulator value
 reducer - an accumulator function to be invoked on each item emitted by the source Publisher, the result of which will be used in the next accumulator call
 Returns:
 a Single that emits a single item that is the result of accumulating the output from the items emitted by the source Publisher
 See Also:
 ReactiveX operators documentation: Reduce,Wikipedia: Fold (higher-order function),reduceWith(Callable, BiFunction)
 - reduceWith
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final <R> Single<R> reduceWith(Callable<R> seedSupplier,BiFunction<R,? superT,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.
 This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate," "compress," or "inject" in other programming contexts. Groovy, for instance, has aninject method that does a similar operation on lists.
 Note that this operator requires the upstream to signalonComplete for the accumulator object to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.
 Backpressure:
 The operator honors backpressure of its downstream consumer and consumes the upstream source in unbounded mode.
 Scheduler:
 reduceWith does not operate by default on a particularScheduler.
 Type Parameters:
 R - the accumulator and output value type
 Parameters:
 seedSupplier - the Callable that provides the initial (seed) accumulator value for each individual Subscriber
 reducer - an accumulator function to be invoked on each item emitted by the source Publisher, the result of which will be used in the next accumulator call
 Returns:
 a Single that emits a single item that is the result of accumulating the output from the items emitted by the source Publisher
 See Also:
 ReactiveX operators documentation: Reduce,Wikipedia: Fold (higher-order function)
 - repeat
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> repeat()
```
 Returns a Flowable that repeats the sequence of items emitted by the source Publisher indefinitely.
 Backpressure:
 The operator honors downstream backpressure and expects the sourcePublisher to honor backpressure as well. If this expectation is violated, the operatormay throw anIllegalStateException.
 Scheduler:
 repeat does not operate by default on a particularScheduler.
 Returns:
 a Flowable that emits the items emitted by the source Publisher repeatedly and in sequence
 See Also:
 ReactiveX operators documentation: Repeat
 - repeat
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> repeat(long times)
```
 Returns a Flowable that repeats the sequence of items emitted by the source Publisher at mostcount times.
 Backpressure:
 The operator honors downstream backpressure and expects the sourcePublisher to honor backpressure as well. If this expectation is violated, the operatormay throw anIllegalStateException.
 Scheduler:
 repeat does not operate by default on a particularScheduler.
 Parameters:
 times - the number of times the source Publisher items are repeated, a count of 0 will yield an empty sequence
 Returns:
 a Flowable that repeats the sequence of items emitted by the source Publisher at mostcount times
 Throws:
 IllegalArgumentException - ifcount is less than zero
 See Also:
 ReactiveX operators documentation: Repeat
 - repeatUntil
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final 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.
 Backpressure:
 The operator honors downstream backpressure and expects the sourcePublisher to honor backpressure as well. If this expectation is violated, the operatormay throw anIllegalStateException.
 Scheduler:
 repeatUntil does not operate by default on a particularScheduler.
 Parameters:
 stop - a boolean supplier that is called when the current Flowable completes and unless it returns false, the current Flowable is resubscribed
 Returns:
 the new Flowable instance
 Throws:
 NullPointerException - ifstop is null
 See Also:
 ReactiveX operators documentation: Repeat
 - repeatWhen
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> repeatWhen(Function<? superFlowable<Object>,? extendsPublisher<?>> handler)
```
 Returns a Flowable that emits the same values as the source Publisher with the exception of anonComplete. AnonComplete notification from the source will result in the emission of avoid item to the Publisher provided as an argument to thenotificationHandler function. If that Publisher callsonComplete oronError thenrepeatWhen will callonComplete oronError on the child subscription. Otherwise, this Publisher will resubscribe to the source Publisher.
 Backpressure:
 The operator honors downstream backpressure and expects the sourcePublisher to honor backpressure as well. If this expectation is violated, the operatormay throw anIllegalStateException.
 Scheduler:
 repeatWhen does not operate by default on a particularScheduler.
 Parameters:
 handler - receives a Publisher of notifications with which a user can complete or error, aborting the repeat.
 Returns:
 the source Publisher modified with repeat logic
 See Also:
 ReactiveX operators documentation: Repeat
 - replay
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final ConnectableFlowable<T> replay()
```
 Returns aConnectableFlowable that shares a single subscription to the underlying Publisher that will replay all of its items and notifications to any futureSubscriber. A Connectable Publisher resembles an ordinary Publisher, except that it does not begin emitting items when it is subscribed to, but only when itsconnect method is called.
 Backpressure:
 This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Publisher sequence.
 Scheduler:
 This version ofreplay does not operate by default on a particularScheduler.
 Returns:
 aConnectableFlowable that upon connection causes the source Publisher to emit its items to itsSubscribers
 See Also:
 ReactiveX operators documentation: Replay
 - replay
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> replay(Function<? superFlowable<T>,? extendsPublisher<R>> selector)
```
 Returns a Flowable that emits items that are the results of invoking a specified selector on the items emitted by aConnectableFlowable that shares a single subscription to the source Publisher.
 Backpressure:
 This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Publisher sequence.
 Scheduler:
 This version ofreplay does not operate by default on a particularScheduler.
 Type Parameters:
 R - the type of items emitted by the resulting Publisher
 Parameters:
 selector - the selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the Publisher
 Returns:
 a Flowable that emits items that are the results of invoking the selector on aConnectableFlowable that shares a single subscription to the source Publisher
 See Also:
 ReactiveX operators documentation: Replay
 - replay
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> replay(Function<? superFlowable<T>,? extendsPublisher<R>> selector, int bufferSize)
```
 Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable that shares a single subscription to the source Publisher, replayingbufferSize notifications.
 Note that due to concurrency requirements,replay(bufferSize) may hold strong references to more thanbufferSize source emissions.
 Backpressure:
 This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Publisher sequence.
 Scheduler:
 This version ofreplay does not operate by default on a particularScheduler.
 Type Parameters:
 R - the type of items emitted by the resulting Publisher
 Parameters:
 selector - the selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the Publisher
 bufferSize - the buffer size that limits the number of items the connectable Publisher can replay
 Returns:
 a Flowable that emits items that are the results of invoking the selector on items emitted by aConnectableFlowable that shares a single subscription to the source Publisher replaying no more thanbufferSize items
 See Also:
 ReactiveX operators documentation: Replay
 - replay
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="io.reactivex:computation")public final <R> Flowable<R> replay(Function<? superFlowable<T>,? extendsPublisher<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 aConnectableFlowable that shares a single subscription to the source Publisher, replaying no more thanbufferSize items that were emitted within a specified time window.
 Note that due to concurrency requirements,replay(bufferSize) may hold strong references to more thanbufferSize source emissions.
 Backpressure:
 This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Publisher sequence.
 Scheduler:
 This version ofreplay operates by default on thecomputationScheduler.
 Type Parameters:
 R - the type of items emitted by the resulting Publisher
 Parameters:
 selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the Publisher
 bufferSize - the buffer size that limits the number of items the connectable Publisher can replay
 time - the duration of the window in which the replayed items must have been emitted
 unit - the time unit oftime
 Returns:
 a Flowable that emits items that are the results of invoking the selector on items emitted by aConnectableFlowable that shares a single subscription to the source Publisher, and replays no more thanbufferSize items that were emitted within the window defined bytime
 See Also:
 ReactiveX operators documentation: Replay
 - replay
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="custom")public final <R> Flowable<R> replay(Function<? superFlowable<T>,? extendsPublisher<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 aConnectableFlowable that shares a single subscription to the source Publisher, replaying no more thanbufferSize items that were emitted within a specified time window.
 Note that due to concurrency requirements,replay(bufferSize) may hold strong references to more thanbufferSize source emissions.
 Backpressure:
 This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Publisher sequence.
 Scheduler:
 You specify whichScheduler this operator will use.
 Type Parameters:
 R - the type of items emitted by the resulting Publisher
 Parameters:
 selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the Publisher
 bufferSize - the buffer size that limits the number of items the connectable Publisher can replay
 time - the duration of the window in which the replayed items must have been emitted
 unit - the time unit oftime
 scheduler - the Scheduler that is the time source for the window
 Returns:
 a Flowable that emits items that are the results of invoking the selector on items emitted by aConnectableFlowable that shares a single subscription to the source Publisher, and replays no more thanbufferSize items that were emitted within the window defined bytime
 Throws:
 IllegalArgumentException - ifbufferSize is less than zero
 See Also:
 ReactiveX operators documentation: Replay
 - replay
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="custom")public final <R> Flowable<R> replay(Function<? superFlowable<T>,? extendsPublisher<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 aConnectableFlowable that shares a single subscription to the source Publisher, replaying a maximum ofbufferSize items.
 Note that due to concurrency requirements,replay(bufferSize) may hold strong references to more thanbufferSize source emissions.
 Backpressure:
 This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Publisher sequence.
 Scheduler:
 You specify whichScheduler this operator will use.
 Type Parameters:
 R - the type of items emitted by the resulting Publisher
 Parameters:
 selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the Publisher
 bufferSize - the buffer size that limits the number of items the connectable Publisher can replay
 scheduler - the Scheduler on which the replay is observed
 Returns:
 a Flowable that emits items that are the results of invoking the selector on items emitted by aConnectableFlowable that shares a single subscription to the source Publisher, replaying no more thanbufferSize notifications
 See Also:
 ReactiveX operators documentation: Replay
 - replay
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="io.reactivex:computation")public final <R> Flowable<R> replay(Function<? superFlowable<T>,? extendsPublisher<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 aConnectableFlowable that shares a single subscription to the source Publisher, replaying all items that were emitted within a specified time window.
 Backpressure:
 This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Publisher sequence.
 Scheduler:
 This version ofreplay operates by default on thecomputationScheduler.
 Type Parameters:
 R - the type of items emitted by the resulting Publisher
 Parameters:
 selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the Publisher
 time - the duration of the window in which the replayed items must have been emitted
 unit - the time unit oftime
 Returns:
 a Flowable that emits items that are the results of invoking the selector on items emitted by aConnectableFlowable that shares a single subscription to the source Publisher, replaying all items that were emitted within the window defined bytime
 See Also:
 ReactiveX operators documentation: Replay
 - replay
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="custom")public final <R> Flowable<R> replay(Function<? superFlowable<T>,? extendsPublisher<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 aConnectableFlowable that shares a single subscription to the source Publisher, replaying all items that were emitted within a specified time window.
 Backpressure:
 This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Publisher sequence.
 Scheduler:
 You specify whichScheduler this operator will use.
 Type Parameters:
 R - the type of items emitted by the resulting Publisher
 Parameters:
 selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the Publisher
 time - the duration of the window in which the replayed items must have been emitted
 unit - the time unit oftime
 scheduler - the scheduler that is the time source for the window
 Returns:
 a Flowable that emits items that are the results of invoking the selector on items emitted by aConnectableFlowable that shares a single subscription to the source Publisher, replaying all items that were emitted within the window defined bytime
 See Also:
 ReactiveX operators documentation: Replay
 - replay
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="custom")public final <R> Flowable<R> replay(Function<? superFlowable<T>,? extendsPublisher<R>> selector,Scheduler scheduler)
```
 Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable that shares a single subscription to the source Publisher.
 Backpressure:
 This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Publisher sequence.
 Scheduler:
 You specify whichScheduler this operator will use.
 Type Parameters:
 R - the type of items emitted by the resulting Publisher
 Parameters:
 selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the Publisher
 scheduler - the Scheduler where the replay is observed
 Returns:
 a Flowable that emits items that are the results of invoking the selector on items emitted by aConnectableFlowable that shares a single subscription to the source Publisher, replaying all items
 See Also:
 ReactiveX operators documentation: Replay
 - replay
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final ConnectableFlowable<T> replay(int bufferSize)
```
 Returns aConnectableFlowable that shares a single subscription to the source Publisher that replays at mostbufferSize items emitted by that Publisher. A Connectable Publisher resembles an ordinary Publisher, except that it does not begin emitting items when it is subscribed to, but only when itsconnect method is called.
 Note that due to concurrency requirements,replay(bufferSize) may hold strong references to more thanbufferSize source emissions.
 Backpressure:
 This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Publisher sequence.
 Scheduler:
 This version ofreplay does not operate by default on a particularScheduler.
 Parameters:
 bufferSize - the buffer size that limits the number of items that can be replayed
 Returns:
 aConnectableFlowable that shares a single subscription to the source Publisher and replays at mostbufferSize items emitted by that Publisher
 See Also:
 ReactiveX operators documentation: Replay
 - replay
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="io.reactivex:computation")public final ConnectableFlowable<T> replay(int bufferSize, long time,TimeUnit unit)
```
 Returns aConnectableFlowable that shares a single subscription to the source Publisher and replays at mostbufferSize items that were emitted during a specified time window. A Connectable Publisher resembles an ordinary Publisher, except that it does not begin emitting items when it is subscribed to, but only when itsconnect method is called.
 Note that due to concurrency requirements,replay(bufferSize) may hold strong references to more thanbufferSize source emissions.
 Backpressure:
 This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Publisher sequence.
 Scheduler:
 This version ofreplay operates by default on thecomputationScheduler.
 Parameters:
 bufferSize - the buffer size that limits the number of items that can be replayed
 time - the duration of the window in which the replayed items must have been emitted
 unit - the time unit oftime
 Returns:
 aConnectableFlowable that shares a single subscription to the source Publisher and replays at mostbufferSize items that were emitted during the window defined bytime
 See Also:
 ReactiveX operators documentation: Replay
 - replay
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="custom")public final ConnectableFlowable<T> replay(int bufferSize, long time,TimeUnit unit,Scheduler scheduler)
```
 Returns aConnectableFlowable that shares a single subscription to the source Publisher and that replays a maximum ofbufferSize items that are emitted within a specified time window. A Connectable Publisher resembles an ordinary Publisher, except that it does not begin emitting items when it is subscribed to, but only when itsconnect method is called.
 Note that due to concurrency requirements,replay(bufferSize) may hold strong references to more thanbufferSize source emissions.
 Backpressure:
 This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Publisher sequence.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 bufferSize - the buffer size that limits the number of items that can be replayed
 time - the duration of the window in which the replayed items must have been emitted
 unit - the time unit oftime
 scheduler - the scheduler that is used as a time source for the window
 Returns:
 aConnectableFlowable that shares a single subscription to the source Publisher and replays at mostbufferSize items that were emitted during the window defined bytime
 Throws:
 IllegalArgumentException - ifbufferSize is less than zero
 See Also:
 ReactiveX operators documentation: Replay
 - replay
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="custom")public final ConnectableFlowable<T> replay(int bufferSize,Scheduler scheduler)
```
 Returns aConnectableFlowable that shares a single subscription to the source Publisher and replays at mostbufferSize items emitted by that Publisher. A Connectable Publisher resembles an ordinary Publisher, except that it does not begin emitting items when it is subscribed to, but only when itsconnect method is called.
 Note that due to concurrency requirements,replay(bufferSize) may hold strong references to more thanbufferSize source emissions.
 Backpressure:
 This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Publisher sequence.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 bufferSize - the buffer size that limits the number of items that can be replayed
 scheduler - the scheduler on which the Subscribers will observe the emitted items
 Returns:
 aConnectableFlowable that shares a single subscription to the source Publisher and replays at mostbufferSize items that were emitted by the Publisher
 See Also:
 ReactiveX operators documentation: Replay
 - replay
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="io.reactivex:computation")public final ConnectableFlowable<T> replay(long time,TimeUnit unit)
```
 Returns aConnectableFlowable that shares a single subscription to the source Publisher and replays all items emitted by that Publisher within a specified time window. A Connectable Publisher resembles an ordinary Publisher, except that it does not begin emitting items when it is subscribed to, but only when itsconnect method is called.
 Backpressure:
 This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Publisher sequence.
 Scheduler:
 This version ofreplay operates by default on thecomputationScheduler.
 Parameters:
 time - the duration of the window in which the replayed items must have been emitted
 unit - the time unit oftime
 Returns:
 aConnectableFlowable that shares a single subscription to the source Publisher and replays the items that were emitted during the window defined bytime
 See Also:
 ReactiveX operators documentation: Replay
 - replay
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="custom")public final ConnectableFlowable<T> replay(long time,TimeUnit unit,Scheduler scheduler)
```
 Returns aConnectableFlowable that shares a single subscription to the source Publisher and replays all items emitted by that Publisher within a specified time window. A Connectable Publisher resembles an ordinary Publisher, except that it does not begin emitting items when it is subscribed to, but only when itsconnect method is called.
 Backpressure:
 This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Publisher sequence.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 time - the duration of the window in which the replayed items must have been emitted
 unit - the time unit oftime
 scheduler - the Scheduler that is the time source for the window
 Returns:
 aConnectableFlowable that shares a single subscription to the source Publisher and replays the items that were emitted during the window defined bytime
 See Also:
 ReactiveX operators documentation: Replay
 - replay
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="custom")public final ConnectableFlowable<T> replay(Scheduler scheduler)
```
 Returns aConnectableFlowable that shares a single subscription to the source Publisher that will replay all of its items and notifications to any futureSubscriber on the givenScheduler. A Connectable Publisher resembles an ordinary Publisher, except that it does not begin emitting items when it is subscribed to, but only when itsconnect method is called.
 Backpressure:
 This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Publisher sequence.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 scheduler - the Scheduler on which the Subscribers will observe the emitted items
 Returns:
 aConnectableFlowable that shares a single subscription to the source Publisher that will replay all of its items and notifications to any futureSubscriber on the givenScheduler
 See Also:
 ReactiveX operators documentation: Replay
 - retry
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> retry()
```
 Returns a Flowable that mirrors the source Publisher, resubscribing to it if it callsonError (infinite retry count).
 If the source Publisher callsSubscriber.onError(java.lang.Throwable), this method will resubscribe to the source Publisher rather than propagating theonError call.
 Any and all items emitted by the source Publisher will be emitted by the resulting Publisher, even those emitted during failed subscriptions. For example, if a Publisher fails at first but emits[1, 2] then succeeds the second time and emits[1, 2, 3, 4, 5] then the complete sequence of emissions and notifications would be[1, 2, 1, 2, 3, 4, 5, onComplete].
 Backpressure:
 The operator honors downstream backpressure and expects the sourcePublisher to honor backpressure as well. If this expectation is violated, the operatormay throw anIllegalStateException.
 Scheduler:
 retry does not operate by default on a particularScheduler.
 Returns:
 the source Publisher modified with retry logic
 See Also:
 ReactiveX operators documentation: Retry
 - retry
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> retry(BiPredicate<? superInteger,? superThrowable> predicate)
```
 Returns a Flowable that mirrors the source Publisher, resubscribing to it if it callsonError and the predicate returns true for that specific exception and retry count.
 Backpressure:
 The operator honors downstream backpressure and expects the sourcePublisher to honor backpressure as well. If this expectation is violated, the operatormay throw anIllegalStateException.
 Scheduler:
 retry does not operate by default on a particularScheduler.
 Parameters:
 predicate - the predicate that determines if a resubscription may happen in case of a specific exception and retry count
 Returns:
 the source Publisher modified with retry logic
 See Also:
 retry(),ReactiveX operators documentation: Retry
 - retry
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> retry(long count)
```
 Returns a Flowable that mirrors the source Publisher, resubscribing to it if it callsonError up to a specified number of retries.
 If the source Publisher callsSubscriber.onError(java.lang.Throwable), this method will resubscribe to the source Publisher for a maximum ofcount resubscriptions rather than propagating theonError call.
 Any and all items emitted by the source Publisher will be emitted by the resulting Publisher, even those emitted during failed subscriptions. For example, if a Publisher fails at first but emits[1, 2] then succeeds the second time and emits[1, 2, 3, 4, 5] then the complete sequence of emissions and notifications would be[1, 2, 1, 2, 3, 4, 5, onComplete].
 Backpressure:
 The operator honors downstream backpressure and expects the sourcePublisher to honor backpressure as well. If this expectation is violated, the operatormay throw anIllegalStateException.
 Scheduler:
 retry does not operate by default on a particularScheduler.
 Parameters:
 count - the number of times to resubscribe if the current Flowable fails
 Returns:
 the source Publisher modified with retry logic
 See Also:
 ReactiveX operators documentation: Retry
 - retry
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> retry(long times,Predicate<? superThrowable> predicate)
```
 Retries at most times or until the predicate returns false, whichever happens first.
 Backpressure:
 The operator honors downstream backpressure and expects the sourcePublisher to honor backpressure as well. If this expectation is violated, the operatormay throw anIllegalStateException.
 Scheduler:
 retry does not operate by default on a particularScheduler.
 Parameters:
 times - the number of times to resubscribe if the current Flowable fails
 predicate - the predicate called with the failure Throwable and should return true to trigger a retry.
 Returns:
 the new Flowable instance
 - retry
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> retry(Predicate<? superThrowable> predicate)
```
 Retries the current Flowable if the predicate returns true.
 Backpressure:
 The operator honors downstream backpressure and expects the sourcePublisher to honor backpressure as well. If this expectation is violated, the operatormay throw anIllegalStateException.
 Scheduler:
 retry does not operate by default on a particularScheduler.
 Parameters:
 predicate - the predicate that receives the failure Throwable and should return true to trigger a retry.
 Returns:
 the new Flowable instance
 - retryUntil
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> retryUntil(BooleanSupplier stop)
```
 Retries until the given stop function returns true.
 Backpressure:
 The operator honors downstream backpressure and expects the sourcePublisher to honor backpressure as well. If this expectation is violated, the operatormay throw anIllegalStateException.
 Scheduler:
 retryUntil does not operate by default on a particularScheduler.
 Parameters:
 stop - the function that should return true to stop retrying
 Returns:
 the new Flowable instance
 - retryWhen
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> retryWhen(Function<? superFlowable<Throwable>,? extendsPublisher<?>> handler)
```
 Returns a Flowable that emits the same values as the source Publisher with the exception of anonError. AnonError notification from the source will result in the emission of aThrowable item to the Publisher provided as an argument to thenotificationHandler function. If that Publisher callsonComplete oronError thenretry will callonComplete oronError on the child subscription. Otherwise, this Publisher will resubscribe to the source Publisher.
 Example: This retries 3 times, each time incrementing the number of seconds it waits.
```
 Flowable.create((FlowableEmitter<? super String> s) -> { System.out.println("subscribing"); s.onError(new RuntimeException("always fails")); }, BackpressureStrategy.BUFFER).retryWhen(attempts -> { return attempts.zipWith(Flowable.range(1, 3), (n, i) -> i).flatMap(i -> { System.out.println("delay retry by " + i + " second(s)"); return Flowable.timer(i, TimeUnit.SECONDS); }); }).blockingForEach(System.out::println);
```
 Output is:
```
 subscribing delay retry by 1 second(s) subscribing delay retry by 2 second(s) subscribing delay retry by 3 second(s) subscribing
```
 Note that the innerPublisher returned by the handler function should signal eitheronNext,onError oronComplete in response to the receivedThrowable to indicate the operator should retry or terminate. If the upstream to the operator is asynchronous, signaling onNext followed by onComplete immediately may result in the sequence to be completed immediately. Similarly, if this innerPublisher signalsonError oronComplete while the upstream is active, the sequence is terminated with the same signal immediately.
 The following example demonstrates how to retry an asynchronous source with a delay:
```
 Flowable.timer(1, TimeUnit.SECONDS) .doOnSubscribe(s -> System.out.println("subscribing")) .map(v -> { throw new RuntimeException(); }) .retryWhen(errors -> { AtomicInteger counter = new AtomicInteger(); return errors .takeWhile(e -> counter.getAndIncrement() != 3) .flatMap(e -> { System.out.println("delay retry by " + counter.get() + " second(s)"); return Flowable.timer(counter.get(), TimeUnit.SECONDS); }); }) .blockingSubscribe(System.out::println, System.out::println);
```
 Backpressure:
 The operator honors downstream backpressure and expects both the source and innerPublishers to honor backpressure as well. If this expectation is violated, the operatormay throw anIllegalStateException.
 Scheduler:
 retryWhen does not operate by default on a particularScheduler.
 Parameters:
 handler - receives a Publisher of notifications with which a user can complete or error, aborting the retry
 Returns:
 the source Publisher modified with retry logic
 See Also:
 ReactiveX operators documentation: Retry
 - safeSubscribe
```
@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final void safeSubscribe(Subscriber<? superT> 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).
 Backpressure:
 This operator leaves the reactive world and the backpressure behavior depends on the Subscriber's behavior.
 Scheduler:
 safeSubscribe does not operate by default on a particularScheduler.
 Parameters:
 s - the incoming Subscriber instance
 Throws:
 NullPointerException - if s is null
 - sample
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="io.reactivex:computation")public final 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.
 Backpressure:
 This operator does not support backpressure as it uses time to control data flow.
 Scheduler:
 sample operates by default on thecomputationScheduler.
 Parameters:
 period - the sampling rate
 unit - theTimeUnit in whichperiod is defined
 Returns:
 a Flowable that emits the results of sampling the items emitted by the source Publisher at the specified time interval
 See Also:
 ReactiveX operators documentation: Sample,RxJava wiki: Backpressure,throttleLast(long, TimeUnit)
 - sample
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="io.reactivex:computation")public final 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.
 Backpressure:
 This operator does not support backpressure as it uses time to control data flow.
 Scheduler:
 sample operates by default on thecomputationScheduler.
 History: 2.0.5 - experimental
 Parameters:
 period - the sampling rate
 unit - theTimeUnit in whichperiod is defined
 emitLast - if true and the upstream completes while there is still an unsampled item available, that item is emitted to downstream before completion if false, an unsampled last item is ignored.
 Returns:
 a Flowable that emits the results of sampling the items emitted by the source Publisher at the specified time interval
 Since:
 2.1
 See Also:
 ReactiveX operators documentation: Sample,RxJava wiki: Backpressure,throttleLast(long, TimeUnit)
 - sample
```
@CheckReturnValue@NonNull@BackpressureSupport(value=ERROR)@SchedulerSupport(value="custom")public final 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.
 Backpressure:
 This operator does not support backpressure as it uses time to control data flow.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 period - the sampling rate
 unit - theTimeUnit in whichperiod is defined
 scheduler - theScheduler to use when sampling
 Returns:
 a Flowable that emits the results of sampling the items emitted by the source Publisher at the specified time interval
 See Also:
 ReactiveX operators documentation: Sample,RxJava wiki: Backpressure,throttleLast(long, TimeUnit, Scheduler)
 - sample
```
@CheckReturnValue@NonNull@BackpressureSupport(value=ERROR)@SchedulerSupport(value="custom")public final 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.
 Backpressure:
 This operator does not support backpressure as it uses time to control data flow.
 Scheduler:
 You specify whichScheduler this operator will use.
 History: 2.0.5 - experimental
 Parameters:
 period - the sampling rate
 unit - theTimeUnit in whichperiod is defined
 scheduler - theScheduler to use when sampling
 emitLast - if true and the upstream completes while there is still an unsampled item available, that item is emitted to downstream before completion if false, an unsampled last item is ignored.
 Returns:
 a Flowable that emits the results of sampling the items emitted by the source Publisher at the specified time interval
 Since:
 2.1
 See Also:
 ReactiveX operators documentation: Sample,RxJava wiki: Backpressure,throttleLast(long, TimeUnit, Scheduler)
 - sample
```
@CheckReturnValue@NonNull@BackpressureSupport(value=ERROR)@SchedulerSupport(value="none")public final  Flowable<T> sample(Publisher sampler)
```
 Returns a Flowable that, when the specifiedsampler Publisher emits an item or completes, emits the most recently emitted item (if any) emitted by the source Publisher since the previous emission from thesampler Publisher.
 Backpressure:
 This operator does not support backpressure as it uses the emissions of thesampler Publisher to control data flow.
 Scheduler:
 This version ofsample does not operate by default on a particularScheduler.
 Type Parameters:
 U - the element type of the sampler Publisher
 Parameters:
 sampler - the Publisher to use for sampling the source Publisher
 Returns:
 a Flowable that emits the results of sampling the items emitted by this Publisher whenever thesampler Publisher emits an item or completes
 See Also:
 ReactiveX operators documentation: Sample,RxJava wiki: Backpressure
 - sample
```
@CheckReturnValue@NonNull@BackpressureSupport(value=ERROR)@SchedulerSupport(value="none")public final  Flowable<T> sample(Publisher sampler, boolean emitLast)
```
 Returns a Flowable that, when the specifiedsampler Publisher emits an item or completes, emits the most recently emitted item (if any) emitted by the source Publisher since the previous emission from thesampler Publisher and optionally emit the very last upstream item when the upstream or other Publisher complete.
 Backpressure:
 This operator does not support backpressure as it uses the emissions of thesampler Publisher to control data flow.
 Scheduler:
 This version ofsample does not operate by default on a particularScheduler.
 History: 2.0.5 - experimental
 Type Parameters:
 U - the element type of the sampler Publisher
 Parameters:
 sampler - the Publisher to use for sampling the source Publisher
 emitLast - if true and the upstream completes while there is still an unsampled item available, that item is emitted to downstream before completion if false, an unsampled last item is ignored.
 Returns:
 a Flowable that emits the results of sampling the items emitted by this Publisher whenever thesampler Publisher emits an item or completes
 Since:
 2.1
 See Also:
 ReactiveX operators documentation: Sample,RxJava wiki: Backpressure
 - scan
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final 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.
 This sort of function is sometimes called an accumulator.
 Backpressure:
 The operator honors downstream backpressure and expects the sourcePublisher to honor backpressure as well. Violating this expectation, aMissingBackpressureExceptionmay get signaled somewhere downstream.
 Scheduler:
 scan does not operate by default on a particularScheduler.
 Parameters:
 accumulator - an accumulator function to be invoked on each item emitted by the source Publisher, whose result will be emitted toSubscribers viaonNext and used in the next accumulator call
 Returns:
 a Flowable that emits the results of each call to the accumulator function
 See Also:
 ReactiveX operators documentation: Scan
 - scan
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> scan(R initialValue,BiFunction<R,? superT,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.
 This sort of function is sometimes called an accumulator.
 Note that the Publisher that results from this method will emitinitialValue as its first emitted item.
 Note that theinitialValue is shared among all subscribers to the resulting Publisher and may cause problems if it is mutable. To make sure each subscriber gets its own value, defer the application of this operator viadefer(Callable):
```
 Publisher<T> source = ... Flowable.defer(() -> source.scan(new ArrayList<>(), (list, item) -> list.add(item))); // alternatively, by using compose to stay fluent source.compose(o -> Flowable.defer(() -> o.scan(new ArrayList<>(), (list, item) -> list.add(item))) );
```
 Backpressure:
 The operator honors downstream backpressure and expects the sourcePublisher to honor backpressure as well. Violating this expectation, aMissingBackpressureExceptionmay get signaled somewhere downstream.
 Scheduler:
 scan does not operate by default on a particularScheduler.
 Type Parameters:
 R - the initial, accumulator and result type
 Parameters:
 initialValue - the initial (seed) accumulator item
 accumulator - an accumulator function to be invoked on each item emitted by the source Publisher, whose result will be emitted toSubscribers viaonNext and used in the next accumulator call
 Returns:
 a Flowable that emitsinitialValue followed by the results of each call to the accumulator function
 See Also:
 ReactiveX operators documentation: Scan
 - scanWith
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> scanWith(Callable<R> seedSupplier,BiFunction<R,? superT,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.
 This sort of function is sometimes called an accumulator.
 Note that the Publisher that results from this method will emit the value returned by theseedSupplier as its first item.
 Backpressure:
 The operator honors downstream backpressure and expects the sourcePublisher to honor backpressure as well. Violating this expectation, aMissingBackpressureExceptionmay get signaled somewhere downstream.
 Scheduler:
 scanWith does not operate by default on a particularScheduler.
 Type Parameters:
 R - the initial, accumulator and result type
 Parameters:
 seedSupplier - a Callable that returns the initial (seed) accumulator item for each individual Subscriber
 accumulator - an accumulator function to be invoked on each item emitted by the source Publisher, whose result will be emitted toSubscribers viaonNext and used in the next accumulator call
 Returns:
 a Flowable that emitsinitialValue followed by the results of each call to the accumulator function
 See Also:
 ReactiveX operators documentation: Scan
 - serialize
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<T> serialize()
```
 Forces a Publisher's emissions and notifications to be serialized and for it to obeythe Publisher contract in other ways.
 It is possible for a Publisher to invoke its Subscribers' methods asynchronously, perhaps from different threads. This could make such a Publisher poorly-behaved, in that it might try to invokeonComplete oronError before one of itsonNext invocations, or it might callonNext from two different threads concurrently. You can force such a Publisher to be well-behaved and sequential by applying theserialize method to it.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 serialize does not operate by default on a particularScheduler.
 Returns:
 aPublisher that is guaranteed to be well-behaved and to make only serialized calls to its Subscribers
 See Also:
 ReactiveX operators documentation: Serialize
 - share
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> share()
```
 Returns a newPublisher that multicasts (and shares a single subscription to) the originalPublisher. As long as there is at least oneSubscriber thisPublisher will be subscribed and emitting data. When all subscribers have canceled it will cancel the sourcePublisher.
 This is an alias forpublish().refCount().
 Backpressure:
 The operator honors backpressure and expects the sourcePublisher to honor backpressure as well. If this expectation is violated, the operator will signal aMissingBackpressureException to itsSubscribers.
 Scheduler:
 share does not operate by default on a particularScheduler.
 Returns:
 aPublisher that upon connection causes the sourcePublisher to emit items to itsSubscribers
 See Also:
 ReactiveX operators documentation: RefCount
 - singleElement
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final 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 anIllegalArgumentException if this Flowable signals more than one item.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure).
 Scheduler:
 singleElement does not operate by default on a particularScheduler.
 Returns:
 a Maybe that emits the single item emitted by the source Publisher
 See Also:
 ReactiveX operators documentation: First
 - single
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final 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. If the source Publisher emits more than one item, anIllegalArgumentException is signaled instead.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure).
 Scheduler:
 single does not operate by default on a particularScheduler.
 Parameters:
 defaultItem - a default value to emit if the source Publisher emits no item
 Returns:
 a Single that emits the single item emitted by the source Publisher, or a default item if the source Publisher is empty
 See Also:
 ReactiveX operators documentation: First
 - singleOrError
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final 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 aNoSuchElementException will be signaled and if this Flowable emits more than one item, anIllegalArgumentException will be signaled.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure).
 Scheduler:
 singleOrError does not operate by default on a particularScheduler.
 Returns:
 the new Single instance
 See Also:
 ReactiveX operators documentation: First
 - skip
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> skip(long count)
```
 Returns a Flowable that skips the firstcount items emitted by the source Publisher and emits the remainder.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 This version ofskip does not operate by default on a particularScheduler.
 Parameters:
 count - the number of items to skip
 Returns:
 a Flowable that is identical to the source Publisher except that it does not emit the firstcount items that the source Publisher emits
 See Also:
 ReactiveX operators documentation: Skip
 - skip
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> skip(long time,TimeUnit unit)
```
 Returns a Flowable that skips values emitted by the source Publisher before a specified time window elapses.
 Backpressure:
 The operator doesn't support backpressure as it uses time to skip an arbitrary number of elements and thus has to consume the sourcePublisher in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 skip does not operate on any particular scheduler but uses the current time from thecomputationScheduler.
 Parameters:
 time - the length of the time window to skip
 unit - the time unit oftime
 Returns:
 a Flowable that skips values emitted by the source Publisher before the time window defined bytime elapses and the emits the remainder
 See Also:
 ReactiveX operators documentation: Skip
 - skip
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="custom")public final 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 specifiedScheduler elapses.
 Backpressure:
 The operator doesn't support backpressure as it uses time to skip an arbitrary number of elements and thus has to consume the sourcePublisher in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 You specify whichScheduler this operator will use for the timed skipping
 Parameters:
 time - the length of the time window to skip
 unit - the time unit oftime
 scheduler - theScheduler on which the timed wait happens
 Returns:
 a Flowable that skips values emitted by the source Publisher before the time window defined bytime andscheduler elapses, and then emits the remainder
 See Also:
 ReactiveX operators documentation: Skip
 - skipLast
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final 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.
 This Subscriber accumulates a queue long enough to store the firstcount items. As more items are received, items are taken from the front of the queue and emitted by the returned Publisher. This causes such items to be delayed.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 This version ofskipLast does not operate by default on a particularScheduler.
 Parameters:
 count - number of items to drop from the end of the source sequence
 Returns:
 a Flowable that emits the items emitted by the source Publisher except for the dropped ones at the end
 Throws:
 IndexOutOfBoundsException - ifcount is less than zero
 See Also:
 ReactiveX operators documentation: SkipLast
 - skipLast
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final 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.
 Note: this action will cache the latest items arriving in the specified time window.
 Backpressure:
 The operator doesn't support backpressure as it uses time to skip an arbitrary number of elements and thus has to consume the sourcePublisher in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 skipLast does not operate on any particular scheduler but uses the current time from thecomputationScheduler.
 Parameters:
 time - the length of the time window
 unit - the time unit oftime
 Returns:
 a Flowable that drops those items emitted by the source Publisher in a time window before the source completes defined bytime
 See Also:
 ReactiveX operators documentation: SkipLast
 - skipLast
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final 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.
 Note: this action will cache the latest items arriving in the specified time window.
 Backpressure:
 The operator doesn't support backpressure as it uses time to skip an arbitrary number of elements and thus has to consume the sourcePublisher in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 skipLast does not operate on any particular scheduler but uses the current time from thecomputationScheduler.
 Parameters:
 time - the length of the time window
 unit - the time unit oftime
 delayError - if true, an exception signaled by the current Flowable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signaled and all regular elements dropped
 Returns:
 a Flowable that drops those items emitted by the source Publisher in a time window before the source completes defined bytime
 See Also:
 ReactiveX operators documentation: SkipLast
 - skipLast
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="custom")public final 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.
 Note: this action will cache the latest items arriving in the specified time window.
 Backpressure:
 The operator doesn't support backpressure as it uses time to skip an arbitrary number of elements and thus has to consume the sourcePublisher in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 You specify whichScheduler this operator will use for tracking the current time
 Parameters:
 time - the length of the time window
 unit - the time unit oftime
 scheduler - the scheduler used as the time source
 Returns:
 a Flowable that drops those items emitted by the source Publisher in a time window before the source completes defined bytime andscheduler
 See Also:
 ReactiveX operators documentation: SkipLast
 - skipLast
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="custom")public final 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.
 Note: this action will cache the latest items arriving in the specified time window.
 Backpressure:
 The operator doesn't support backpressure as it uses time to skip an arbitrary number of elements and thus has to consume the sourcePublisher in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 You specify whichScheduler this operator will use to track the current time
 Parameters:
 time - the length of the time window
 unit - the time unit oftime
 scheduler - the scheduler used as the time source
 delayError - if true, an exception signaled by the current Flowable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signaled and all regular elements dropped
 Returns:
 a Flowable that drops those items emitted by the source Publisher in a time window before the source completes defined bytime andscheduler
 See Also:
 ReactiveX operators documentation: SkipLast
 - skipLast
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="custom")public final 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.
 Note: this action will cache the latest items arriving in the specified time window.
 Backpressure:
 The operator doesn't support backpressure as it uses time to skip an arbitrary number of elements and thus has to consume the sourcePublisher in an unbounded manner (i.e., no backpressure applied to it).
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 time - the length of the time window
 unit - the time unit oftime
 scheduler - the scheduler used as the time source
 delayError - if true, an exception signaled by the current Flowable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signaled and all regular elements dropped
 bufferSize - the hint about how many elements to expect to be skipped
 Returns:
 a Flowable that drops those items emitted by the source Publisher in a time window before the source completes defined bytime andscheduler
 See Also:
 ReactiveX operators documentation: SkipLast
 - skipUntil
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final  Flowable<T> skipUntil(Publisher other)
```
 Returns a Flowable that skips items emitted by the source Publisher until a second Publisher emits an item.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 skipUntil does not operate by default on a particularScheduler.
 Type Parameters:
 U - the element type of the other Publisher
 Parameters:
 other - the second Publisher that has to emit an item before the source Publisher's elements begin to be mirrored by the resulting Publisher
 Returns:
 a Flowable that skips items from the source Publisher until the second Publisher emits an item, then emits the remaining items
 See Also:
 ReactiveX operators documentation: SkipUntil
 - skipWhile
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> skipWhile(Predicate<? superT> 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.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 skipWhile does not operate by default on a particularScheduler.
 Parameters:
 predicate - a function to test each item emitted from the source Publisher
 Returns:
 a Flowable that begins emitting items emitted by the source Publisher when the specified predicate becomes false
 See Also:
 ReactiveX operators documentation: SkipWhile
 - sorted
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> sorted()
```
 Returns a Flowable that emits the events emitted by source Publisher, in a sorted order. Each item emitted by the Publisher must implementComparable with respect to all other items in the sequence.
 If any item emitted by this Flowable does not implementComparable with respect to all other items emitted by this Flowable, no items will be emitted and the sequence is terminated with aClassCastException.
 Note that callingsorted with long, non-terminating or infinite sources might causeOutOfMemoryError
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure to it).
 Scheduler:
 sorted does not operate by default on a particularScheduler.
 Returns:
 a Flowable that emits the items emitted by the source Publisher in sorted order
 - sorted
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> sorted(Comparator<? superT> sortFunction)
```
 Returns a Flowable that emits the events emitted by source Publisher, in a sorted order based on a specified comparison function.
 Note that callingsorted with long, non-terminating or infinite sources might causeOutOfMemoryError
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure to it).
 Scheduler:
 sorted does not operate by default on a particularScheduler.
 Parameters:
 sortFunction - a function that compares two items emitted by the source Publisher and returns an Integer that indicates their sort order
 Returns:
 a Flowable that emits the items emitted by the source Publisher in sorted order
 - startWith
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> startWith(Iterable<? extendsT> items)
```
 Returns a Flowable that emits the items in a specifiedIterable before it begins to emit items emitted by the source Publisher.
 Backpressure:
 The operator honors backpressure from downstream. The sourcePublisher is expected to honor backpressure as well. If it violates this rule, itmay throw anIllegalStateException when the sourcePublisher completes.
 Scheduler:
 startWith does not operate by default on a particularScheduler.
 Parameters:
 items - an Iterable that contains the items you want the modified Publisher to emit first
 Returns:
 a Flowable that emits the items in the specifiedIterable and then emits the items emitted by the source Publisher
 See Also:
 ReactiveX operators documentation: StartWith
 - startWith
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> startWith(Publisher<? extendsT> other)
```
 Returns a Flowable that emits the items in a specifiedPublisher before it begins to emit items emitted by the source Publisher.
 Backpressure:
 The operator honors backpressure from downstream. Both this and theotherPublishers are expected to honor backpressure as well. If any of then violates this rule, itmay throw anIllegalStateException when the sourcePublisher completes.
 Scheduler:
 startWith does not operate by default on a particularScheduler.
 Parameters:
 other - a Publisher that contains the items you want the modified Publisher to emit first
 Returns:
 a Flowable that emits the items in the specifiedPublisher and then emits the items emitted by the source Publisher
 See Also:
 ReactiveX operators documentation: StartWith
 - startWith
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> startWith(T value)
```
 Returns a Flowable that emits a specified item before it begins to emit items emitted by the source Publisher.
 Backpressure:
 The operator honors backpressure from downstream. The sourcePublisher is expected to honor backpressure as well. If it violates this rule, itmay throw anIllegalStateException when the sourcePublisher completes.
 Scheduler:
 startWith does not operate by default on a particularScheduler.
 Parameters:
 value - the item to emit first
 Returns:
 a Flowable that emits the specified item before it begins to emit items emitted by the source Publisher
 See Also:
 ReactiveX operators documentation: StartWith
 - startWithArray
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> startWithArray(T... items)
```
 Returns a Flowable that emits the specified items before it begins to emit items emitted by the source Publisher.
 Backpressure:
 The operator honors backpressure from downstream. The sourcePublisher is expected to honor backpressure as well. If it violates this rule, itmay throw anIllegalStateException when the sourcePublisher completes.
 Scheduler:
 startWithArray does not operate by default on a particularScheduler.
 Parameters:
 items - the array of values to emit first
 Returns:
 a Flowable that emits the specified items before it begins to emit items emitted by the source Publisher
 See Also:
 ReactiveX operators documentation: StartWith
 - subscribe
```
@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final Disposable subscribe()
```
 Subscribes to a Publisher and ignoresonNext andonComplete emissions.
 If the Flowable emits an error, it is wrapped into anOnErrorNotImplementedException and routed to the RxJavaPlugins.onError handler.
 Backpressure:
 The operator consumes the sourcePublisher in an unbounded manner (i.e., no backpressure is applied to it).
 Scheduler:
 subscribe does not operate by default on a particularScheduler.
 Returns:
 aDisposable reference with which the caller can stop receiving items before the Publisher has finished sending them
 See Also:
 ReactiveX operators documentation: Subscribe
 - subscribe
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final Disposable subscribe(Consumer<? superT> onNext)
```
 Subscribes to a Publisher and provides a callback to handle the items it emits.
 If the Flowable emits an error, it is wrapped into anOnErrorNotImplementedException and routed to the RxJavaPlugins.onError handler.
 Backpressure:
 The operator consumes the sourcePublisher in an unbounded manner (i.e., no backpressure is applied to it).
 Scheduler:
 subscribe does not operate by default on a particularScheduler.
 Parameters:
 onNext - theConsumer<T> you have designed to accept emissions from the Publisher
 Returns:
 aDisposable reference with which the caller can stop receiving items before the Publisher has finished sending them
 Throws:
 NullPointerException - ifonNext is null
 See Also:
 ReactiveX operators documentation: Subscribe
 - subscribe
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final Disposable subscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError)
```
 Subscribes to a Publisher and provides callbacks to handle the items it emits and any error notification it issues.
 Backpressure:
 The operator consumes the sourcePublisher in an unbounded manner (i.e., no backpressure is applied to it).
 Scheduler:
 subscribe does not operate by default on a particularScheduler.
 Parameters:
 onNext - theConsumer<T> you have designed to accept emissions from the Publisher
 onError - theConsumer<Throwable> you have designed to accept any error notification from the Publisher
 Returns:
 aDisposable reference with which the caller can stop receiving items before the Publisher has finished sending them
 Throws:
 NullPointerException - ifonNext is null, or ifonError is null
 See Also:
 ReactiveX operators documentation: Subscribe
 - subscribe
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final Disposable subscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError,Action onComplete)
```
 Subscribes to a Publisher and provides callbacks to handle the items it emits and any error or completion notification it issues.
 Backpressure:
 The operator consumes the sourcePublisher in an unbounded manner (i.e., no backpressure is applied to it).
 Scheduler:
 subscribe does not operate by default on a particularScheduler.
 Parameters:
 onNext - theConsumer<T> you have designed to accept emissions from the Publisher
 onError - theConsumer<Throwable> you have designed to accept any error notification from the Publisher
 onComplete - theAction you have designed to accept a completion notification from the Publisher
 Returns:
 aDisposable reference with which the caller can stop receiving items before the Publisher has finished sending them
 Throws:
 NullPointerException - ifonNext is null, or ifonError is null, or ifonComplete is null
 See Also:
 ReactiveX operators documentation: Subscribe
 - subscribe
```
@CheckReturnValue@NonNull@BackpressureSupport(value=SPECIAL)@SchedulerSupport(value="none")public final Disposable subscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError,Action onComplete,Consumer<? superSubscription> onSubscribe)
```
 Subscribes to a Publisher and provides callbacks to handle the items it emits and any error or completion notification it issues.
 Backpressure:
 The operator consumes the sourcePublisher in an unbounded manner (i.e., no backpressure is applied to it).
 Scheduler:
 subscribe does not operate by default on a particularScheduler.
 Parameters:
 onNext - theConsumer<T> you have designed to accept emissions from the Publisher
 onError - theConsumer<Throwable> you have designed to accept any error notification from the Publisher
 onComplete - theAction you have designed to accept a completion notification from the Publisher
 onSubscribe - theConsumer that receives the upstream's Subscription
 Returns:
 aDisposable reference with which the caller can stop receiving items before the Publisher has finished sending them
 Throws:
 NullPointerException - ifonNext is null, or ifonError is null, or ifonComplete is null, or ifonSubscribe is null
 See Also:
 ReactiveX operators documentation: Subscribe
 - subscribe
```
@BackpressureSupport(value=SPECIAL)@SchedulerSupport(value="none")public final void subscribe(Subscriber<? superT> s)
```
 Specified by:
 subscribe in interface Publisher<T>
 - subscribe
```
@BackpressureSupport(value=SPECIAL)@SchedulerSupport(value="none")public final void subscribe(FlowableSubscriber<? superT> s)
```
 Establish a connection between this Flowable and the given FlowableSubscriber and start streaming events based on the demand of the FlowableSubscriber.
 This is a "factory method" and can be called multiple times, each time starting a newSubscription.
 EachSubscription will work for only a singleFlowableSubscriber.
 If the sameFlowableSubscriber instance is subscribed to multipleFlowables and/or the sameFlowable multiple times, it must ensure the serialization over itsonXXX methods manually.
 If theFlowable rejects the subscription attempt or otherwise fails it will signal the error viaSubscriber.onError(Throwable).
 This subscribe method relaxes the following Reactive Streams rules:
 - §1.3: onNext should not be called concurrently until onSubscribe returns.FlowableSubscriber.onSubscribe should make sure a sync or async call triggered by request() is safe.
 - §2.3: onError or onComplete must not call cancel.Calling request() or cancel() is NOP at this point.
 - §2.12: onSubscribe must be called at most once on the same instance.FlowableSubscriber reuse is not checked and if happens, it is the responsibility of the FlowableSubscriber to ensure proper serialization of its onXXX methods.
 - §3.9: negative requests should emit an onError(IllegalArgumentException).Non-positive requests signal via RxJavaPlugins.onError and the stream is not affected.
 Backpressure:
 The backpressure behavior/expectation is determined by the suppliedFlowableSubscriber.
 Scheduler:
 subscribe does not operate by default on a particularScheduler.
 History: 2.0.7 - experimental; 2.1 - beta
 Parameters:
 s - the FlowableSubscriber that will consume signals from this Flowable
 Since:
 2.2
 - subscribeActual
```
protected abstract void subscribeActual(Subscriber<? superT> s)
```
 Operator implementations (both source and intermediate) should implement this method that performs the necessary business logic and handles the incomingSubscribers.
 There is no need to call any of the plugin hooks on the currentFlowable instance or theSubscriber; all hooks and basic safeguards have been applied bysubscribe(Subscriber) before this method gets called.
 Parameters:
 s - the incoming Subscriber, never null
 - subscribeWith
```
@CheckReturnValue@BackpressureSupport(value=SPECIAL)@SchedulerSupport(value="none")public final <E extendsSubscriber<? superT>> E subscribeWith(E subscriber)
```
 Subscribes a given Subscriber (subclass) to this Flowable and returns the given Subscriber as is.
 Usage example:
```
 Flowable<Integer> source = Flowable.range(1, 10); CompositeDisposable composite = new CompositeDisposable(); ResourceSubscriber<Integer> rs = new ResourceSubscriber<>() { // ... }; composite.add(source.subscribeWith(rs));
```
 Backpressure:
 The backpressure behavior/expectation is determined by the suppliedSubscriber.
 Scheduler:
 subscribeWith does not operate by default on a particularScheduler.
 Type Parameters:
 E - the type of the Subscriber to use and return
 Parameters:
 subscriber - the Subscriber (subclass) to use and return, not null
 Returns:
 the inputsubscriber
 Throws:
 NullPointerException - ifsubscriber is null
 Since:
 2.0
 - subscribeOn
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="custom")public final Flowable<T> subscribeOn(@NonNullScheduler scheduler)
```
 Asynchronously subscribes Subscribers to this Publisher on the specifiedScheduler.
 If there is acreate(FlowableOnSubscribe, BackpressureStrategy) type source up in the chain, it is recommended to usesubscribeOn(scheduler, false) instead to avoid same-pool deadlock because requests may pile up behind an eager/blocking emitter.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 scheduler - theScheduler to perform subscription actions on
 Returns:
 the source Publisher modified so that its subscriptions happen on the specifiedScheduler
 See Also:
 ReactiveX operators documentation: SubscribeOn,RxJava Threading Examples,observeOn(io.reactivex.Scheduler),subscribeOn(Scheduler, boolean)
 - subscribeOn
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="custom")public final Flowable<T> subscribeOn(@NonNullScheduler scheduler, boolean requestOn)
```
 Asynchronously subscribes Subscribers to this Publisher on the specifiedScheduler optionally reroutes requests from other threads to the sameScheduler thread.
 If there is acreate(FlowableOnSubscribe, BackpressureStrategy) type source up in the chain, it is recommended to haverequestOn false to avoid same-pool deadlock because requests may pile up behind an eager/blocking emitter.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 You specify whichScheduler this operator will use.
 History: 2.1.1 - experimental
 Parameters:
 scheduler - theScheduler to perform subscription actions on
 requestOn - if true, requests are rerouted to the given Scheduler as well (strong pipelining) if false, requests coming from any thread are simply forwarded to the upstream on the same thread (weak pipelining)
 Returns:
 the source Publisher modified so that its subscriptions happen on the specifiedScheduler
 Since:
 2.2
 See Also:
 ReactiveX operators documentation: SubscribeOn,RxJava Threading Examples,observeOn(io.reactivex.Scheduler)
 - switchIfEmpty
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> switchIfEmpty(Publisher<? extendsT> 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.
 Backpressure:
 If the sourcePublisher is empty, the alternatePublisher is expected to honor backpressure. If the sourcePublisher is non-empty, it is expected to honor backpressure as instead. In either case, if violated, aMissingBackpressureExceptionmay get signaled somewhere downstream.
 Scheduler:
 switchIfEmpty does not operate by default on a particularScheduler.
 Parameters:
 other - the alternate Publisher to subscribe to if the source does not emit any items
 Returns:
 a Publisher that emits the items emitted by the source Publisher or the items of an alternate Publisher if the source Publisher is empty.
 Since:
 1.1.0
 - switchMap
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> switchMap(Function<? superT,? extendsPublisher<? 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.
 The resulting Publisher completes if both the upstream Publisher and the last inner Publisher, if any, complete. If the upstream Publisher signals an onError, the inner Publisher is canceled and the error delivered in-sequence.
 Backpressure:
 The operator honors backpressure from downstream. The outerPublisher is consumed in an unbounded manner (i.e., without backpressure) and the innerPublishers are expected to honor backpressure but it is not enforced; the operator won't signal aMissingBackpressureException but the violationmay lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 switchMap does not operate by default on a particularScheduler.
 Type Parameters:
 R - the element type of the inner Publishers and the output
 Parameters:
 mapper - a function that, when applied to an item emitted by the source Publisher, returns a Publisher
 Returns:
 a Flowable that emits the items emitted by the Publisher returned from applyingfunc to the most recently emitted item emitted by the source Publisher
 See Also:
 ReactiveX operators documentation: FlatMap,switchMapDelayError(Function)
 - switchMap
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <R> Flowable<R> switchMap(Function<? superT,? extendsPublisher<? 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.
 The resulting Publisher completes if both the upstream Publisher and the last inner Publisher, if any, complete. If the upstream Publisher signals an onError, the inner Publisher is canceled and the error delivered in-sequence.
 Backpressure:
 The operator honors backpressure from downstream. The outerPublisher is consumed in an unbounded manner (i.e., without backpressure) and the innerPublishers are expected to honor backpressure but it is not enforced; the operator won't signal aMissingBackpressureException but the violationmay lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 switchMap does not operate by default on a particularScheduler.
 Type Parameters:
 R - the element type of the inner Publishers and the output
 Parameters:
 mapper - a function that, when applied to an item emitted by the source Publisher, returns a Publisher
 bufferSize - the number of elements to prefetch from the current active inner Publisher
 Returns:
 a Flowable that emits the items emitted by the Publisher returned from applyingfunc to the most recently emitted item emitted by the source Publisher
 See Also:
 ReactiveX operators documentation: FlatMap,switchMapDelayError(Function, int)
 - switchMapCompletable
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final Completable switchMapCompletable(@NonNullFunction<? superT,? extendsCompletableSource> mapper)
```
 Maps the upstream values intoCompletableSources, subscribes to the newer one while disposing the subscription to the previousCompletableSource, thus keeping at most one activeCompletableSource running.
 Since aCompletableSource doesn't produce any items, the resulting reactive type of this operator is aCompletable that can only indicate successful completion or a failure in any of the innerCompletableSources or the failure of the currentFlowable.
 Backpressure:
 The operator consumes the currentFlowable in an unbounded manner and otherwise does not have backpressure in its return type because no items are ever produced.
 Scheduler:
 switchMapCompletable does not operate by default on a particularScheduler.
 Error handling:
 If either thisFlowable or the activeCompletableSource signals anonError, the resultingCompletable is terminated immediately with thatThrowable. Use theswitchMapCompletableDelayError(Function) to delay such inner failures until every innerCompletableSources and the mainFlowable terminates in some fashion. If they fail concurrently, the operator may combine theThrowables into aCompositeException and signal it to the downstream instead. If any inactivated (switched out)CompletableSource signals anonError late, theThrowables will be signaled to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors.
 History: 2.1.11 - experimental
 Parameters:
 mapper - the function called with each upstream item and should return aCompletableSource to be subscribed to and awaited for (non blockingly) for its terminal event
 Returns:
 the new Completable instance
 Since:
 2.2
 See Also:
 switchMapCompletableDelayError(Function)
 - switchMapCompletableDelayError
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final Completable switchMapCompletableDelayError(@NonNullFunction<? superT,? extendsCompletableSource> mapper)
```
 Maps the upstream values intoCompletableSources, subscribes to the newer one while disposing the subscription to the previousCompletableSource, thus keeping at most one activeCompletableSource running and delaying any main or inner errors until all of them terminate.
 Since aCompletableSource doesn't produce any items, the resulting reactive type of this operator is aCompletable that can only indicate successful completion or a failure in any of the innerCompletableSources or the failure of the currentFlowable.
 Backpressure:
 The operator consumes the currentFlowable in an unbounded manner and otherwise does not have backpressure in its return type because no items are ever produced.
 Scheduler:
 switchMapCompletableDelayError does not operate by default on a particularScheduler.
 Error handling:
 Errors of thisFlowable and all theCompletableSources, who had the chance to run to their completion, are delayed until all of them terminate in some fashion. At this point, if there was only one failure, the respectiveThrowable is emitted to the downstream. If there was more than one failure, the operator combines allThrowables into aCompositeException and signals that to the downstream. If any inactivated (switched out)CompletableSource signals anonError late, theThrowables will be signaled to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors.
 History: 2.1.11 - experimental
 Parameters:
 mapper - the function called with each upstream item and should return aCompletableSource to be subscribed to and awaited for (non blockingly) for its terminal event
 Returns:
 the new Completable instance
 Since:
 2.2
 See Also:
 switchMapCompletable(Function)
 - switchMapDelayError
```
@CheckReturnValue@BackpressureSupport(value=SPECIAL)@SchedulerSupport(value="none")public final <R> Flowable<R> switchMapDelayError(Function<? superT,? extendsPublisher<? 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.
 The resulting Publisher completes if both the upstream Publisher and the last inner Publisher, if any, complete. If the upstream 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 outerPublisher is consumed in an unbounded manner (i.e., without backpressure) and the innerPublishers are expected to honor backpressure but it is not enforced; the operator won't signal aMissingBackpressureException but the violationmay lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 switchMapDelayError does not operate by default on a particularScheduler.
 Type Parameters:
 R - the element type of the inner Publishers and the output
 Parameters:
 mapper - a function that, when applied to an item emitted by the source Publisher, returns a Publisher
 Returns:
 a Flowable that emits the items emitted by the Publisher returned from applyingfunc to the most recently emitted item emitted by the source Publisher
 Since:
 2.0
 See Also:
 ReactiveX operators documentation: FlatMap,switchMap(Function)
 - switchMapDelayError
```
@CheckReturnValue@BackpressureSupport(value=SPECIAL)@SchedulerSupport(value="none")public final <R> Flowable<R> switchMapDelayError(Function<? superT,? extendsPublisher<? 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.
 The resulting Publisher completes if both the upstream Publisher and the last inner Publisher, if any, complete. If the upstream 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 outerPublisher is consumed in an unbounded manner (i.e., without backpressure) and the innerPublishers are expected to honor backpressure but it is not enforced; the operator won't signal aMissingBackpressureException but the violationmay lead toOutOfMemoryError due to internal buffer bloat.
 Scheduler:
 switchMapDelayError does not operate by default on a particularScheduler.
 Type Parameters:
 R - the element type of the inner Publishers and the output
 Parameters:
 mapper - a function that, when applied to an item emitted by the source Publisher, returns a Publisher
 bufferSize - the number of elements to prefetch from the current active inner Publisher
 Returns:
 a Flowable that emits the items emitted by the Publisher returned from applyingfunc to the most recently emitted item emitted by the source Publisher
 Since:
 2.0
 See Also:
 ReactiveX operators documentation: FlatMap,switchMap(Function, int)
 - switchMapMaybe
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final <R> Flowable<R> switchMapMaybe(@NonNullFunction<? superT,? extendsMaybeSource<? extends R>> mapper)
```
 Maps the upstream items intoMaybeSources 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 thisFlowable or any of the active innerMaybeSources fail.
 Backpressure:
 The operator honors backpressure from downstream. The mainFlowable is consumed in an unbounded manner (i.e., without backpressure).
 Scheduler:
 switchMapMaybe does not operate by default on a particularScheduler.
 Error handling:
 This operator terminates with anonError if thisFlowable or any of the innerMaybeSources fail while they are active. When this happens concurrently, their individualThrowable errors may get combined and emitted as a singleCompositeException. Otherwise, a late (i.e., inactive or switched out)onError from thisFlowable or from any of the innerMaybeSources will be forwarded to the global error handler viaRxJavaPlugins.onError(Throwable) asUndeliverableException
 History: 2.1.11 - experimental
 Type Parameters:
 R - the output value type
 Parameters:
 mapper - the function called with the current upstream event and should return aMaybeSource to replace the current active inner source and get subscribed to.
 Returns:
 the new Flowable instance
 Since:
 2.2
 See Also:
 switchMapMaybe(Function),switchMapMaybeDelayError(Function)
 - switchMapMaybeDelayError
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final <R> Flowable<R> switchMapMaybeDelayError(@NonNullFunction<? superT,? extendsMaybeSource<? extends R>> mapper)
```
 Maps the upstream items intoMaybeSources 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 thisFlowable or the innerMaybeSources until all terminate.
 Backpressure:
 The operator honors backpressure from downstream. The mainFlowable is consumed in an unbounded manner (i.e., without backpressure).
 Scheduler:
 switchMapMaybeDelayError does not operate by default on a particularScheduler.
 History: 2.1.11 - experimental
 Type Parameters:
 R - the output value type
 Parameters:
 mapper - the function called with the current upstream event and should return aMaybeSource to replace the current active inner source and get subscribed to.
 Returns:
 the new Flowable instance
 Since:
 2.2
 See Also:
 switchMapMaybe(Function)
 - switchMapSingle
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final <R> Flowable<R> switchMapSingle(@NonNullFunction<? superT,? extendsSingleSource<? extends R>> mapper)
```
 Maps the upstream items intoSingleSources 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 thisFlowable or any of the active innerSingleSources fail.
 Backpressure:
 The operator honors backpressure from downstream. The mainFlowable is consumed in an unbounded manner (i.e., without backpressure).
 Scheduler:
 switchMapSingle does not operate by default on a particularScheduler.
 Error handling:
 This operator terminates with anonError if thisFlowable or any of the innerSingleSources fail while they are active. When this happens concurrently, their individualThrowable errors may get combined and emitted as a singleCompositeException. Otherwise, a late (i.e., inactive or switched out)onError from thisFlowable or from any of the innerSingleSources will be forwarded to the global error handler viaRxJavaPlugins.onError(Throwable) asUndeliverableException
 History: 2.1.11 - experimental
 Type Parameters:
 R - the output value type
 Parameters:
 mapper - the function called with the current upstream event and should return aSingleSource to replace the current active inner source and get subscribed to.
 Returns:
 the new Flowable instance
 Since:
 2.2
 See Also:
 switchMapSingleDelayError(Function)
 - switchMapSingleDelayError
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final <R> Flowable<R> switchMapSingleDelayError(@NonNullFunction<? superT,? extendsSingleSource<? extends R>> mapper)
```
 Maps the upstream items intoSingleSources 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 thisFlowable or the innerSingleSources until all terminate.
 Backpressure:
 The operator honors backpressure from downstream. The mainFlowable is consumed in an unbounded manner (i.e., without backpressure).
 Scheduler:
 switchMapSingleDelayError does not operate by default on a particularScheduler.
 History: 2.1.11 - experimental
 Type Parameters:
 R - the output value type
 Parameters:
 mapper - the function called with the current upstream event and should return aSingleSource to replace the current active inner source and get subscribed to.
 Returns:
 the new Flowable instance
 Since:
 2.2
 See Also:
 switchMapSingle(Function)
 - take
```
@CheckReturnValue@BackpressureSupport(value=SPECIAL)@SchedulerSupport(value="none")public final Flowable<T> take(long count)
```
 Returns a Flowable that emits only the firstcount items emitted by the source Publisher. If the source emits fewer thancount items then all of its items are emitted.
 This method returns a Publisher that will invoke a subscribingSubscriber'sonNext function a maximum ofcount times before invokingonComplete.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior in case the first request is smaller than thecount. Otherwise, the sourcePublisher is consumed in an unbounded manner (i.e., without applying backpressure to it).
 Scheduler:
 This version oftake does not operate by default on a particularScheduler.
 Parameters:
 count - the maximum number of items to emit
 Returns:
 a Flowable that emits only the firstcount items emitted by the source Publisher, or all of the items from the source Publisher if that Publisher emits fewer thancount items
 See Also:
 ReactiveX operators documentation: Take
 - take
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="io.reactivex:computation")public final Flowable<T> take(long time,TimeUnit unit)
```
 Returns a Flowable that emits those items emitted by source Publisher before a specified time runs out.
 If time runs out before theFlowable completes normally, theonComplete event will be signaled on the defaultcomputationScheduler.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 This version oftake operates by default on thecomputationScheduler.
 Parameters:
 time - the length of the time window
 unit - the time unit oftime
 Returns:
 a Flowable that emits those items emitted by the source Publisher before the time runs out
 See Also:
 ReactiveX operators documentation: Take
 - take
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="custom")public final 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.
 If time runs out before theFlowable completes normally, theonComplete event will be signaled on the providedScheduler.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 time - the length of the time window
 unit - the time unit oftime
 scheduler - the Scheduler used for time source
 Returns:
 a Flowable that emits those items emitted by the source Publisher before the time runs out, according to the specified Scheduler
 See Also:
 ReactiveX operators documentation: Take
 - takeLast
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<T> takeLast(int count)
```
 Returns a Flowable that emits at most the lastcount items emitted by the source Publisher. If the source emits fewer thancount items then all of its items are emitted.
 Backpressure:
 The operator honors backpressure from downstream if thecount is non-zero; ignores backpressure if thecount is zero as it doesn't signal any values.
 Scheduler:
 This version oftakeLast does not operate by default on a particularScheduler.
 Parameters:
 count - the maximum number of items to emit from the end of the sequence of items emitted by the source Publisher
 Returns:
 a Flowable that emits at most the lastcount items emitted by the source Publisher
 Throws:
 IndexOutOfBoundsException - ifcount is less than zero
 See Also:
 ReactiveX operators documentation: TakeLast
 - takeLast
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final 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.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., no backpressure is applied to it).
 Scheduler:
 takeLast does not operate on any particular scheduler but uses the current time from thecomputationScheduler.
 Parameters:
 count - the maximum number of items to emit
 time - the length of the time window
 unit - the time unit oftime
 Returns:
 a Flowable that emits at mostcount items from the source Publisher that were emitted in a specified window of time before the Publisher completed
 See Also:
 ReactiveX operators documentation: TakeLast
 - takeLast
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="custom")public final 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.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., no backpressure is applied to it).
 Scheduler:
 You specify whichScheduler this operator will use for tracking the current time
 Parameters:
 count - the maximum number of items to emit
 time - the length of the time window
 unit - the time unit oftime
 scheduler - theScheduler that provides the timestamps for the observed items
 Returns:
 a Flowable that emits at mostcount 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 the givenscheduler
 Throws:
 IndexOutOfBoundsException - ifcount is less than zero
 See Also:
 ReactiveX operators documentation: TakeLast
 - takeLast
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="custom")public final 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.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., no backpressure is applied to it).
 Scheduler:
 You specify whichScheduler this operator will use for tracking the current time
 Parameters:
 count - the maximum number of items to emit
 time - the length of the time window
 unit - the time unit oftime
 scheduler - theScheduler that provides the timestamps for the observed items
 delayError - if true, an exception signaled by the current Flowable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signaled and all regular elements dropped
 bufferSize - the hint about how many elements to expect to be last
 Returns:
 a Flowable that emits at mostcount 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 the givenscheduler
 Throws:
 IndexOutOfBoundsException - ifcount is less than zero
 See Also:
 ReactiveX operators documentation: TakeLast
 - takeLast
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="io.reactivex:computation")public final 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.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., no backpressure is applied to it) but note that thismay lead toOutOfMemoryError due to internal buffer bloat. Consider usingtakeLast(long, long, TimeUnit) in this case.
 Scheduler:
 This version oftakeLast operates by default on thecomputationScheduler.
 Parameters:
 time - the length of the time window
 unit - the time unit oftime
 Returns:
 a Flowable that emits the items from the source Publisher that were emitted in the window of time before the Publisher completed specified bytime
 See Also:
 ReactiveX operators documentation: TakeLast
 - takeLast
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="io.reactivex:computation")public final 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.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., no backpressure is applied to it) but note that thismay lead toOutOfMemoryError due to internal buffer bloat. Consider usingtakeLast(long, long, TimeUnit) in this case.
 Scheduler:
 This version oftakeLast operates by default on thecomputationScheduler.
 Parameters:
 time - the length of the time window
 unit - the time unit oftime
 delayError - if true, an exception signaled by the current Flowable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signaled and all regular elements dropped
 Returns:
 a Flowable that emits the items from the source Publisher that were emitted in the window of time before the Publisher completed specified bytime
 See Also:
 ReactiveX operators documentation: TakeLast
 - takeLast
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="custom")public final 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.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., no backpressure is applied to it) but note that thismay lead toOutOfMemoryError due to internal buffer bloat. Consider usingtakeLast(long, long, TimeUnit, Scheduler) in this case.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 time - the length of the time window
 unit - the time unit oftime
 scheduler - the Scheduler that provides the timestamps for the Observed items
 Returns:
 a Flowable that emits the items from the source Publisher that were emitted in the window of time before the Publisher completed specified bytime, where the timing information is provided byscheduler
 See Also:
 ReactiveX operators documentation: TakeLast
 - takeLast
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="custom")public final 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.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., no backpressure is applied to it) but note that thismay lead toOutOfMemoryError due to internal buffer bloat. Consider usingtakeLast(long, long, TimeUnit, Scheduler) in this case.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 time - the length of the time window
 unit - the time unit oftime
 scheduler - the Scheduler that provides the timestamps for the Observed items
 delayError - if true, an exception signaled by the current Flowable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signaled and all regular elements dropped
 Returns:
 a Flowable that emits the items from the source Publisher that were emitted in the window of time before the Publisher completed specified bytime, where the timing information is provided byscheduler
 See Also:
 ReactiveX operators documentation: TakeLast
 - takeLast
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="custom")public final 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.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., no backpressure is applied to it) but note that thismay lead toOutOfMemoryError due to internal buffer bloat. Consider usingtakeLast(long, long, TimeUnit, Scheduler) in this case.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 time - the length of the time window
 unit - the time unit oftime
 scheduler - the Scheduler that provides the timestamps for the Observed items
 delayError - if true, an exception signaled by the current Flowable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signaled and all regular elements dropped
 bufferSize - the hint about how many elements to expect to be last
 Returns:
 a Flowable that emits the items from the source Publisher that were emitted in the window of time before the Publisher completed specified bytime, where the timing information is provided byscheduler
 See Also:
 ReactiveX operators documentation: TakeLast
 - takeUntil
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<T> takeUntil(Predicate<? superT> 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.
 The difference between this operator andtakeWhile(Predicate) is that here, the condition is evaluatedafter the item is emitted.
 Backpressure:
 The operator is a pass-through for backpressure; the backpressure behavior is determined by the upstream source and the downstream consumer.
 Scheduler:
 takeUntil does not operate by default on a particularScheduler.
 Parameters:
 stopPredicate - a function that evaluates an item emitted by the source Publisher and returns a Boolean
 Returns:
 a Flowable that first emits items emitted by the source Publisher, checks the specified condition after each item, and then completes when the condition is satisfied.
 Since:
 1.1.0
 See Also:
 ReactiveX operators documentation: TakeUntil,takeWhile(Predicate)
 - takeUntil
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final  Flowable<T> takeUntil(Publisher other)
```
 Returns a Flowable that emits the items emitted by the source Publisher until a second Publisher emits an item.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 takeUntil does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of items emitted byother
 Parameters:
 other - the Publisher whose first emitted item will causetakeUntil to stop emitting items from the source Publisher
 Returns:
 a Flowable that emits the items emitted by the source Publisher until such time asother emits its first item
 See Also:
 ReactiveX operators documentation: TakeUntil
 - takeWhile
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<T> takeWhile(Predicate<? superT> 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.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 takeWhile does not operate by default on a particularScheduler.
 Parameters:
 predicate - a function that evaluates an item emitted by the source Publisher and returns a Boolean
 Returns:
 a Flowable that emits the items from the source Publisher so long as each item satisfies the condition defined bypredicate, then completes
 See Also:
 ReactiveX operators documentation: TakeWhile,takeUntil(Predicate)
 - throttleFirst
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="io.reactivex:computation")public final 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.
 This differs fromthrottleLast(long, java.util.concurrent.TimeUnit) in that this only tracks the passage of time whereasthrottleLast(long, java.util.concurrent.TimeUnit) ticks at scheduled intervals.
 Backpressure:
 This operator does not support backpressure as it uses time to control data flow.
 Scheduler:
 throttleFirst operates by default on thecomputationScheduler.
 Parameters:
 windowDuration - time to wait before emitting another item after emitting the last item
 unit - the unit of time ofwindowDuration
 Returns:
 a Flowable that performs the throttle operation
 See Also:
 ReactiveX operators documentation: Sample,RxJava wiki: Backpressure
 - throttleFirst
```
@CheckReturnValue@NonNull@BackpressureSupport(value=ERROR)@SchedulerSupport(value="custom")public final 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.
 This differs fromthrottleLast(long, java.util.concurrent.TimeUnit) in that this only tracks the passage of time whereasthrottleLast(long, java.util.concurrent.TimeUnit) ticks at scheduled intervals.
 Backpressure:
 This operator does not support backpressure as it uses time to control data flow.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 skipDuration - time to wait before emitting another item after emitting the last item
 unit - the unit of time ofskipDuration
 scheduler - theScheduler to use internally to manage the timers that handle timeout for each event
 Returns:
 a Flowable that performs the throttle operation
 See Also:
 ReactiveX operators documentation: Sample,RxJava wiki: Backpressure
 - throttleLast
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="io.reactivex:computation")public final 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.
 This differs fromthrottleFirst(long, java.util.concurrent.TimeUnit) in that this ticks along at a scheduled interval whereasthrottleFirst(long, java.util.concurrent.TimeUnit) does not tick, it just tracks the passage of time.
 Backpressure:
 This operator does not support backpressure as it uses time to control data flow.
 Scheduler:
 throttleLast operates by default on thecomputationScheduler.
 Parameters:
 intervalDuration - duration of windows within which the last item emitted by the source Publisher will be emitted
 unit - the unit of time ofintervalDuration
 Returns:
 a Flowable that performs the throttle operation
 See Also:
 ReactiveX operators documentation: Sample,RxJava wiki: Backpressure,sample(long, TimeUnit)
 - throttleLast
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="custom")public final 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.
 This differs fromthrottleFirst(long, java.util.concurrent.TimeUnit) in that this ticks along at a scheduled interval whereasthrottleFirst(long, java.util.concurrent.TimeUnit) does not tick, it just tracks the passage of time.
 Backpressure:
 This operator does not support backpressure as it uses time to control data flow.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 intervalDuration - duration of windows within which the last item emitted by the source Publisher will be emitted
 unit - the unit of time ofintervalDuration
 scheduler - theScheduler to use internally to manage the timers that handle timeout for each event
 Returns:
 a Flowable that performs the throttle operation
 See Also:
 ReactiveX operators documentation: Sample,RxJava wiki: Backpressure,sample(long, TimeUnit, Scheduler)
 - throttleLatest
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="io.reactivex:computation")public final Flowable<T> throttleLatest(long timeout,TimeUnit unit)
```
 Throttles items from the upstreamFlowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
 Unlike the option withthrottleLatest(long, TimeUnit, boolean), the very last item being held back (if any) is not emitted when the upstream completes.
 If no items were emitted from the upstream during this timeout phase, the next upstream item is emitted immediately and the timeout window starts from then.
 Backpressure:
 This operator does not support backpressure as it uses time to control data flow. If the downstream is not ready to receive items, aMissingBackpressureException will be signaled.
 Scheduler:
 throttleLatest operates by default on thecomputationScheduler.
 History: 2.1.14 - experimental
 Parameters:
 timeout - the time to wait after an item emission towards the downstream before trying to emit the latest item from upstream again
 unit - the time unit
 Returns:
 the new Flowable instance
 Since:
 2.2
 See Also:
 throttleLatest(long, TimeUnit, boolean),throttleLatest(long, TimeUnit, Scheduler)
 - throttleLatest
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="io.reactivex:computation")public final Flowable<T> throttleLatest(long timeout,TimeUnit unit, boolean emitLast)
```
 Throttles items from the upstreamFlowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
 If no items were emitted from the upstream during this timeout phase, the next upstream item is emitted immediately and the timeout window starts from then.
 Backpressure:
 This operator does not support backpressure as it uses time to control data flow. If the downstream is not ready to receive items, aMissingBackpressureException will be signaled.
 Scheduler:
 throttleLatest operates by default on thecomputationScheduler.
 History: 2.1.14 - experimental
 Parameters:
 timeout - the time to wait after an item emission towards the downstream before trying to emit the latest item from upstream again
 unit - the time unit
 emitLast - Iftrue, the very last item from the upstream will be emitted immediately when the upstream completes, regardless if there is a timeout window active or not. Iffalse, the very last upstream item is ignored and the flow terminates.
 Returns:
 the new Flowable instance
 Since:
 2.2
 See Also:
 throttleLatest(long, TimeUnit, Scheduler, boolean)
 - throttleLatest
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="custom")public final Flowable<T> throttleLatest(long timeout,TimeUnit unit,Scheduler scheduler)
```
 Throttles items from the upstreamFlowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
 Unlike the option withthrottleLatest(long, TimeUnit, Scheduler, boolean), the very last item being held back (if any) is not emitted when the upstream completes.
 If no items were emitted from the upstream during this timeout phase, the next upstream item is emitted immediately and the timeout window starts from then.
 Backpressure:
 This operator does not support backpressure as it uses time to control data flow. If the downstream is not ready to receive items, aMissingBackpressureException will be signaled.
 Scheduler:
 You specify whichScheduler this operator will use.
 History: 2.1.14 - experimental
 Parameters:
 timeout - the time to wait after an item emission towards the downstream before trying to emit the latest item from upstream again
 unit - the time unit
 scheduler - theScheduler where the timed wait and latest item emission will be performed
 Returns:
 the new Flowable instance
 Since:
 2.2
 See Also:
 throttleLatest(long, TimeUnit, Scheduler, boolean)
 - throttleLatest
```
@CheckReturnValue@NonNull@BackpressureSupport(value=ERROR)@SchedulerSupport(value="custom")public final Flowable<T> throttleLatest(long timeout,TimeUnit unit,Scheduler scheduler, boolean emitLast)
```
 Throttles items from the upstreamFlowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
 If no items were emitted from the upstream during this timeout phase, the next upstream item is emitted immediately and the timeout window starts from then.
 Backpressure:
 This operator does not support backpressure as it uses time to control data flow. If the downstream is not ready to receive items, aMissingBackpressureException will be signaled.
 Scheduler:
 You specify whichScheduler this operator will use.
 History: 2.1.14 - experimental
 Parameters:
 timeout - the time to wait after an item emission towards the downstream before trying to emit the latest item from upstream again
 unit - the time unit
 scheduler - theScheduler where the timed wait and latest item emission will be performed
 emitLast - Iftrue, the very last item from the upstream will be emitted immediately when the upstream completes, regardless if there is a timeout window active or not. Iffalse, the very last upstream item is ignored and the flow terminates.
 Returns:
 the new Flowable instance
 Since:
 2.2
 - throttleWithTimeout
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="io.reactivex:computation")public final 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. The timer resets on each emission (alias todebounce(long, TimeUnit)).
 Note: If items keep being emitted by the source Publisher faster than the timeout then no items will be emitted by the resulting Publisher.
 Backpressure:
 This operator does not support backpressure as it uses time to control data flow.
 Scheduler:
 throttleWithTimeout operates by default on thecomputationScheduler.
 Parameters:
 timeout - the length of the window of time that must pass after the emission of an item from the source Publisher in which that Publisher emits no items in order for the item to be emitted by the resulting Publisher
 unit - the unit of time for the specifiedtimeout
 Returns:
 a Flowable that filters out items from the source Publisher that are too quickly followed by newer items
 See Also:
 ReactiveX operators documentation: Debounce,RxJava wiki: Backpressure,debounce(long, TimeUnit)
 - throttleWithTimeout
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="custom")public final 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. The timer resets on each emission (alias todebounce(long, TimeUnit, Scheduler)).
 Note: If items keep being emitted by the source Publisher faster than the timeout then no items will be emitted by the resulting Publisher.
 Backpressure:
 This operator does not support backpressure as it uses time to control data flow.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 timeout - the length of the window of time that must pass after the emission of an item from the source Publisher in which that Publisher emits no items in order for the item to be emitted by the resulting Publisher
 unit - the unit of time for the specifiedtimeout
 scheduler - theScheduler to use internally to manage the timers that handle the timeout for each item
 Returns:
 a Flowable that filters out items from the source Publisher that are too quickly followed by newer items
 See Also:
 ReactiveX operators documentation: Debounce,RxJava wiki: Backpressure,debounce(long, TimeUnit, Scheduler)
 - timeInterval
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<Timed<T>> timeInterval()
```
 Returns a Flowable that emits records of the time interval between consecutive items emitted by the source Publisher.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 timeInterval does not operate on any particular scheduler but uses the current time from thecomputationScheduler.
 Returns:
 a Flowable that emits time interval information items
 See Also:
 ReactiveX operators documentation: TimeInterval
 - timeInterval
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final 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.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 The operator does not operate on any particular scheduler but uses the current time from the specifiedScheduler.
 Parameters:
 scheduler - theScheduler used to compute time intervals
 Returns:
 a Flowable that emits time interval information items
 See Also:
 ReactiveX operators documentation: TimeInterval
 - timeInterval
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<Timed<T>> timeInterval(TimeUnit unit)
```
 Returns a Flowable that emits records of the time interval between consecutive items emitted by the source Publisher.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 timeInterval does not operate on any particular scheduler but uses the current time from thecomputationScheduler.
 Parameters:
 unit - the time unit for the current time
 Returns:
 a Flowable that emits time interval information items
 See Also:
 ReactiveX operators documentation: TimeInterval
 - timeInterval
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final 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.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 The operator does not operate on any particular scheduler but uses the current time from the specifiedScheduler.
 Parameters:
 unit - the time unit for the current time
 scheduler - theScheduler used to compute time intervals
 Returns:
 a Flowable that emits time interval information items
 See Also:
 ReactiveX operators documentation: TimeInterval
 - timeout
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final <V> Flowable<T> timeout(Function<? superT,? extendsPublisher<V>> itemTimeoutIndicator)
```
 Returns a Flowable that mirrors the source Publisher, but notifies Subscribers of aTimeoutException 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.
 Note: The arrival of the first source item is never timed out.
 Backpressure:
 The operator honors backpressure from downstream. ThePublisher sources are expected to honor backpressure as well. If any of the sourcePublishers violate this, itmay throw anIllegalStateException when the sourcePublisher completes.
 Scheduler:
 This version oftimeout operates by default on theimmediateScheduler.
 Type Parameters:
 V - the timeout value type (ignored)
 Parameters:
 itemTimeoutIndicator - a function that returns a Publisher for each item emitted by the source Publisher and that determines the timeout window for the subsequent item
 Returns:
 a Flowable that mirrors the source Publisher, but notifies Subscribers of aTimeoutException if an item emitted by the source Publisher takes longer to arrive than the time window defined by the selector for the previously emitted item
 See Also:
 ReactiveX operators documentation: Timeout
 - timeout
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <V> Flowable<T> timeout(Function<? superT,? extendsPublisher<V>> itemTimeoutIndicator,Flowable<? extendsT> 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.
 Note: The arrival of the first source item is never timed out.
 Backpressure:
 The operator honors backpressure from downstream. ThePublisher sources are expected to honor backpressure as well. If any of the sourcePublishers violate this, itmay throw anIllegalStateException when the sourcePublisher completes.
 Scheduler:
 This version oftimeout operates by default on theimmediateScheduler.
 Type Parameters:
 V - the timeout value type (ignored)
 Parameters:
 itemTimeoutIndicator - a function that returns a Publisher, for each item emitted by the source Publisher, that determines the timeout window for the subsequent item
 other - the fallback Publisher to switch to if the source Publisher times out
 Returns:
 a Flowable that mirrors the source Publisher, but switches to mirroring a fallback Publisher if an item emitted by the source Publisher takes longer to arrive than the time window defined by the selector for the previously emitted item
 See Also:
 ReactiveX operators documentation: Timeout
 - timeout
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="io.reactivex:computation")public final Flowable<T> timeout(long timeout,TimeUnit timeUnit)
```
 Returns a Flowable that mirrors the source Publisher but applies a timeout policy for each emitted item. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the resulting Publisher terminates and notifies Subscribers of aTimeoutException.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 This version oftimeout operates by default on thecomputationScheduler.
 Parameters:
 timeout - maximum duration between emitted items before a timeout occurs
 timeUnit - the unit of time that applies to thetimeout argument.
 Returns:
 the source Publisher modified to notify Subscribers of aTimeoutException in case of a timeout
 See Also:
 ReactiveX operators documentation: Timeout
 - timeout
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="io.reactivex:computation")public final Flowable<T> timeout(long timeout,TimeUnit timeUnit,Publisher<? extendsT> other)
```
 Returns a Flowable that mirrors the source Publisher but applies a timeout policy for each emitted item. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the source Publisher is disposed and resulting Publisher begins instead to mirror a fallback Publisher.
 Backpressure:
 The operator honors backpressure from downstream. ThePublisher sources are expected to honor backpressure as well. If any of the sourcePublishers violate this, itmay throw anIllegalStateException when the sourcePublisher completes.
 Scheduler:
 This version oftimeout operates by default on thecomputationScheduler.
 Parameters:
 timeout - maximum duration between items before a timeout occurs
 timeUnit - the unit of time that applies to thetimeout argument
 other - the fallback Publisher to use in case of a timeout
 Returns:
 the source Publisher modified to switch to the fallback Publisher in case of a timeout
 See Also:
 ReactiveX operators documentation: Timeout
 - timeout
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="custom")public final Flowable<T> timeout(long timeout,TimeUnit timeUnit,Scheduler scheduler,Publisher<? extendsT> other)
```
 Returns a Flowable that mirrors the source Publisher but applies a timeout policy for each emitted item using a specified Scheduler. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the source Publisher is disposed and resulting Publisher begins instead to mirror a fallback Publisher.
 Backpressure:
 The operator honors backpressure from downstream. ThePublisher sources are expected to honor backpressure as well. If any of the sourcePublishers violate this, itmay throw anIllegalStateException when the sourcePublisher completes.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 timeout - maximum duration between items before a timeout occurs
 timeUnit - the unit of time that applies to thetimeout argument
 scheduler - theScheduler to run the timeout timers on
 other - the Publisher to use as the fallback in case of a timeout
 Returns:
 the source Publisher modified so that it will switch to the fallback Publisher in case of a timeout
 See Also:
 ReactiveX operators documentation: Timeout
 - timeout
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="custom")public final 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. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the resulting Publisher terminates and notifies Subscribers of aTimeoutException.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 timeout - maximum duration between items before a timeout occurs
 timeUnit - the unit of time that applies to thetimeout argument
 scheduler - the Scheduler to run the timeout timers on
 Returns:
 the source Publisher modified to notify Subscribers of aTimeoutException in case of a timeout
 See Also:
 ReactiveX operators documentation: Timeout
 - timeout
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final <U,V> Flowable<T> timeout(Publisher firstTimeoutIndicator,Function<? superT,? extendsPublisher<V>> itemTimeoutIndicator)
```
 Returns a Flowable that mirrors the source Publisher, but notifies Subscribers of aTimeoutException if either the first item emitted by the source Publisher or any subsequent item doesn't arrive within time windows defined by other Publishers.
 Backpressure:
 The operator honors backpressure from downstream. Both this and the returnedPublishers are expected to honor backpressure as well. If any of then violates this rule, itmay throw anIllegalStateException when thePublisher completes.
 Scheduler:
 timeout does not operate by default on anyScheduler.
 Type Parameters:
 U - the first timeout value type (ignored)
 V - the subsequent timeout value type (ignored)
 Parameters:
 firstTimeoutIndicator - a function that returns a Publisher that determines the timeout window for the first source item
 itemTimeoutIndicator - a function that returns a Publisher for each item emitted by the source Publisher and that determines the timeout window in which the subsequent source item must arrive in order to continue the sequence
 Returns:
 a Flowable that mirrors the source Publisher, but notifies Subscribers of aTimeoutException if either the first item or any subsequent item doesn't arrive within the time windows specified by the timeout selectors
 See Also:
 ReactiveX operators documentation: Timeout
 - timeout
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <U,V> Flowable<T> timeout(Publisher firstTimeoutIndicator,Function<? superT,? extendsPublisher<V>> itemTimeoutIndicator,Publisher<? extendsT> 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.
 Backpressure:
 The operator honors backpressure from downstream. ThePublisher sources are expected to honor backpressure as well. If any of the sourcePublishers violate this, itmay throw anIllegalStateException when the sourcePublisher completes.
 Scheduler:
 timeout does not operate by default on anyScheduler.
 Type Parameters:
 U - the first timeout value type (ignored)
 V - the subsequent timeout value type (ignored)
 Parameters:
 firstTimeoutIndicator - a function that returns a Publisher which determines the timeout window for the first source item
 itemTimeoutIndicator - a function that returns a Publisher for each item emitted by the source Publisher and that determines the timeout window in which the subsequent source item must arrive in order to continue the sequence
 other - the fallback Publisher to switch to if the source Publisher times out
 Returns:
 a Flowable that mirrors the source Publisher, but switches to theother Publisher if either the first item emitted by the source Publisher or any subsequent item doesn't arrive within time windows defined by the timeout selectors
 Throws:
 NullPointerException - ifitemTimeoutIndicator is null
 See Also:
 ReactiveX operators documentation: Timeout
 - timestamp
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<Timed<T>> timestamp()
```
 Returns a Flowable that emits each item emitted by the source Publisher, wrapped in aTimed object.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 timestamp does not operate on any particular scheduler but uses the current time from thecomputationScheduler.
 Returns:
 a Flowable that emits timestamped items from the source Publisher
 See Also:
 ReactiveX operators documentation: Timestamp
 - timestamp
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<Timed<T>> timestamp(Scheduler scheduler)
```
 Returns a Flowable that emits each item emitted by the source Publisher, wrapped in aTimed object whose timestamps are provided by a specified Scheduler.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 This operator does not operate on any particular scheduler but uses the current time from the specifiedScheduler.
 Parameters:
 scheduler - theScheduler to use as a time source
 Returns:
 a Flowable that emits timestamped items from the source Publisher with timestamps provided by thescheduler
 See Also:
 ReactiveX operators documentation: Timestamp
 - timestamp
```
@CheckReturnValue@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<Timed<T>> timestamp(TimeUnit unit)
```
 Returns a Flowable that emits each item emitted by the source Publisher, wrapped in aTimed object.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 timestamp does not operate on any particular scheduler but uses the current time from thecomputationScheduler.
 Parameters:
 unit - the time unit for the current time
 Returns:
 a Flowable that emits timestamped items from the source Publisher
 See Also:
 ReactiveX operators documentation: Timestamp
 - timestamp
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final Flowable<Timed<T>> timestamp(TimeUnit unit,Scheduler scheduler)
```
 Returns a Flowable that emits each item emitted by the source Publisher, wrapped in aTimed object whose timestamps are provided by a specified Scheduler.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 This operator does not operate on any particular scheduler but uses the current time from the specifiedScheduler.
 Parameters:
 unit - the time unit for the current time
 scheduler - theScheduler to use as a time source
 Returns:
 a Flowable that emits timestamped items from the source Publisher with timestamps provided by thescheduler
 See Also:
 ReactiveX operators documentation: Timestamp
 - to
```
@CheckReturnValue@BackpressureSupport(value=SPECIAL)@SchedulerSupport(value="none")public final <R> R to(Function<? superFlowable<T>,R> converter)
```
 Calls the specified converter function during assembly time and returns its resulting value.
 This allows fluent conversion to any other type.
 Backpressure:
 The backpressure behavior depends on what happens in theconverter function.
 Scheduler:
 to does not operate by default on a particularScheduler.
 Type Parameters:
 R - the resulting object type
 Parameters:
 converter - the function that receives the current Flowable instance and returns a value
 Returns:
 the value returned by the function
 - toList
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final 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.
 Normally, a Publisher that returns multiple items will do so by invoking itsSubscriber'sonNext method for each such item. You can change this behavior, instructing the Publisher to compose a list of all of these items and then to invoke the Subscriber'sonNext function once, passing it the entire list, by calling the Publisher'stoList method prior to calling itssubscribe() method.
 Note that this operator requires the upstream to signalonComplete for the accumulated list to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure to it).
 Scheduler:
 toList does not operate by default on a particularScheduler.
 Returns:
 a Single that emits a single item: a List containing all of the items emitted by the source Publisher
 See Also:
 ReactiveX operators documentation: To
 - toList
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final 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.
 Normally, a Publisher that returns multiple items will do so by invoking itsSubscriber'sonNext method for each such item. You can change this behavior, instructing the Publisher to compose a list of all of these items and then to invoke the Subscriber'sonNext function once, passing it the entire list, by calling the Publisher'stoList method prior to calling itssubscribe() method.
 Note that this operator requires the upstream to signalonComplete for the accumulated list to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure to it).
 Scheduler:
 toList does not operate by default on a particularScheduler.
 Parameters:
 capacityHint - the number of elements expected from the current Flowable
 Returns:
 a Flowable that emits a single item: a List containing all of the items emitted by the source Publisher
 See Also:
 ReactiveX operators documentation: To
 - toList
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final > Single toList(Callable collectionSupplier)
```
 Returns a Single that emits a single item, a list composed of all the items emitted by the finite source Publisher.
 Normally, a Publisher that returns multiple items will do so by invoking itsSubscriber'sonNext method for each such item. You can change this behavior, instructing the Publisher to compose a list of all of these items and then to invoke the Subscriber'sonNext function once, passing it the entire list, by calling the Publisher'stoList method prior to calling itssubscribe() method.
 Note that this operator requires the upstream to signalonComplete for the accumulated collection to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure to it).
 Scheduler:
 toList does not operate by default on a particularScheduler.
 Type Parameters:
 U - the subclass of a collection of Ts
 Parameters:
 collectionSupplier - the Callable returning the collection (for each individual Subscriber) to be filled in
 Returns:
 a Single that emits a single item: a List containing all of the items emitted by the source Publisher
 See Also:
 ReactiveX operators documentation: To
 - toMap
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final <K> Single<Map<K,T>> toMap(Function<? superT,? 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 specifiedkeySelector function.
 If more than one source item maps to the same key, the HashMap will contain the latest of those items.
 Note that this operator requires the upstream to signalonComplete for the accumulated map to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure to it).
 Scheduler:
 toMap does not operate by default on a particularScheduler.
 Type Parameters:
 K - the key type of the Map
 Parameters:
 keySelector - the function that extracts the key from a source item to be used in the HashMap
 Returns:
 a Single that emits a single item: a HashMap containing the mapped items from the source Publisher
 See Also:
 ReactiveX operators documentation: To
 - toMap
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final <K,V> Single<Map<K,V>> toMap(Function<? superT,? extends K> keySelector,Function<? superT,? 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 specifiedkeySelector function.
 If more than one source item maps to the same key, the HashMap will contain a single entry that corresponds to the latest of those items.
 Note that this operator requires the upstream to signalonComplete for the accumulated map to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure to it).
 Scheduler:
 toMap does not operate by default on a particularScheduler.
 Type Parameters:
 K - the key type of the Map
 V - the value type of the Map
 Parameters:
 keySelector - the function that extracts the key from a source item to be used in the HashMap
 valueSelector - the function that extracts the value from a source item to be used in the HashMap
 Returns:
 a Single that emits a single item: a HashMap containing the mapped items from the source Publisher
 See Also:
 ReactiveX operators documentation: To
 - toMap
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final <K,V> Single<Map<K,V>> toMap(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector,Callable<? extendsMap<K,V>> mapSupplier)
```
 Returns a Single that emits a single Map, returned by a specifiedmapFactory function, that contains keys and values extracted from the items emitted by the finite source Publisher.
 Note that this operator requires the upstream to signalonComplete for the accumulated map to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure to it).
 Scheduler:
 toMap does not operate by default on a particularScheduler.
 Type Parameters:
 K - the key type of the Map
 V - the value type of the Map
 Parameters:
 keySelector - the function that extracts the key from a source item to be used in the Map
 valueSelector - the function that extracts the value from the source items to be used as value in the Map
 mapSupplier - the function that returns a Map instance to be used
 Returns:
 a Flowable that emits a single item: a Map that contains the mapped items emitted by the source Publisher
 See Also:
 ReactiveX operators documentation: To
 - toMultimap
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final <K> Single<Map<K,Collection<T>>> toMultimap(Function<? superT,? 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 specifiedkeySelector function.
 Note that this operator requires the upstream to signalonComplete for the accumulated map to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.
 Backpressure:
 This operator does not support backpressure as by intent it is requesting and buffering everything.
 Scheduler:
 toMultimap does not operate by default on a particularScheduler.
 Type Parameters:
 K - the key type of the Map
 Parameters:
 keySelector - the function that extracts the key from the source items to be used as key in the HashMap
 Returns:
 a Single that emits a single item: a HashMap that contains an ArrayList of items mapped from the source Publisher
 See Also:
 ReactiveX operators documentation: To
 - toMultimap
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final <K,V> Single<Map<K,Collection<V>>> toMultimap(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector)
```
 Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a specifiedvalueSelector function from items emitted by the finite source Publisher, keyed by a specifiedkeySelector function.
 Note that this operator requires the upstream to signalonComplete for the accumulated map to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure to it).
 Scheduler:
 toMultimap does not operate by default on a particularScheduler.
 Type Parameters:
 K - the key type of the Map
 V - the value type of the Map
 Parameters:
 keySelector - the function that extracts a key from the source items to be used as key in the HashMap
 valueSelector - the function that extracts a value from the source items to be used as value in the HashMap
 Returns:
 a Single that emits a single item: a HashMap that contains an ArrayList of items mapped from the source Publisher
 See Also:
 ReactiveX operators documentation: To
 - toMultimap
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final <K,V> Single<Map<K,Collection<V>>> toMultimap(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector,Callable<? extendsMap<K,Collection<V>>> mapSupplier,Function<? super K,? extendsCollection<? super V>> collectionFactory)
```
 Returns a Single that emits a single Map, returned by a specifiedmapFactory function, that contains a custom collection of values, extracted by a specifiedvalueSelector function from items emitted by the finite source Publisher, and keyed by thekeySelector function.
 Note that this operator requires the upstream to signalonComplete for the accumulated map to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure to it).
 Scheduler:
 toMultimap does not operate by default on a particularScheduler.
 Type Parameters:
 K - the key type of the Map
 V - the value type of the Map
 Parameters:
 keySelector - the function that extracts a key from the source items to be used as the key in the Map
 valueSelector - the function that extracts a value from the source items to be used as the value in the Map
 mapSupplier - the function that returns a Map instance to be used
 collectionFactory - the function that returns a Collection instance for a particular key to be used in the Map
 Returns:
 a Single that emits a single item: a Map that contains the collection of mapped items from the source Publisher
 See Also:
 ReactiveX operators documentation: To
 - toMultimap
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final <K,V> Single<Map<K,Collection<V>>> toMultimap(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector,Callable<Map<K,Collection<V>>> mapSupplier)
```
 Returns a Single that emits a single Map, returned by a specifiedmapFactory function, that contains an ArrayList of values, extracted by a specifiedvalueSelector function from items emitted by the finite source Publisher and keyed by thekeySelector function.
 Note that this operator requires the upstream to signalonComplete for the accumulated map to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure to it).
 Scheduler:
 toMultimap does not operate by default on a particularScheduler.
 Type Parameters:
 K - the key type of the Map
 V - the value type of the Map
 Parameters:
 keySelector - the function that extracts a key from the source items to be used as the key in the Map
 valueSelector - the function that extracts a value from the source items to be used as the value in the Map
 mapSupplier - the function that returns a Map instance to be used
 Returns:
 a Single that emits a single item: a Map that contains a list items mapped from the source Publisher
 See Also:
 ReactiveX operators documentation: To
 - toObservable
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final Observable<T> toObservable()
```
 Converts the current Flowable into a non-backpressuredObservable.
 Backpressure:
 Observables don't support backpressure thus the current Flowable is consumed in an unbounded manner (by requesting Long.MAX_VALUE).
 Scheduler:
 toObservable does not operate by default on a particularScheduler.
 Returns:
 the new Observable instance
 Since:
 2.0
 - toSortedList
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final 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. Each item emitted by the Publisher must implementComparable with respect to all other items in the sequence.
 If any item emitted by this Flowable does not implementComparable with respect to all other items emitted by this Flowable, no items will be emitted and the sequence is terminated with aClassCastException.
 Note that this operator requires the upstream to signalonComplete for the accumulated list to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure to it).
 Scheduler:
 toSortedList does not operate by default on a particularScheduler.
 Returns:
 a Single that emits a list that contains the items emitted by the source Publisher in sorted order
 See Also:
 ReactiveX operators documentation: To
 - toSortedList
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final Single<List<T>> toSortedList(Comparator<? superT> 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.
 Note that this operator requires the upstream to signalonComplete for the accumulated list to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure to it).
 Scheduler:
 toSortedList does not operate by default on a particularScheduler.
 Parameters:
 comparator - a function that compares two items emitted by the source Publisher and returns an Integer that indicates their sort order
 Returns:
 a Single that emits a list that contains the items emitted by the source Publisher in sorted order
 See Also:
 ReactiveX operators documentation: To
 - toSortedList
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final Single<List<T>> toSortedList(Comparator<? superT> 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.
 Note that this operator requires the upstream to signalonComplete for the accumulated list to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure to it).
 Scheduler:
 toSortedList does not operate by default on a particularScheduler.
 Parameters:
 comparator - a function that compares two items emitted by the source Publisher and returns an Integer that indicates their sort order
 capacityHint - the initial capacity of the ArrayList used to accumulate items before sorting
 Returns:
 a Single that emits a list that contains the items emitted by the source Publisher in sorted order
 Since:
 2.0
 See Also:
 ReactiveX operators documentation: To
 - toSortedList
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final 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. Each item emitted by the Publisher must implementComparable with respect to all other items in the sequence.
 If any item emitted by this Flowable does not implementComparable with respect to all other items emitted by this Flowable, no items will be emitted and the sequence is terminated with aClassCastException.
 Note that this operator requires the upstream to signalonComplete for the accumulated list to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.
 Backpressure:
 The operator honors backpressure from downstream and consumes the sourcePublisher in an unbounded manner (i.e., without applying backpressure to it).
 Scheduler:
 toSortedList does not operate by default on a particularScheduler.
 Parameters:
 capacityHint - the initial capacity of the ArrayList used to accumulate items before sorting
 Returns:
 a Flowable that emits a list that contains the items emitted by the source Publisher in sorted order
 Since:
 2.0
 See Also:
 ReactiveX operators documentation: To
 - unsubscribeOn
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="custom")public final Flowable<T> unsubscribeOn(Scheduler scheduler)
```
 Modifies the source Publisher so that subscribers will cancel it on a specifiedScheduler.
 Backpressure:
 The operator doesn't interfere with backpressure which is determined by the sourcePublisher's backpressure behavior.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 scheduler - theScheduler to perform cancellation actions on
 Returns:
 the source Publisher modified so that its cancellations happen on the specifiedScheduler
 See Also:
 ReactiveX operators documentation: SubscribeOn
 - window
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<Flowable<T>> window(long count)
```
 Returns a Flowable that emits windows of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping windows, each containingcount items. When the source Publisher completes or encounters an error, the resulting Publisher emits the current window and propagates the notification from the source Publisher.
 Backpressure:
 The operator honors backpressure of its inner and outer subscribers, however, the inner Publisher uses an unbounded buffer that may hold at mostcount elements.
 Scheduler:
 This version ofwindow does not operate by default on a particularScheduler.
 Parameters:
 count - the maximum size of each window before it should be emitted
 Returns:
 a Flowable that emits connected, non-overlapping windows, each containing at mostcount items from the source Publisher
 Throws:
 IllegalArgumentException - if either count is non-positive
 See Also:
 ReactiveX operators documentation: Window
 - window
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<Flowable<T>> window(long count, long skip)
```
 Returns a Flowable that emits windows of items it collects from the source Publisher. The resulting Publisher emits windows everyskip items, each containing no more thancount items. When the source Publisher completes or encounters an error, the resulting Publisher emits the current window and propagates the notification from the source Publisher.
 Backpressure:
 The operator honors backpressure of its inner and outer subscribers, however, the inner Publisher uses an unbounded buffer that may hold at mostcount elements.
 Scheduler:
 This version ofwindow does not operate by default on a particularScheduler.
 Parameters:
 count - the maximum size of each window before it should be emitted
 skip - how many items need to be skipped before starting a new window. Note that ifskip andcount are equal this is the same operation aswindow(long).
 Returns:
 a Flowable that emits windows everyskip items containing at mostcount items from the source Publisher
 Throws:
 IllegalArgumentException - if either count or skip is non-positive
 See Also:
 ReactiveX operators documentation: Window
 - window
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final Flowable<Flowable<T>> window(long count, long skip, int bufferSize)
```
 Returns a Flowable that emits windows of items it collects from the source Publisher. The resulting Publisher emits windows everyskip items, each containing no more thancount items. When the source Publisher completes or encounters an error, the resulting Publisher emits the current window and propagates the notification from the source Publisher.
 Backpressure:
 The operator honors backpressure of its inner and outer subscribers, however, the inner Publisher uses an unbounded buffer that may hold at mostcount elements.
 Scheduler:
 This version ofwindow does not operate by default on a particularScheduler.
 Parameters:
 count - the maximum size of each window before it should be emitted
 skip - how many items need to be skipped before starting a new window. Note that ifskip andcount are equal this is the same operation aswindow(long).
 bufferSize - the capacity hint for the buffer in the inner windows
 Returns:
 a Flowable that emits windows everyskip items containing at mostcount items from the source Publisher
 Throws:
 IllegalArgumentException - if either count or skip is non-positive
 See Also:
 ReactiveX operators documentation: Window
 - window
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="io.reactivex:computation")public final Flowable<Flowable<T>> window(long timespan, long timeskip,TimeUnit unit)
```
 Returns a Flowable that emits windows of items it collects from the source Publisher. The resulting Publisher starts a new window periodically, as determined by thetimeskip argument. It emits each window after a fixed timespan, specified by thetimespan argument. When the source Publisher completes or Publisher completes or encounters an error, the resulting Publisher emits the current window and propagates the notification from the source Publisher.
 Backpressure:
 The operator consumes the sourcePublisher in an unbounded manner. The returnedPublisher doesn't support backpressure as it uses time to control the creation of windows. The returned innerPublishers honor backpressure but have an unbounded inner buffer thatmay lead toOutOfMemoryError if left unconsumed.
 Scheduler:
 This version ofwindow operates by default on thecomputationScheduler.
 Parameters:
 timespan - the period of time each window collects items before it should be emitted
 timeskip - the period of time after which a new window will be created
 unit - the unit of time that applies to thetimespan andtimeskip arguments
 Returns:
 a Flowable that emits new windows periodically as a fixed timespan elapses
 See Also:
 ReactiveX operators documentation: Window
 - window
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="custom")public final 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. The resulting Publisher starts a new window periodically, as determined by thetimeskip argument. It emits each window after a fixed timespan, specified by thetimespan argument. When the source Publisher completes or Publisher completes or encounters an error, the resulting Publisher emits the current window and propagates the notification from the source Publisher.
 Backpressure:
 The operator consumes the sourcePublisher in an unbounded manner. The returnedPublisher doesn't support backpressure as it uses time to control the creation of windows. The returned innerPublishers honor backpressure but have an unbounded inner buffer thatmay lead toOutOfMemoryError if left unconsumed.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 timespan - the period of time each window collects items before it should be emitted
 timeskip - the period of time after which a new window will be created
 unit - the unit of time that applies to thetimespan andtimeskip arguments
 scheduler - theScheduler to use when determining the end and start of a window
 Returns:
 a Flowable that emits new windows periodically as a fixed timespan elapses
 See Also:
 ReactiveX operators documentation: Window
 - window
```
@CheckReturnValue@NonNull@BackpressureSupport(value=ERROR)@SchedulerSupport(value="custom")public final 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. The resulting Publisher starts a new window periodically, as determined by thetimeskip argument. It emits each window after a fixed timespan, specified by thetimespan argument. When the source Publisher completes or Publisher completes or encounters an error, the resulting Publisher emits the current window and propagates the notification from the source Publisher.
 Backpressure:
 The operator consumes the sourcePublisher in an unbounded manner. The returnedPublisher doesn't support backpressure as it uses time to control the creation of windows. The returned innerPublishers honor backpressure but have an unbounded inner buffer thatmay lead toOutOfMemoryError if left unconsumed.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 timespan - the period of time each window collects items before it should be emitted
 timeskip - the period of time after which a new window will be created
 unit - the unit of time that applies to thetimespan andtimeskip arguments
 scheduler - theScheduler to use when determining the end and start of a window
 bufferSize - the capacity hint for the buffer in the inner windows
 Returns:
 a Flowable that emits new windows periodically as a fixed timespan elapses
 See Also:
 ReactiveX operators documentation: Window
 - window
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="io.reactivex:computation")public final Flowable<Flowable<T>> window(long timespan,TimeUnit unit)
```
 Returns a Flowable that emits windows of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping windows, each of a fixed duration specified by thetimespan argument. When the source Publisher completes or encounters an error, the resulting Publisher emits the current window and propagates the notification from the source Publisher.
 Backpressure:
 The operator consumes the sourcePublisher in an unbounded manner. The returnedPublisher doesn't support backpressure as it uses time to control the creation of windows. The returned innerPublishers honor backpressure and may hold up tocount elements at most.
 Scheduler:
 This version ofwindow operates by default on thecomputationScheduler.
 Parameters:
 timespan - the period of time each window collects items before it should be emitted and replaced with a new window
 unit - the unit of time that applies to thetimespan argument
 Returns:
 a Flowable that emits connected, non-overlapping windows representing items emitted by the source Publisher during fixed, consecutive durations
 See Also:
 ReactiveX operators documentation: Window
 - window
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="io.reactivex:computation")public final Flowable<Flowable<T>> window(long timespan,TimeUnit unit, long count)
```
 Returns a Flowable that emits windows of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping windows, each of a fixed duration as specified by thetimespan argument or a maximum size as specified by thecount argument (whichever is reached first). When the source Publisher completes or encounters an error, the resulting Publisher emits the current window and propagates the notification from the source Publisher.
 Backpressure:
 The operator consumes the sourcePublisher in an unbounded manner. The returnedPublisher doesn't support backpressure as it uses time to control the creation of windows. The returned innerPublishers honor backpressure and may hold up tocount elements at most.
 Scheduler:
 This version ofwindow operates by default on thecomputationScheduler.
 Parameters:
 timespan - the period of time each window collects items before it should be emitted and replaced with a new window
 unit - the unit of time that applies to thetimespan argument
 count - the maximum size of each window before it should be emitted
 Returns:
 a Flowable that emits connected, non-overlapping windows of items from the source Publisher that were emitted during a fixed duration of time or when the window has reached maximum capacity (whichever occurs first)
 See Also:
 ReactiveX operators documentation: Window
 - window
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="io.reactivex:computation")public final 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. The resulting Publisher emits connected, non-overlapping windows, each of a fixed duration as specified by thetimespan argument or a maximum size as specified by thecount argument (whichever is reached first). When the source Publisher completes or encounters an error, the resulting Publisher emits the current window and propagates the notification from the source Publisher.
 Backpressure:
 The operator consumes the sourcePublisher in an unbounded manner. The returnedPublisher doesn't support backpressure as it uses time to control the creation of windows. The returned innerPublishers honor backpressure and may hold up tocount elements at most.
 Scheduler:
 This version ofwindow operates by default on thecomputationScheduler.
 Parameters:
 timespan - the period of time each window collects items before it should be emitted and replaced with a new window
 unit - the unit of time that applies to thetimespan argument
 count - the maximum size of each window before it should be emitted
 restart - if true, when a window reaches the capacity limit, the timer is restarted as well
 Returns:
 a Flowable that emits connected, non-overlapping windows of items from the source Publisher that were emitted during a fixed duration of time or when the window has reached maximum capacity (whichever occurs first)
 See Also:
 ReactiveX operators documentation: Window
 - window
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="custom")public final Flowable<Flowable<T>> window(long timespan,TimeUnit unit,Scheduler scheduler)
```
 Returns a Flowable that emits windows of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping windows, each of a fixed duration as specified by thetimespan argument. When the source Publisher completes or encounters an error, the resulting Publisher emits the current window and propagates the notification from the source Publisher.
 Backpressure:
 The operator consumes the sourcePublisher in an unbounded manner. The returnedPublisher doesn't support backpressure as it uses time to control the creation of windows. The returned innerPublishers honor backpressure but have an unbounded inner buffer thatmay lead toOutOfMemoryError if left unconsumed.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 timespan - the period of time each window collects items before it should be emitted and replaced with a new window
 unit - the unit of time which applies to thetimespan argument
 scheduler - theScheduler to use when determining the end and start of a window
 Returns:
 a Flowable that emits connected, non-overlapping windows containing items emitted by the source Publisher within a fixed duration
 See Also:
 ReactiveX operators documentation: Window
 - window
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="custom")public final 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. The resulting Publisher emits connected, non-overlapping windows, each of a fixed duration specified by thetimespan argument or a maximum size specified by thecount argument (whichever is reached first). When the source Publisher completes or encounters an error, the resulting Publisher emits the current window and propagates the notification from the source Publisher.
 Backpressure:
 The operator consumes the sourcePublisher in an unbounded manner. The returnedPublisher doesn't support backpressure as it uses time to control the creation of windows. The returned innerPublishers honor backpressure and may hold up tocount elements at most.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 timespan - the period of time each window collects items before it should be emitted and replaced with a new window
 unit - the unit of time which applies to thetimespan argument
 count - the maximum size of each window before it should be emitted
 scheduler - theScheduler to use when determining the end and start of a window
 Returns:
 a Flowable that emits connected, non-overlapping windows of items from the source Publisher that were emitted during a fixed duration of time or when the window has reached maximum capacity (whichever occurs first)
 See Also:
 ReactiveX operators documentation: Window
 - window
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="custom")public final 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. The resulting Publisher emits connected, non-overlapping windows, each of a fixed duration specified by thetimespan argument or a maximum size specified by thecount argument (whichever is reached first). When the source Publisher completes or encounters an error, the resulting Publisher emits the current window and propagates the notification from the source Publisher.
 Backpressure:
 The operator consumes the sourcePublisher in an unbounded manner. The returnedPublisher doesn't support backpressure as it uses time to control the creation of windows. The returned innerPublishers honor backpressure and may hold up tocount elements at most.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 timespan - the period of time each window collects items before it should be emitted and replaced with a new window
 unit - the unit of time which applies to thetimespan argument
 count - the maximum size of each window before it should be emitted
 scheduler - theScheduler to use when determining the end and start of a window
 restart - if true, when a window reaches the capacity limit, the timer is restarted as well
 Returns:
 a Flowable that emits connected, non-overlapping windows of items from the source Publisher that were emitted during a fixed duration of time or when the window has reached maximum capacity (whichever occurs first)
 See Also:
 ReactiveX operators documentation: Window
 - window
```
@CheckReturnValue@NonNull@BackpressureSupport(value=ERROR)@SchedulerSupport(value="custom")public final 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. The resulting Publisher emits connected, non-overlapping windows, each of a fixed duration specified by thetimespan argument or a maximum size specified by thecount argument (whichever is reached first). When the source Publisher completes or encounters an error, the resulting Publisher emits the current window and propagates the notification from the source Publisher.
 Backpressure:
 The operator consumes the sourcePublisher in an unbounded manner. The returnedPublisher doesn't support backpressure as it uses time to control the creation of windows. The returned innerPublishers honor backpressure and may hold up tocount elements at most.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 timespan - the period of time each window collects items before it should be emitted and replaced with a new window
 unit - the unit of time which applies to thetimespan argument
 count - the maximum size of each window before it should be emitted
 scheduler - theScheduler to use when determining the end and start of a window
 restart - if true, when a window reaches the capacity limit, the timer is restarted as well
 bufferSize - the capacity hint for the buffer in the inner windows
 Returns:
 a Flowable that emits connected, non-overlapping windows of items from the source Publisher that were emitted during a fixed duration of time or when the window has reached maximum capacity (whichever occurs first)
 See Also:
 ReactiveX operators documentation: Window
 - window
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="none")public final  Flowable<Flowable<T>> window(Publisher 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.
 Backpressure:
 The outer Publisher of this operator does not support backpressure as it uses aboundary Publisher to control data flow. The inner Publishers honor backpressure and buffer everything until the boundary signals the next element.
 Scheduler:
 This version ofwindow does not operate by default on a particularScheduler.
 Type Parameters:
 B - the window element type (ignored)
 Parameters:
 boundaryIndicator - a Publisher whose emitted items close and open windows
 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 theboundary Publisher
 See Also:
 ReactiveX operators documentation: Window
 - window
```
@CheckReturnValue@NonNull@BackpressureSupport(value=ERROR)@SchedulerSupport(value="none")public final  Flowable<Flowable<T>> window(Publisher 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.
 Backpressure:
 The outer Publisher of this operator does not support backpressure as it uses aboundary Publisher to control data flow. The inner Publishers honor backpressure and buffer everything until the boundary signals the next element.
 Scheduler:
 This version ofwindow does not operate by default on a particularScheduler.
 Type Parameters:
 B - the window element type (ignored)
 Parameters:
 boundaryIndicator - a Publisher whose emitted items close and open windows
 bufferSize - the capacity hint for the buffer in the inner windows
 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 theboundary Publisher
 See Also:
 ReactiveX operators documentation: Window
 - window
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="none")public final <U,V> Flowable<Flowable<T>> window(Publisher openingIndicator,Function<? super U,? extendsPublisher<V>> closingIndicator)
```
 Returns a Flowable that emits windows of items it collects from the source Publisher. The resulting Publisher emits windows that contain those items emitted by the source Publisher between the time when thewindowOpenings Publisher emits an item and when the Publisher returned byclosingSelector emits an item.
 Backpressure:
 The outer Publisher of this operator doesn't support backpressure because the emission of new inner Publishers are controlled by thewindowOpenings Publisher. The inner Publishers honor backpressure and buffer everything until the associated closing Publisher signals or completes.
 Scheduler:
 This version ofwindow does not operate by default on a particularScheduler.
 Type Parameters:
 U - the element type of the window-opening Publisher
 V - the element type of the window-closing Publishers
 Parameters:
 openingIndicator - a Publisher that, when it emits an item, causes another window to be created
 closingIndicator - aFunction that produces a Publisher for every window created. When this Publisher emits an item, the associated window is closed and emitted
 Returns:
 a Flowable that emits windows of items emitted by the source Publisher that are governed by the specified window-governing Publishers
 See Also:
 ReactiveX operators documentation: Window
 - window
```
@CheckReturnValue@NonNull@BackpressureSupport(value=ERROR)@SchedulerSupport(value="none")public final <U,V> Flowable<Flowable<T>> window(Publisher openingIndicator,Function<? super U,? extendsPublisher<V>> closingIndicator, int bufferSize)
```
 Returns a Flowable that emits windows of items it collects from the source Publisher. The resulting Publisher emits windows that contain those items emitted by the source Publisher between the time when thewindowOpenings Publisher emits an item and when the Publisher returned byclosingSelector emits an item.
 Backpressure:
 The outer Publisher of this operator doesn't support backpressure because the emission of new inner Publishers are controlled by thewindowOpenings Publisher. The inner Publishers honor backpressure and buffer everything until the associated closing Publisher signals or completes.
 Scheduler:
 This version ofwindow does not operate by default on a particularScheduler.
 Type Parameters:
 U - the element type of the window-opening Publisher
 V - the element type of the window-closing Publishers
 Parameters:
 openingIndicator - a Publisher that, when it emits an item, causes another window to be created
 closingIndicator - aFunction that produces a Publisher for every window created. When this Publisher emits an item, the associated window is closed and emitted
 bufferSize - the capacity hint for the buffer in the inner windows
 Returns:
 a Flowable that emits windows of items emitted by the source Publisher that are governed by the specified window-governing Publishers
 See Also:
 ReactiveX operators documentation: Window
 - window
```
@CheckReturnValue@BackpressureSupport(value=ERROR)@SchedulerSupport(value="none")public final  Flowable<Flowable<T>> window(Callable<? extendsPublisher> boundaryIndicatorSupplier)
```
 Returns a Flowable that emits windows of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping windows. It emits the current window and opens a new one whenever the Publisher produced by the specifiedclosingSelector emits an item.
 Backpressure:
 The operator consumes the sourcePublisher in an unbounded manner. The returnedPublisher doesn't support backpressure as it uses theclosingSelector to control the creation of windows. The returned innerPublishers honor backpressure but have an unbounded inner buffer thatmay lead toOutOfMemoryError if left unconsumed.
 Scheduler:
 This version ofwindow does not operate by default on a particularScheduler.
 Type Parameters:
 B - the element type of the boundary Publisher
 Parameters:
 boundaryIndicatorSupplier - aCallable that returns aPublisher that governs the boundary between windows. When the sourcePublisher emits an item,window emits the current window and begins a new one.
 Returns:
 a Flowable that emits connected, non-overlapping windows of items from the source Publisher wheneverclosingSelector emits an item
 See Also:
 ReactiveX operators documentation: Window
 - window
```
@CheckReturnValue@NonNull@BackpressureSupport(value=ERROR)@SchedulerSupport(value="none")public final  Flowable<Flowable<T>> window(Callable<? extendsPublisher> boundaryIndicatorSupplier, int bufferSize)
```
 Returns a Flowable that emits windows of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping windows. It emits the current window and opens a new one whenever the Publisher produced by the specifiedclosingSelector emits an item.
 Backpressure:
 The operator consumes the sourcePublisher in an unbounded manner. The returnedPublisher doesn't support backpressure as it uses theclosingSelector to control the creation of windows. The returned innerPublishers honor backpressure but have an unbounded inner buffer thatmay lead toOutOfMemoryError if left unconsumed.
 Scheduler:
 This version ofwindow does not operate by default on a particularScheduler.
 Type Parameters:
 B - the element type of the boundary Publisher
 Parameters:
 boundaryIndicatorSupplier - aCallable that returns aPublisher that governs the boundary between windows. When the sourcePublisher emits an item,window emits the current window and begins a new one.
 bufferSize - the capacity hint for the buffer in the inner windows
 Returns:
 a Flowable that emits connected, non-overlapping windows of items from the source Publisher wheneverclosingSelector emits an item
 See Also:
 ReactiveX operators documentation: Window
 - withLatestFrom
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final <U,R> Flowable<R> withLatestFrom(Publisher<? extends U> other,BiFunction<? superT,? super U,? extends R> combiner)
```
 Merges the specified Publisher into this Publisher sequence by using theresultSelector function only when the source Publisher (this instance) emits an item.
 Backpressure:
 The operator is a pass-through for backpressure: the backpressure support depends on the upstream and downstream's backpressure behavior. The other Publisher is consumed in an unbounded fashion.
 Scheduler:
 This operator, by default, doesn't run any particularScheduler.
 Type Parameters:
 U - the element type of the other Publisher
 R - the result type of the combination
 Parameters:
 other - the other Publisher
 combiner - the function to call when this Publisher emits an item and the other Publisher has already emitted an item, to generate the item to be emitted by the resulting Publisher
 Returns:
 a Flowable that merges the specified Publisher into this Publisher by using theresultSelector function only when the source Publisher sequence (this instance) emits an item
 Since:
 2.0
 See Also:
 ReactiveX operators documentation: CombineLatest
 - withLatestFrom
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final <T1,T2,R> Flowable<R> withLatestFrom(Publisher<T1> source1,Publisher<T2> source2,Function3<? superT,? 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.
 Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when this Publisher emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately.
 Backpressure:
 This operator is a pass-through for backpressure behavior between the sourcePublisher and the downstream Subscriber. The otherPublishers are consumed in an unbounded manner.
 Scheduler:
 This operator does not operate by default on a particularScheduler.
 Type Parameters:
 T1 - the first other source's value type
 T2 - the second other source's value type
 R - the result value type
 Parameters:
 source1 - the first other Publisher
 source2 - the second other Publisher
 combiner - the function called with an array of values from each participating Publisher
 Returns:
 the new Publisher instance
 Since:
 2.0
 - withLatestFrom
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final <T1,T2,T3,R> Flowable<R> withLatestFrom(Publisher<T1> source1,Publisher<T2> source2,Publisher<T3> source3,Function4<? superT,? 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.
 Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when this Publisher emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately.
 Backpressure:
 This operator is a pass-through for backpressure behavior between the sourcePublisher and the downstream Subscriber. The otherPublishers are consumed in an unbounded manner.
 Scheduler:
 This operator does not operate by default on a particularScheduler.
 Type Parameters:
 T1 - the first other source's value type
 T2 - the second other source's value type
 T3 - the third other source's value type
 R - the result value type
 Parameters:
 source1 - the first other Publisher
 source2 - the second other Publisher
 source3 - the third other Publisher
 combiner - the function called with an array of values from each participating Publisher
 Returns:
 the new Publisher instance
 Since:
 2.0
 - withLatestFrom
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final <T1,T2,T3,T4,R> Flowable<R> withLatestFrom(Publisher<T1> source1,Publisher<T2> source2,Publisher<T3> source3,Publisher<T4> source4,Function5<? superT,? 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.
 Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when this Publisher emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately.
 Backpressure:
 This operator is a pass-through for backpressure behavior between the sourcePublisher and the downstream Subscriber. The otherPublishers are consumed in an unbounded manner.
 Scheduler:
 This operator does not operate by default on a particularScheduler.
 Type Parameters:
 T1 - the first other source's value type
 T2 - the second other source's value type
 T3 - the third other source's value type
 T4 - the fourth other source's value type
 R - the result value type
 Parameters:
 source1 - the first other Publisher
 source2 - the second other Publisher
 source3 - the third other Publisher
 source4 - the fourth other Publisher
 combiner - the function called with an array of values from each participating Publisher
 Returns:
 the new Publisher instance
 Since:
 2.0
 - withLatestFrom
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final <R> Flowable<R> withLatestFrom(Publisher<?>[] others,Function<? superObject[],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.
 Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when this Publisher emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately.
 Backpressure:
 This operator is a pass-through for backpressure behavior between the sourcePublisher and the downstream Subscriber. The otherPublishers are consumed in an unbounded manner.
 Scheduler:
 This operator does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result value type
 Parameters:
 others - the array of other sources
 combiner - the function called with an array of values from each participating Publisher
 Returns:
 the new Publisher instance
 Since:
 2.0
 - withLatestFrom
```
@CheckReturnValue@NonNull@BackpressureSupport(value=PASS_THROUGH)@SchedulerSupport(value="none")public final <R> Flowable<R> withLatestFrom(Iterable<? extendsPublisher<?>> others,Function<? superObject[],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.
 Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when this Publisher emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately.
 Backpressure:
 This operator is a pass-through for backpressure behavior between the sourcePublisher and the downstream Subscriber. The otherPublishers are consumed in an unbounded manner.
 Scheduler:
 This operator does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result value type
 Parameters:
 others - the iterable of other sources
 combiner - the function called with an array of values from each participating Publisher
 Returns:
 the new Publisher instance
 Since:
 2.0
 - zipWith
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <U,R> Flowable<R> zipWith(Iterable other,BiFunction<? superT,? 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.
 Note that theother Iterable is evaluated as items are observed from the source Publisher; it is not pre-consumed. This allows you to zip infinite streams on either side.
 Backpressure:
 The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping withinterval(long, TimeUnit) may result in MissingBackpressureException, use one of theonBackpressureX to handle similar, backpressure-ignoring sources.
 Scheduler:
 zipWith does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of items in theother Iterable
 R - the type of items emitted by the resulting Publisher
 Parameters:
 other - the Iterable sequence
 zipper - a function that combines the pairs of items from the Publisher and the Iterable to generate the items to be emitted by the resulting Publisher
 Returns:
 a Flowable that pairs up values from the source Publisher and theother Iterable sequence and emits the results ofzipFunction applied to these pairs
 See Also:
 ReactiveX operators documentation: Zip
 - zipWith
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <U,R> Flowable<R> zipWith(Publisher<? extends U> other,BiFunction<? superT,? 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.
 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 callingdoOnComplete()). 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:
```
range(1, 5).doOnComplete(action1).zipWith(range(6, 5).doOnComplete(action2), (a, b) -> a + b)
```
 action1 will be called butaction2 won't.
 To work around this termination property, usedoOnCancel(Action) as well or useusing() 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 withinterval(long, TimeUnit) may result in MissingBackpressureException, use one of theonBackpressureX to handle similar, backpressure-ignoring sources.
 Scheduler:
 zipWith does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of items emitted by theother Publisher
 R - the type of items emitted by the resulting Publisher
 Parameters:
 other - the other Publisher
 zipper - a function that combines the pairs of items from the two Publishers to generate the items to be emitted by the resulting Publisher
 Returns:
 a Flowable that pairs up values from the source Publisher and theother Publisher and emits the results ofzipFunction applied to these pairs
 See Also:
 ReactiveX operators documentation: Zip
 - zipWith
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <U,R> Flowable<R> zipWith(Publisher<? extends U> other,BiFunction<? superT,? 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.
 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 callingdoOnComplete()). 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:
```
range(1, 5).doOnComplete(action1).zipWith(range(6, 5).doOnComplete(action2), (a, b) -> a + b)
```
 action1 will be called butaction2 won't.
 To work around this termination property, usedoOnCancel(Action) as well or useusing() 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 withinterval(long, TimeUnit) may result in MissingBackpressureException, use one of theonBackpressureX to handle similar, backpressure-ignoring sources.
 Scheduler:
 zipWith does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of items emitted by theother Publisher
 R - the type of items emitted by the resulting Publisher
 Parameters:
 other - the other Publisher
 zipper - a function that combines the pairs of items from the two Publishers to generate the items to be emitted by the resulting Publisher
 delayError - if true, errors from the current Flowable or the other Publisher is delayed until both terminate
 Returns:
 a Flowable that pairs up values from the source Publisher and theother Publisher and emits the results ofzipFunction applied to these pairs
 Since:
 2.0
 See Also:
 ReactiveX operators documentation: Zip
 - zipWith
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <U,R> Flowable<R> zipWith(Publisher<? extends U> other,BiFunction<? superT,? 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.
 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 callingdoOnComplete()). 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:
```
range(1, 5).doOnComplete(action1).zipWith(range(6, 5).doOnComplete(action2), (a, b) -> a + b)
```
 action1 will be called butaction2 won't.
 To work around this termination property, usedoOnCancel(Action) as well or useusing() 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 withinterval(long, TimeUnit) may result in MissingBackpressureException, use one of theonBackpressureX to handle similar, backpressure-ignoring sources.
 Scheduler:
 zipWith does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of items emitted by theother Publisher
 R - the type of items emitted by the resulting Publisher
 Parameters:
 other - the other Publisher
 zipper - a function that combines the pairs of items from the two Publishers to generate the items to be emitted by the resulting Publisher
 bufferSize - the capacity hint for the buffer in the inner windows
 delayError - if true, errors from the current Flowable or the other Publisher is delayed until both terminate
 Returns:
 a Flowable that pairs up values from the source Publisher and theother Publisher and emits the results ofzipFunction applied to these pairs
 Since:
 2.0
 See Also:
 ReactiveX operators documentation: Zip
 - test
```
@CheckReturnValue@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public final TestSubscriber<T> test()
```
 Creates a TestSubscriber that requests Long.MAX_VALUE and subscribes it to this Flowable.
 Backpressure:
 The returned TestSubscriber consumes this Flowable in an unbounded fashion.
 Scheduler:
 test does not operate by default on a particularScheduler.
 Returns:
 the new TestSubscriber instance
 Since:
 2.0
 - test
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final TestSubscriber<T> test(long initialRequest)
```
 Creates a TestSubscriber with the given initial request amount and subscribes it to this Flowable.
 Backpressure:
 The returned TestSubscriber requests the giveninitialRequest amount upfront.
 Scheduler:
 test does not operate by default on a particularScheduler.
 Parameters:
 initialRequest - the initial request amount, positive
 Returns:
 the new TestSubscriber instance
 Since:
 2.0
 - test
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final 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.
 Backpressure:
 The returned TestSubscriber requests the giveninitialRequest amount upfront.
 Scheduler:
 test does not operate by default on a particularScheduler.
 Parameters:
 initialRequest - the initial request amount, positive
 cancel - should the TestSubscriber be canceled before the subscription?
 Returns:
 the new TestSubscriber instance
 Since:
 2.0

Movatterモバイル変換

Class Flowable<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Flowable

Method Detail

amb

ambArray

bufferSize

combineLatest

combineLatest

combineLatest

combineLatest

combineLatest

combineLatestDelayError

combineLatestDelayError

combineLatestDelayError

combineLatestDelayError

combineLatestDelayError

combineLatestDelayError

combineLatest

combineLatest

combineLatest

combineLatest

combineLatest

combineLatest

combineLatest

combineLatest

concat

concat

concat

concat

concat

concat

concatArray

concatArrayDelayError

concatArrayEager

concatArrayEager

concatArrayEagerDelayError

concatArrayEagerDelayError

concatDelayError

concatDelayError

concatDelayError

concatEager

concatEager

concatEager

concatEager

create

defer

empty

error

error

fromArray

fromCallable

fromFuture

fromFuture

fromFuture

fromFuture

fromIterable

fromPublisher

generate

generate

generate

generate

generate

interval

interval

interval

interval

intervalRange

intervalRange

just

just

just

just

just

just

just