GroupedFlowable

extends Flowable<T>

java.lang.Object
↳	io.reactivex.Flowable<T>
	↳	io.reactivex.flowables.GroupedFlowable<K, T>

Class Overview

A Flowable that has been grouped by key, the value of which can be obtained with getKey().

Note: A GroupedFlowable 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 those GroupedObservables that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator like take(0) to them.

Summary

Protected Constructors
	GroupedFlowable(K key) Constructs a GroupedFlowable with the given key.

Public Methods
K	getKey() Returns the key that identifies the group of items emitted by this `GroupedObservable`.

[Expand]

Inherited Methods

From class io.reactivex.Flowable

final Single<Boolean>	all(Predicate<? super T> predicate) Returns a Single that emits a Boolean that indicates whether all of the items emitted by the source Publisher satisfy a condition.
static <T> Flowable<T>	amb(Iterable<? extends Publisher<? extends T>> sources) Mirrors the one Publisher in an Iterable of several Publishers that first either emits an item or sends a termination notification.
static <T> Flowable<T>	ambArray(Publisher...<? extends T> sources) Mirrors the one Publisher in an array of several Publishers that first either emits an item or sends a termination notification.
final Flowable<T>	ambWith(Publisher<? extends T> other) Mirrors the Publisher (current or provided) that first either emits an item or sends a termination notification.
final Single<Boolean>	any(Predicate<? super T> predicate) Returns a Single that emits `true` if any item emitted by the source Publisher satisfies a specified condition, otherwise `false`.
final T	blockingFirst(T defaultItem) Returns the first item emitted by this `Flowable`, or a default value if it emits no items.
final T	blockingFirst() Returns the first item emitted by this `Flowable`, or throws `NoSuchElementException` if it emits no items.
final void	blockingForEach(Consumer<? super T> onNext) Invokes a method on each item emitted by this `Flowable` and blocks until the Flowable completes.
final Iterable<T>	blockingIterable(int bufferSize) Converts this `Flowable` into an `Iterable`.
final Iterable<T>	blockingIterable() Converts this `Flowable` into an `Iterable`.
final T	blockingLast() Returns the last item emitted by this `Flowable`, or throws `NoSuchElementException` if this `Flowable` emits no items.
final T	blockingLast(T defaultItem) Returns the last item emitted by this `Flowable`, or a default value if it emits no items.
final Iterable<T>	blockingLatest() Returns an `Iterable` that returns the latest item emitted by this `Flowable`, waiting if necessary for one to become available.
final Iterable<T>	blockingMostRecent(T initialItem) Returns an `Iterable` that always returns the item most recently emitted by this `Flowable`.
final Iterable<T>	blockingNext() Returns an `Iterable` that blocks until this `Flowable` emits another item, then returns that item.
final 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.
final T	blockingSingle() If this `Flowable` completes after emitting a single item, return that item, otherwise throw a `NoSuchElementException`.
final void	blockingSubscribe(Consumer<? super T> onNext) Subscribes to the source and calls the given callbacks on the current thread.
final void	blockingSubscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) Subscribes to the source and calls the given callbacks on the current thread.
final void	blockingSubscribe() Runs the source observable to a terminal event, ignoring any values and rethrowing any exception.
final void	blockingSubscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) Subscribes to the source and calls the given callbacks on the current thread.
final void	blockingSubscribe(Subscriber<? super T> subscriber) Subscribes to the source and calls the Subscriber methods on the current thread.
final <U extends Collection<? super T>> Flowable<U>	buffer(long timespan, long timeskip, TimeUnit unit, Scheduler scheduler, Callable<U> bufferSupplier) Returns a Flowable that emits buffers of items it collects from the source Publisher.
final <B> Flowable<List<T>>	buffer(Callable<? extends Publisher<B>> boundaryIndicatorSupplier) Returns a Flowable that emits buffers of items it collects from the source Publisher.
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.
final <U extends Collection<? super T>> Flowable<U>	buffer(int count, Callable<U> bufferSupplier) Returns a Flowable that emits buffers of items it collects from the source Publisher.
final <B, U extends Collection<? super T>> Flowable<U>	buffer(Publisher<B> boundaryIndicator, Callable<U> bufferSupplier) Returns a Flowable that emits non-overlapping buffered items from the source Publisher each time the specified boundary Publisher emits an item.
final <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.
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.
final Flowable<List<T>>	buffer(int count) Returns a Flowable that emits buffers of items it collects from the source Publisher.
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.
final <TOpening, TClosing> Flowable<List<T>>	buffer(Flowable<? extends TOpening> openingIndicator, Function<? super TOpening, ? extends Publisher<? extends TClosing>> closingIndicator) Returns a Flowable that emits buffers of items it collects from the source Publisher.
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.
final Flowable<List<T>>	buffer(long timespan, TimeUnit unit) Returns a Flowable that emits buffers of items it collects from the source Publisher.
final <U extends Collection<? super T>> Flowable<U>	buffer(long timespan, TimeUnit unit, Scheduler scheduler, int count, Callable<U> bufferSupplier, boolean restartTimerOnMaxSize) Returns a Flowable that emits buffers of items it collects from the source Publisher.
final Flowable<List<T>>	buffer(int count, int skip) Returns a Flowable that emits buffers of items it collects from the source Publisher.
final <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.
final <TOpening, TClosing, U extends Collection<? super T>> Flowable<U>	buffer(Flowable<? extends TOpening> openingIndicator, Function<? super TOpening, ? extends Publisher<? extends TClosing>> closingIndicator, Callable<U> bufferSupplier) Returns a Flowable that emits buffers of items it collects from the source Publisher.
final <B, U extends Collection<? super T>> Flowable<U>	buffer(Callable<? extends Publisher<B>> boundaryIndicatorSupplier, Callable<U> bufferSupplier) Returns a Flowable that emits buffers of items it collects from the source Publisher.
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.
final <U extends Collection<? super T>> Flowable<U>	buffer(int count, int skip, Callable<U> bufferSupplier) Returns a Flowable that emits buffers of items it collects from the source Publisher.
static int	bufferSize() Returns the default internal buffer size used by most async operators.
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.
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.
final <U> Flowable<U>	cast(Class<U> clazz) Returns a Flowable that emits the items emitted by the source Publisher, converted to the specified type.
final <U> Single<U>	collect(Callable<? extends U> initialItemSupplier, BiConsumer<? super U, ? super T> collector) Collects items emitted by the source Publisher into a single mutable data structure and returns a Single that emits this structure.
final <U> Single<U>	collectInto(U initialItem, BiConsumer<? super U, ? super T> collector) Collects items emitted by the source Publisher into a single mutable data structure and returns a Single that emits this structure.
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>	combineLatest(Publisher[]<? extends T> sources, Function<? super Object[], ? extends R> combiner) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <T, R> Flowable<R>	combineLatest(Iterable<? extends Publisher<? extends T>> sources, Function<? super Object[], ? extends R> combiner) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <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, 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 <T, R> Flowable<R>	combineLatest(Publisher[]<? extends T> sources, Function<? super Object[], ? extends R> combiner, int bufferSize) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <T, R> Flowable<R>	combineLatest(Function<? super Object[], ? extends R> combiner, Publisher...<? extends T> sources) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <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 <T, R> Flowable<R>	combineLatest(Iterable<? extends Publisher<? extends T>> sources, Function<? super Object[], ? extends R> combiner, int bufferSize) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <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 <T, R> Flowable<R>	combineLatestDelayError(Function<? super Object[], ? extends R> combiner, int bufferSize, Publisher...<? extends T> sources) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publisher, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
static <T, R> Flowable<R>	combineLatestDelayError(Publisher[]<? extends T> sources, Function<? super Object[], ? extends R> combiner) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <T, R> Flowable<R>	combineLatestDelayError(Publisher[]<? extends T> sources, Function<? super Object[], ? extends R> combiner, int bufferSize) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
static <T, R> Flowable<R>	combineLatestDelayError(Iterable<? extends Publisher<? extends T>> sources, Function<? super Object[], ? extends R> combiner) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
static <T, R> Flowable<R>	combineLatestDelayError(Iterable<? extends Publisher<? extends T>> sources, Function<? super Object[], ? extends R> combiner, int bufferSize) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
static <T, R> Flowable<R>	combineLatestDelayError(Function<? super Object[], ? extends R> combiner, Publisher...<? extends T> sources) Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
final <R> Flowable<R>	compose(FlowableTransformer<? super T, ? extends R> composer) Transform a Publisher by applying a particular Transformer function to it.
static <T> Flowable<T>	concat(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(Iterable<? extends Publisher<? extends T>> sources) Concatenates elements of each Publisher provided via an Iterable sequence into a single sequence of elements without interleaving them.
static <T> Flowable<T>	concat(Publisher<? extends 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>	concat(Publisher<? extends Publisher<? extends T>> sources, int prefetch) Returns a Flowable that emits the items emitted by each of the Publishers emitted by the source Publisher, one after the other, without interleaving them.
static <T> Flowable<T>	concat(Publisher<? extends Publisher<? extends T>> sources) Returns a Flowable that emits the items emitted by each of the Publishers emitted by the source Publisher, one after the other, without interleaving them.
static <T> Flowable<T>	concat(Publisher<? extends 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>	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 a sequence of Publishers eagerly into a single stream of values.
static <T> Flowable<T>	concatArrayEager(Publisher...<? extends T> sources) Concatenates a sequence of Publishers eagerly into a single stream of values.
static <T> Flowable<T>	concatDelayError(Publisher<? extends Publisher<? extends T>> sources, int prefetch, boolean tillTheEnd) Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher, one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate.
static <T> Flowable<T>	concatDelayError(Iterable<? extends Publisher<? extends T>> sources) Concatenates the Iterable sequence of Publishers into a single sequence by subscribing to each Publisher, one after the other, one at a time and delays any errors till the all inner Publishers terminate.
static <T> Flowable<T>	concatDelayError(Publisher<? extends Publisher<? extends T>> sources) Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher, one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate.
static <T> Flowable<T>	concatEager(Iterable<? extends Publisher<? extends T>> sources) Concatenates a sequence of Publishers eagerly into a single stream of values.
static <T> Flowable<T>	concatEager(Publisher<? extends Publisher<? extends T>> sources, int maxConcurrency, int prefetch) Concatenates a Publisher sequence of Publishers eagerly into a single stream of values.
static <T> Flowable<T>	concatEager(Publisher<? extends Publisher<? extends T>> sources) Concatenates a Publisher sequence of Publishers eagerly into a single stream of values.
static <T> Flowable<T>	concatEager(Iterable<? extends Publisher<? extends T>> sources, int maxConcurrency, int prefetch) Concatenates a sequence of Publishers eagerly into a single stream of values.
final <R> Flowable<R>	concatMap(Function<? super T, ? extends Publisher<? extends R>> mapper, int prefetch) Returns a new Flowable that emits items resulting from applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then emitting the items that result from concatenating those resulting Publishers.
final <R> Flowable<R>	concatMap(Function<? super T, ? extends Publisher<? extends R>> mapper) Returns a new Flowable that emits items resulting from applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then emitting the items that result from concatenating those resulting Publishers.
final <R> Flowable<R>	concatMapDelayError(Function<? super T, ? extends Publisher<? extends R>> mapper, int prefetch, boolean tillTheEnd) Maps each of the items into a Publisher, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner Publishers till all of them terminate.
final <R> Flowable<R>	concatMapDelayError(Function<? super T, ? extends Publisher<? extends R>> mapper) Maps each of the items into a Publisher, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner Publishers till all of them terminate.
final <R> Flowable<R>	concatMapEager(Function<? super T, ? extends Publisher<? extends R>> mapper) Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
final <R> Flowable<R>	concatMapEager(Function<? super T, ? extends Publisher<? extends R>> mapper, int maxConcurrency, int prefetch) Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
final <R> Flowable<R>	concatMapEagerDelayError(Function<? super T, ? extends Publisher<? extends R>> mapper, boolean tillTheEnd) Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
final <R> Flowable<R>	concatMapEagerDelayError(Function<? super T, ? extends Publisher<? extends R>> mapper, int maxConcurrency, int prefetch, boolean tillTheEnd) Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
final <U> Flowable<U>	concatMapIterable(Function<? super T, ? extends Iterable<? extends U>> mapper) Returns a Flowable that concatenate each item emitted by the source Publisher with the values in an Iterable corresponding to that item that is generated by a selector.
final <U> Flowable<U>	concatMapIterable(Function<? super T, ? extends Iterable<? extends U>> mapper, int prefetch) Returns a Flowable that concatenate each item emitted by the source Publisher with the values in an Iterable corresponding to that item that is generated by a selector.
final Flowable<T>	concatWith(Publisher<? extends T> other) Returns a Flowable that emits the items emitted from the current Publisher, then the next, one after the other, without interleaving them.
final Single<Boolean>	contains(Object item) Returns a Single that emits a Boolean that indicates whether the source Publisher emitted a specified item.
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.
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.
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.
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.
final <U> Flowable<T>	debounce(Function<? super T, ? extends Publisher<U>> debounceIndicator) Returns a Flowable that mirrors the source Publisher, except that it drops items emitted by the source Publisher that are followed by another item within a computed debounce duration.
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.
static <T> Flowable<T>	defer(Callable<? extends Publisher<? extends T>> supplier) Returns a Flowable that calls a Publisher factory to create a Publisher for each new Subscriber that subscribes.
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.
final <U, V> Flowable<T>	delay(Publisher<U> subscriptionIndicator, Function<? super T, ? extends Publisher<V>> itemDelayIndicator) Returns a Flowable that delays the subscription to and emissions from the source Publisher via another Publisher on a per-item basis.
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.
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.
final <U> Flowable<T>	delay(Function<? super T, ? extends Publisher<U>> itemDelayIndicator) Returns a Flowable that delays the emissions of the source Publisher via another Publisher on a per-item basis.
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.
final <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.
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.
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.
final <T2> Flowable<T2>	dematerialize() Returns a Flowable that reverses the effect of `materialize` by transforming the `Notification` objects emitted by the source Publisher into the items or notifications they represent.
final Flowable<T>	distinct() Returns a Flowable that emits all items emitted by the source Publisher that are distinct.
final <K> Flowable<T>	distinct(Function<? super T, K> keySelector) Returns a Flowable that emits all items emitted by the source Publisher that are distinct according to a key selector function.
final <K> Flowable<T>	distinct(Function<? super T, K> keySelector, Callable<? extends Collection<? super K>> collectionSupplier) Returns a Flowable that emits all items emitted by the source Publisher that are distinct according to a key selector function.
final Flowable<T>	distinctUntilChanged(BiPredicate<? super T, ? super T> comparer) Returns a Flowable that emits all items emitted by the source Publisher that are distinct from their immediate predecessors when compared with each other via the provided comparator function.
final <K> Flowable<T>	distinctUntilChanged(Function<? super T, K> keySelector) Returns a Flowable that emits all items emitted by the source Publisher that are distinct from their immediate predecessors, according to a key selector function.
final Flowable<T>	distinctUntilChanged() Returns a Flowable that emits all items emitted by the source Publisher that are distinct from their immediate predecessors.
final Flowable<T>	doAfterNext(Consumer<? super T> onAfterNext) Calls the specified consumer with the current item after this item has been emitted to the downstream.
final Flowable<T>	doAfterTerminate(Action onAfterTerminate) Registers an `Action` to be called when this Publisher invokes either `onComplete` or `onError`.
final Flowable<T>	doFinally(Action onFinally) Calls the specified action after this Flowable signals onError or onCompleted or gets cancelled by the downstream.
final Flowable<T>	doOnCancel(Action onCancel) Calls the cancel `Action` if the downstream cancels the sequence.
final Flowable<T>	doOnComplete(Action onComplete) Modifies the source Publisher so that it invokes an action when it calls `onComplete`.
final Flowable<T>	doOnEach(Consumer<? super Notification<T>> onNotification) Modifies the source Publisher so that it invokes an action for each item it emits.
final Flowable<T>	doOnEach(Subscriber<? super T> subscriber) Modifies the source Publisher so that it notifies a Subscriber for each item and terminal event it emits.
final Flowable<T>	doOnError(Consumer<? super Throwable> onError) Modifies the source Publisher so that it invokes an action if it calls `onError`.
final Flowable<T>	doOnLifecycle(Consumer<? super Subscription> onSubscribe, LongConsumer onRequest, Action onCancel) Calls the appropriate onXXX method (shared between all Subscribers) for the lifecycle events of the sequence (subscription, cancellation, requesting).
final Flowable<T>	doOnNext(Consumer<? super T> onNext) Modifies the source Publisher so that it invokes an action when it calls `onNext`.
final Flowable<T>	doOnRequest(LongConsumer onRequest) Modifies the source `Publisher` so that it invokes the given action when it receives a request for more items.
final Flowable<T>	doOnSubscribe(Consumer<? super Subscription> onSubscribe) Modifies the source `Publisher` so that it invokes the given action when it is subscribed from its subscribers.
final Flowable<T>	doOnTerminate(Action onTerminate) Modifies the source Publisher so that it invokes an action when it calls `onComplete` or `onError`.
final Single<T>	elementAt(long index, T defaultItem) Returns a Flowable 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.
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.
final Single<T>	elementAtOrError(long index) Returns a Flowable that emits the item found at a specified index in a sequence of emissions from this Flowable or signals a `NoSuchElementException` if this Flowable has fewer elements than index.
static <T> Flowable<T>	empty() Returns a Flowable that emits no items to the Subscriber and immediately invokes its `onComplete` method.
static <T> Flowable<T>	error(Callable<? extends Throwable> supplier) Returns a Flowable that invokes a Subscriber's `onError` method when the Subscriber subscribes to it.
static <T> Flowable<T>	error(Throwable throwable) Returns a Flowable that invokes a Subscriber's `onError` method when the Subscriber subscribes to it.
final Flowable<T>	filter(Predicate<? super T> predicate) Filters items emitted by a Publisher by only emitting those that satisfy a specified predicate.
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.
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.
final 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.
final <R> Flowable<R>	flatMap(Function<? super T, ? extends Publisher<? extends R>> onNextMapper, Function<Throwable, ? extends Publisher<? extends R>> onErrorMapper, Callable<? extends Publisher<? extends R>> onCompleteSupplier, int maxConcurrency) Returns a Flowable that applies a function to each item emitted or notification raised by the source Publisher and then flattens the Publishers returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to these Publishers.
final <U, R> Flowable<R>	flatMap(Function<? super T, ? extends Publisher<? extends U>> mapper, BiFunction<? super T, ? super U, ? extends R> combiner, boolean delayErrors, int maxConcurrency) Returns a Flowable that emits the results of a specified function to the pair of values emitted by the source Publisher and a specified collection Publisher, while limiting the maximum number of concurrent subscriptions to these Publishers.
final <U, R> Flowable<R>	flatMap(Function<? super T, ? extends Publisher<? extends U>> mapper, BiFunction<? super T, ? super U, ? extends R> combiner, int maxConcurrency) Returns a Flowable that emits the results of a specified function to the pair of values emitted by the source Publisher and a specified collection Publisher, while limiting the maximum number of concurrent subscriptions to these Publishers.
final <R> Flowable<R>	flatMap(Function<? super T, ? extends Publisher<? extends R>> mapper, boolean delayErrors, int maxConcurrency) Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Publishers.
final <R> Flowable<R>	flatMap(Function<? super T, ? extends Publisher<? extends R>> mapper, int maxConcurrency) Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Publishers.
final <U, R> Flowable<R>	flatMap(Function<? super T, ? extends Publisher<? extends U>> mapper, BiFunction<? super T, ? super U, ? extends R> combiner) Returns a Flowable that emits the results of a specified function to the pair of values emitted by the source Publisher and a specified collection Publisher.
final <U, R> Flowable<R>	flatMap(Function<? super T, ? extends Publisher<? extends U>> mapper, BiFunction<? super T, ? super U, ? extends R> combiner, boolean delayErrors, int maxConcurrency, int bufferSize) Returns a Flowable that emits the results of a specified function to the pair of values emitted by the source Publisher and a specified collection Publisher, while limiting the maximum number of concurrent subscriptions to these Publishers.
final <R> Flowable<R>	flatMap(Function<? super T, ? extends Publisher<? extends R>> mapper, boolean delayErrors) Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger.
final <U, R> Flowable<R>	flatMap(Function<? super T, ? extends Publisher<? extends U>> mapper, BiFunction<? super T, ? super U, ? extends R> combiner, boolean delayErrors) Returns a Flowable that emits the results of a specified function to the pair of values emitted by the source Publisher and a specified collection Publisher.
final <R> Flowable<R>	flatMap(Function<? super T, ? extends Publisher<? extends R>> onNextMapper, Function<? super Throwable, ? extends Publisher<? extends R>> onErrorMapper, Callable<? extends Publisher<? extends R>> onCompleteSupplier) Returns a Flowable that applies a function to each item emitted or notification raised by the source Publisher and then flattens the Publishers returned from these functions and emits the resulting items.
final <R> Flowable<R>	flatMap(Function<? super T, ? extends Publisher<? extends R>> mapper) Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger.
final <R> Flowable<R>	flatMap(Function<? super T, ? extends Publisher<? extends R>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize) Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Publishers.
final Completable	flatMapCompletable(Function<? super T, ? extends CompletableSource> mapper) Maps each element of the upstream Flowable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete.
final Completable	flatMapCompletable(Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency) Maps each element of the upstream Flowable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete, optionally delaying all errors.
final <U> Flowable<U>	flatMapIterable(Function<? super T, ? extends Iterable<? extends U>> mapper, int bufferSize) Returns a Flowable that merges each item emitted by the source Publisher with the values in an Iterable corresponding to that item that is generated by a selector.
final <U, V> Flowable<V>	flatMapIterable(Function<? super T, ? extends Iterable<? extends U>> mapper, BiFunction<? super T, ? super U, ? extends V> resultSelector) Returns a Flowable that emits the results of applying a function to the pair of values from the source Publisher and an Iterable corresponding to that item that is generated by a selector.
final <U> Flowable<U>	flatMapIterable(Function<? super T, ? extends Iterable<? extends U>> mapper) Returns a Flowable that merges each item emitted by the source Publisher with the values in an Iterable corresponding to that item that is generated by a selector.
final <U, V> Flowable<V>	flatMapIterable(Function<? super T, ? extends Iterable<? extends U>> mapper, BiFunction<? super T, ? super U, ? extends V> resultSelector, int prefetch) Returns a Flowable that merges each item emitted by the source Publisher with the values in an Iterable corresponding to that item that is generated by a selector, while limiting the number of concurrent subscriptions to these Publishers.
final <R> Flowable<R>	flatMapMaybe(Function<? super T, ? extends MaybeSource<? extends R>> mapper, boolean delayErrors, int maxConcurrency) Maps each element of the upstream Flowable into MaybeSources, subscribes to them and waits until the upstream and all MaybeSources complete, optionally delaying all errors.
final <R> Flowable<R>	flatMapMaybe(Function<? super T, ? extends MaybeSource<? extends R>> mapper) Maps each element of the upstream Flowable into MaybeSources, subscribes to them and waits until the upstream and all MaybeSources complete.
final <R> Flowable<R>	flatMapSingle(Function<? super T, ? extends SingleSource<? extends R>> mapper, boolean delayErrors, int maxConcurrency) Maps each element of the upstream Flowable into SingleSources, subscribes to them and waits until the upstream and all SingleSources complete, optionally delaying all errors.
final <R> Flowable<R>	flatMapSingle(Function<? super T, ? extends SingleSource<? extends R>> mapper) Maps each element of the upstream Flowable into SingleSources, subscribes to them and waits until the upstream and all SingleSources complete.
final Disposable	forEach(Consumer<? super T> onNext) Subscribes to the Publisher and receives notifications for each element.
final Disposable	forEachWhile(Predicate<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) Subscribes to the Publisher and receives notifications for each element and the terminal events until the onNext Predicate returns false.
final Disposable	forEachWhile(Predicate<? super T> onNext, Consumer<? super Throwable> onError) Subscribes to the Publisher and receives notifications for each element and error events until the onNext Predicate returns false.
final Disposable	forEachWhile(Predicate<? super T> onNext) Subscribes to the Publisher and receives notifications for each element 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, Scheduler scheduler) Converts a `Future`, operating on a specified `Scheduler`, into a Publisher.
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, 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) Converts a `Future` 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, BiFunction<S, Emitter<T>, S> 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, 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> Flowable<T>	generate(Consumer<Emitter<T>> generator) Returns a cold, synchronous, stateless and backpressure-aware generator of values.
final <K> Flowable<GroupedFlowable<K, T>>	groupBy(Function<? super T, ? extends K> keySelector, boolean delayError) Groups the items emitted by a `Publisher` according to a specified criterion, and emits these grouped items as `GroupedFlowable`s.
final <K> Flowable<GroupedFlowable<K, T>>	groupBy(Function<? super T, ? extends K> keySelector) Groups the items emitted by a `Publisher` according to a specified criterion, and emits these grouped items as `GroupedFlowable`s.
final <K, V> Flowable<GroupedFlowable<K, V>>	groupBy(Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector) Groups the items emitted by a `Publisher` according to a specified criterion, and emits these grouped items as `GroupedFlowable`s.
final <K, V> Flowable<GroupedFlowable<K, V>>	groupBy(Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, boolean delayError) Groups the items emitted by a `Publisher` according to a specified criterion, and emits these grouped items as `GroupedFlowable`s.
final <K, V> Flowable<GroupedFlowable<K, V>>	groupBy(Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, boolean delayError, int bufferSize) Groups the items emitted by a `Publisher` according to a specified criterion, and emits these grouped items as `GroupedFlowable`s.
final <TRight, TLeftEnd, TRightEnd, R> Flowable<R>	groupJoin(Publisher<? extends TRight> other, Function<? super T, ? extends Publisher<TLeftEnd>> leftEnd, Function<? super TRight, ? extends Publisher<TRightEnd>> rightEnd, BiFunction<? super T, ? super Flowable<TRight>, ? extends R> resultSelector) Returns a Flowable that correlates two Publishers when they overlap in time and groups the results.
final Flowable<T>	hide() Hides the identity of this Flowable and its Subscription.
final Completable	ignoreElements() Ignores all items emitted by the source Publisher and only calls `onComplete` or `onError`.
static Flowable<Long>	interval(long period, TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits a sequential number every specified interval of time, on a specified Scheduler.
static Flowable<Long>	interval(long period, TimeUnit unit) Returns a Flowable that emits a sequential number every specified interval of time.
static Flowable<Long>	interval(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits a `0L` after the `initialDelay` and ever increasing numbers after each `period` of time thereafter, on a specified `Scheduler`.
static Flowable<Long>	interval(long initialDelay, long period, TimeUnit unit) Returns a Flowable that emits a `0L` after the `initialDelay` and ever increasing numbers after each `period` of time thereafter.
static Flowable<Long>	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.
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.
final Single<Boolean>	isEmpty() Returns a Single that emits `true` if the source Publisher is empty, otherwise `false`.
final <TRight, TLeftEnd, TRightEnd, R> Flowable<R>	join(Publisher<? extends TRight> other, Function<? super T, ? extends Publisher<TLeftEnd>> leftEnd, Function<? super TRight, ? extends Publisher<TRightEnd>> rightEnd, BiFunction<? super T, ? super TRight, ? extends R> resultSelector) Correlates the items emitted by two Publishers based on overlapping durations.
static <T> Flowable<T>	just(T 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) Converts two 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 item) Returns a Flowable that emits a single item and then completes.
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, 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.
static <T> Flowable<T>	just(T item1, T item2, T item3) Converts three items into a Publisher that emits those items.
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.
final Maybe<T>	lastElement() Returns a Maybe that emits the last item emitted by this Flowable or completes if this Flowable is empty.
final 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.
final <R> Flowable<R>	lift(FlowableOperator<? extends R, ? super T> lifter) This method requires advanced knowledge about building operators; please consider other standard composition methods first; Lifts a function to the current Publisher and returns a new Publisher that when subscribed to will pass the values of the current Publisher through the Operator function.
final <R> Flowable<R>	map(Function<? super T, ? extends R> mapper) Returns a Flowable that applies a specified function to each item emitted by the source Publisher and emits the results of these function applications.
final Flowable<Notification<T>>	materialize() Returns a Flowable that represents all of the emissions and notifications from the source Publisher into emissions marked with their original types within `Notification` objects.
static <T> Flowable<T>	merge(Publisher<? extends Publisher<? extends T>> sources) Flattens a Publisher that emits Publishers into a single Publisher that emits the items emitted by those Publishers, without any transformation.
static <T> Flowable<T>	merge(Publisher<? extends 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 Publisher<? extends T>> sources, int maxConcurrency) Flattens a Publisher that emits Publishers into a single Publisher that emits the items emitted by those Publishers, without any transformation, while limiting the maximum number of concurrent subscriptions to these Publishers.
static <T> Flowable<T>	merge(Iterable<? extends Publisher<? extends T>> sources, int maxConcurrency) Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the number of concurrent subscriptions to these Publishers.
static <T> Flowable<T>	merge(Publisher<? extends T> source1, Publisher<? extends T> source2) Flattens two Publishers into a single Publisher, without any transformation.
static <T> Flowable<T>	merge(Iterable<? extends Publisher<? extends T>> sources) Flattens an Iterable of Publishers into one Publisher, without any transformation.
static <T> Flowable<T>	merge(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>	merge(Iterable<? extends Publisher<? extends T>> sources, int maxConcurrency, int bufferSize) Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the number of concurrent subscriptions to these Publishers.
static <T> Flowable<T>	mergeArray(Publisher...<? extends T> sources) Flattens an Array of Publishers into one 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>	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(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 Publisher<? extends T>> sources, int maxConcurrency) Flattens a Publisher that emits Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
static <T> Flowable<T>	mergeDelayError(Publisher<? extends Publisher<? extends T>> sources) Flattens a Publisher that emits Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them.
static <T> Flowable<T>	mergeDelayError(Iterable<? extends Publisher<? extends T>> sources, int maxConcurrency, int bufferSize) Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
static <T> Flowable<T>	mergeDelayError(Publisher<? extends 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(Iterable<? extends Publisher<? extends T>> sources, int maxConcurrency) Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
static <T> Flowable<T>	mergeDelayError(Iterable<? extends Publisher<? extends T>> sources) 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(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.
final Flowable<T>	mergeWith(Publisher<? extends T> other) Flattens this and another Publisher into a single Publisher, without any transformation.
static <T> Flowable<T>	never() Returns a Flowable that never sends any items or notifications to a Subscriber.
final 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.
final 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.
final 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.
final <U> Flowable<U>	ofType(Class<U> clazz) Filters the items emitted by a Publisher, only emitting those of the specified type.
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.
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.
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.
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.
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.
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.
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.
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.
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.
final Flowable<T>	onBackpressureDrop(Consumer<? super T> onDrop) Instructs a Publisher that is emitting items faster than its Subscriber can consume them to discard, rather than emit, those items that its Subscriber is not prepared to observe.
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.
final Flowable<T>	onErrorResumeNext(Publisher<? extends T> next) Instructs a Publisher to pass control to another Publisher rather than invoking `onError` if it encounters an error.
final Flowable<T>	onErrorResumeNext(Function<? super Throwable, ? extends Publisher<? extends T>> resumeFunction) Instructs a Publisher to pass control to another Publisher rather than invoking `onError` if it encounters an error.
final Flowable<T>	onErrorReturn(Function<? super Throwable, ? extends T> valueSupplier) Instructs a Publisher to emit an item (returned by a specified function) rather than invoking `onError` if it encounters an error.
final 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.
final Flowable<T>	onExceptionResumeNext(Publisher<? extends T> next) Instructs a Publisher to pass control to another Publisher rather than invoking `onError` if it encounters an `Exception`.
final Flowable<T>	onTerminateDetach() Nulls out references to the upstream producer and downstream Subscriber if the sequence is terminated or downstream cancels.
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.
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.
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.
final ConnectableFlowable<T>	publish() Returns a `ConnectableFlowable`, which is a variety of Publisher that waits until its `connect` method is called before it begins emitting items to those Subscribers that have subscribed to it.
final <R> Flowable<R>	publish(Function<? super Flowable<T>, ? extends Publisher<? extends R>> selector, int prefetch) Returns a Flowable that emits the results of invoking a specified selector on items emitted by a `ConnectableFlowable` that shares a single subscription to the underlying sequence.
final ConnectableFlowable<T>	publish(int bufferSize) Returns a `ConnectableFlowable`, which is a variety of Publisher that waits until its `connect` method is called before it begins emitting items to those Subscribers that have subscribed to it.
final <R> Flowable<R>	publish(Function<? super Flowable<T>, ? extends Publisher<R>> selector) Returns a Flowable that emits the results of invoking a specified selector on items emitted by a `ConnectableFlowable` that shares a single subscription to the underlying sequence.
static Flowable<Integer>	range(int start, int count) Returns a Flowable that emits a sequence of Integers within a specified range.
static Flowable<Long>	rangeLong(long start, long count) Returns a Flowable that emits a sequence of Longs within a specified range.
final 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.
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 source Publisher, and emits the final result from the final call to your function as its sole item.
final <R> Single<R>	reduce(R seed, BiFunction<R, ? super T, R> reducer) Returns a Single that applies a specified accumulator function to the first item emitted by a source Publisher and a specified seed value, then feeds the result of that function along with the second item emitted by a Publisher into the same function, and so on until all items have been emitted by the source Publisher, emitting the final result from the final call to your function as its sole item.
final <R> Single<R>	reduceWith(Callable<R> seedSupplier, BiFunction<R, ? super T, R> reducer) Returns a Single that applies a specified accumulator function to the first item emitted by a source Publisher and a seed value derived from calling a specified seedSupplier, then feeds the result of that function along with the second item emitted by a Publisher into the same function, and so on until all items have been emitted by the source Publisher, emitting the final result from the final call to your function as its sole item.
final Flowable<T>	repeat() Returns a Flowable that repeats the sequence of items emitted by the source Publisher indefinitely.
final Flowable<T>	repeat(long times) Returns a Flowable that repeats the sequence of items emitted by the source Publisher at most `count` times.
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.
final Flowable<T>	repeatWhen(Function<? super Flowable<Object>, ? extends Publisher<?>> handler) Returns a Flowable that emits the same values as the source Publisher with the exception of an `onComplete`.
final <R> Flowable<R>	replay(Function<? super Flowable<T>, ? extends Publisher<R>> selector, Scheduler scheduler) Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a `ConnectableFlowable` that shares a single subscription to the source Publisher.
final <R> Flowable<R>	replay(Function<? super Flowable<T>, ? extends Publisher<R>> selector, int bufferSize) Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a `ConnectableFlowable` that shares a single subscription to the source Publisher, replaying `bufferSize` notifications.
final <R> Flowable<R>	replay(Function<? super Flowable<T>, ? extends Publisher<R>> selector, int bufferSize, Scheduler scheduler) Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a `ConnectableFlowable` that shares a single subscription to the source Publisher, replaying a maximum of `bufferSize` items.
final 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.
final 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.
final 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.
final 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.
final <R> Flowable<R>	replay(Function<? super Flowable<T>, ? extends Publisher<R>> selector) Returns a Flowable that emits items that are the results of invoking a specified selector on the items emitted by a `ConnectableFlowable` that shares a single subscription to the source Publisher.
final <R> Flowable<R>	replay(Function<? super Flowable<T>, ? extends Publisher<R>> selector, int bufferSize, long time, TimeUnit unit) Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a `ConnectableFlowable` that shares a single subscription to the source Publisher, replaying no more than `bufferSize` items that were emitted within a specified time window.
final <R> Flowable<R>	replay(Function<? super Flowable<T>, ? extends Publisher<R>> selector, long time, TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a `ConnectableFlowable` that shares a single subscription to the source Publisher, replaying all items that were emitted within a specified time window.
final 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.
final 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`.
final 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.
final 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.
final <R> Flowable<R>	replay(Function<? super Flowable<T>, ? extends Publisher<R>> selector, long time, TimeUnit unit) Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a `ConnectableFlowable` that shares a single subscription to the source Publisher, replaying all items that were emitted within a specified time window.
final <R> Flowable<R>	replay(Function<? super Flowable<T>, ? extends Publisher<R>> selector, int bufferSize, long time, TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a `ConnectableFlowable` that shares a single subscription to the source Publisher, replaying no more than `bufferSize` items that were emitted within a specified time window.
final Flowable<T>	retry() Returns a Flowable that mirrors the source Publisher, resubscribing to it if it calls `onError` (infinite retry count).
final 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.
final Flowable<T>	retry(long times, Predicate<? super Throwable> predicate) Retries at most times or until the predicate returns false, whichever happens first.
final Flowable<T>	retry(BiPredicate<? super Integer, ? super Throwable> predicate) Returns a Flowable that mirrors the source Publisher, resubscribing to it if it calls `onError` and the predicate returns true for that specific exception and retry count.
final Flowable<T>	retry(Predicate<? super Throwable> predicate) Retries the current Flowable if the predicate returns true.
final Flowable<T>	retryUntil(BooleanSupplier stop) Retries until the given stop function returns true.
final Flowable<T>	retryWhen(Function<? super Flowable<Throwable>, ? extends Publisher<?>> handler) Returns a Flowable that emits the same values as the source Publisher with the exception of an `onError`.
final void	safeSubscribe(Subscriber<? super T> s) Subscribes to the current Flowable and wraps the given Subscriber into a SafeSubscriber (if not already a SafeSubscriber) that deals with exceptions thrown by a misbehaving Subscriber (that doesn't follow the Reactive-Streams specification).
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.
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.
final <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.
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.
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.
final <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.
final <R> Flowable<R>	scan(R initialValue, BiFunction<R, ? super T, R> accumulator) Returns a Flowable that applies a specified accumulator function to the first item emitted by a source Publisher and a seed value, then feeds the result of that function along with the second item emitted by the source Publisher into the same function, and so on until all items have been emitted by the source Publisher, emitting the result of each of these iterations.
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.
final <R> Flowable<R>	scanWith(Callable<R> seedSupplier, BiFunction<R, ? super T, R> accumulator) Returns a Flowable that applies a specified accumulator function to the first item emitted by a source Publisher and a seed value, then feeds the result of that function along with the second item emitted by the source Publisher into the same function, and so on until all items have been emitted by the source Publisher, emitting the result of each of these iterations.
static <T> Single<Boolean>	sequenceEqual(Publisher<? extends T> source1, Publisher<? extends T> source2, 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.
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.
final Flowable<T>	serialize() Forces a Publisher's emissions and notifications to be serialized and for it to obey the Publisher contract in other ways.
final Flowable<T>	share() Returns a new Publisher that multicasts (shares) the original Publisher.
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.
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 an `IllegalArgumentException` if this Flowable signals more than one item.
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 a `NoSuchElementException` will be signalled and if this Flowable emits more than one item, an `IllegalArgumentException` will be signalled.
final Flowable<T>	skip(long count) Returns a Flowable that skips the first `count` items emitted by the source Publisher and emits the remainder.
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 specified `Scheduler` elapses.
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.
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.
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.
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.
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.
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.
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.
final <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.
final Flowable<T>	skipWhile(Predicate<? super T> predicate) Returns a Flowable that skips all items emitted by the source Publisher as long as a specified condition holds true, but emits all further source items as soon as the condition becomes false.
final Flowable<T>	sorted() Returns a Flowable that emits the events emitted by source Publisher, in a sorted order.
final Flowable<T>	sorted(Comparator<? super T> sortFunction) Returns a Flowable that emits the events emitted by source Publisher, in a sorted order based on a specified comparison function.
final Flowable<T>	startWith(Publisher<? extends T> other) Returns a Flowable that emits the items in a specified Publisher before it begins to emit items emitted by the source Publisher.
final Flowable<T>	startWith(Iterable<? extends T> items) Returns a Flowable that emits the items in a specified `Iterable` before it begins to emit items emitted by the source Publisher.
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.
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.
final void	subscribe(FlowableSubscriber<? super T> s) Establish a connection between this Flowable and the given FlowableSubscriber and start streaming events based on the demand of the FlowableSubscriber.
final void	subscribe(Subscriber<? super T> s)
final Disposable	subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) Subscribes to a Publisher and provides callbacks to handle the items it emits and any error or completion notification it issues.
final Disposable	subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Subscription> onSubscribe) Subscribes to a Publisher and provides callbacks to handle the items it emits and any error or completion notification it issues.
final Disposable	subscribe() Subscribes to a Publisher and ignores `onNext` and `onComplete` emissions.
final Disposable	subscribe(Consumer<? super T> onNext) Subscribes to a Publisher and provides a callback to handle the items it emits.
final Disposable	subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) Subscribes to a Publisher and provides callbacks to handle the items it emits and any error notification it issues.
abstract void	subscribeActual(Subscriber<? super T> s) Operator implementations (both source and intermediate) should implement this method that performs the necessary business logic.
final Flowable<T>	subscribeOn(Scheduler scheduler) Asynchronously subscribes Subscribers to this Publisher on the specified `Scheduler`.
final 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.
final <E extends Subscriber<? super T>> E	subscribeWith(E subscriber) Subscribes a given Subscriber (subclass) to this Flowable and returns the given Subscriber as is.
final Flowable<T>	switchIfEmpty(Publisher<? extends T> other) Returns a Flowable that emits the items emitted by the source Publisher or the items of an alternate Publisher if the source Publisher is empty.
final <R> Flowable<R>	switchMap(Function<? super T, ? extends Publisher<? extends R>> mapper, int bufferSize) Returns a new Publisher by applying a function that you supply to each item emitted by the source Publisher that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers.
final <R> Flowable<R>	switchMap(Function<? super T, ? extends Publisher<? extends R>> mapper) Returns a new Publisher by applying a function that you supply to each item emitted by the source Publisher that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers.
final <R> Flowable<R>	switchMapDelayError(Function<? super T, ? extends Publisher<? extends R>> mapper) Returns a new Publisher by applying a function that you supply to each item emitted by the source Publisher that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers and delays any error until all Publishers terminate.
final <R> Flowable<R>	switchMapDelayError(Function<? super T, ? extends Publisher<? extends R>> mapper, int bufferSize) Returns a new Publisher by applying a function that you supply to each item emitted by the source Publisher that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers and delays any error until all Publishers terminate.
static <T> Flowable<T>	switchOnNext(Publisher<? extends Publisher<? extends T>> sources, int bufferSize) Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers.
static <T> Flowable<T>	switchOnNext(Publisher<? extends Publisher<? extends T>> sources) Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers.
static <T> Flowable<T>	switchOnNextDelayError(Publisher<? extends Publisher<? extends T>> sources, int prefetch) Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers and delays any exception until all Publishers terminate.
static <T> Flowable<T>	switchOnNextDelayError(Publisher<? extends Publisher<? extends T>> sources) Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers and delays any exception until all Publishers terminate.
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.
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.
final Flowable<T>	take(long count) Returns a Flowable that emits only the first `count` items emitted by the source Publisher.
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.
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.
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.
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.
final Flowable<T>	takeLast(int count) Returns a Flowable that emits at most the last `count` items emitted by the source Publisher.
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.
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.
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.
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.
final <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.
final Flowable<T>	takeUntil(Predicate<? super T> stopPredicate) Returns a Flowable that emits items emitted by the source Publisher, checks the specified predicate for each item, and then completes when the condition is satisfied.
final Flowable<T>	takeWhile(Predicate<? super T> predicate) Returns a Flowable that emits items emitted by the source Publisher so long as each item satisfied a specified condition, and then completes as soon as this condition is not satisfied.
final TestSubscriber<T>	test(long initialRequest) Creates a TestSubscriber with the given initial request amount and subscribes it to this Flowable.
final TestSubscriber<T>	test() Creates a TestSubscriber that requests Long.MAX_VALUE and subscribes it to this Flowable.
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.
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.
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.
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.
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.
final Flowable<T>	throttleWithTimeout(long timeout, TimeUnit unit, Scheduler scheduler) Returns a Flowable that only emits those items emitted by the source Publisher that are not followed by another emitted item within a specified time window, where the time window is governed by a specified Scheduler.
final Flowable<T>	throttleWithTimeout(long timeout, TimeUnit unit) Returns a Flowable that only emits those items emitted by the source Publisher that are not followed by another emitted item within a specified time window.
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.
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.
final Flowable<Timed<T>>	timeInterval() Returns a Flowable that emits records of the time interval between consecutive items emitted by the source Publisher.
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.
final <V> Flowable<T>	timeout(Function<? super T, ? extends Publisher<V>> itemTimeoutIndicator) Returns a Flowable that mirrors the source Publisher, but notifies Subscribers of a `TimeoutException` if an item emitted by the source Publisher doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by a Publisher that is a function of the previous item.
final <U, V> Flowable<T>	timeout(Publisher<U> firstTimeoutIndicator, Function<? super T, ? extends Publisher<V>> itemTimeoutIndicator) Returns a Flowable that mirrors the source Publisher, but notifies Subscribers of a `TimeoutException` if either the first item emitted by the source Publisher or any subsequent item doesn't arrive within time windows defined by other Publishers.
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.
final <U, V> Flowable<T>	timeout(Publisher<U> firstTimeoutIndicator, Function<? super T, ? extends Publisher<V>> itemTimeoutIndicator, Publisher<? extends T> other) Returns a Flowable that mirrors the source Publisher, but switches to a fallback Publisher if either the first item emitted by the source Publisher or any subsequent item doesn't arrive within time windows defined by other Publishers.
final <V> Flowable<T>	timeout(Function<? super T, ? extends Publisher<V>> itemTimeoutIndicator, Flowable<? extends T> other) Returns a Flowable that mirrors the source Publisher, but that switches to a fallback Publisher if an item emitted by the source Publisher doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by a Publisher that is a function of the previous item.
final Flowable<T>	timeout(long timeout, TimeUnit timeUnit, Publisher<? extends T> other) Returns a Flowable that mirrors the source Publisher but applies a timeout policy for each emitted item.
final Flowable<T>	timeout(long timeout, TimeUnit timeUnit, Scheduler scheduler, Publisher<? extends T> other) Returns a Flowable that mirrors the source Publisher but applies a timeout policy for each emitted item using a specified Scheduler.
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 on a specified Scheduler.
static Flowable<Long>	timer(long delay, TimeUnit unit) Returns a Flowable that emits `0L` after a specified delay, and then completes.
static Flowable<Long>	timer(long delay, TimeUnit unit, Scheduler scheduler) Returns a Flowable that emits `0L` after a specified delay, on a specified Scheduler, and then completes.
final 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.
final Flowable<Timed<T>>	timestamp() Returns a Flowable that emits each item emitted by the source Publisher, wrapped in a `Timed` object.
final 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.
final Flowable<Timed<T>>	timestamp(TimeUnit unit) Returns a Flowable that emits each item emitted by the source Publisher, wrapped in a `Timed` object.
final <R> R	to(Function<? super Flowable<T>, R> converter) Calls the specified converter function during assembly time and returns its resulting value.
final Future<T>	toFuture() Returns a `Future` representing the single value emitted by this `Flowable`.
final <U extends Collection<? super T>> Single<U>	toList(Callable<U> collectionSupplier) Returns a Single that emits a single item, a list composed of all the items emitted by the finite source Publisher.
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.
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.
final <K> Single<Map<K, T>>	toMap(Function<? super T, ? extends K> keySelector) Returns a Single that emits a single HashMap containing all items emitted by the source Publisher, mapped by the keys returned by a specified `keySelector` function.
final <K, V> Single<Map<K, V>>	toMap(Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, Callable<? extends Map<K, V>> mapSupplier) Returns a Single that emits a single Map, returned by a specified `mapFactory` function, that contains keys and values extracted from the items emitted by the source Publisher.
final <K, V> Single<Map<K, V>>	toMap(Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector) Returns a Single that emits a single HashMap containing values corresponding to items emitted by the source Publisher, mapped by the keys returned by a specified `keySelector` function.
final <K> Single<Map<K, Collection<T>>>	toMultimap(Function<? super T, ? extends K> keySelector) Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the source Publisher keyed by a specified `keySelector` function.
final <K, V> Single<Map<K, Collection<V>>>	toMultimap(Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, Callable<Map<K, Collection<V>>> mapSupplier) Returns a Single that emits a single Map, returned by a specified `mapFactory` function, that contains an ArrayList of values, extracted by a specified `valueSelector` function from items emitted by the source Publisher and keyed by the `keySelector` function.
final <K, V> Single<Map<K, Collection<V>>>	toMultimap(Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector) Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a specified `valueSelector` function from items emitted by the source Publisher, keyed by a specified `keySelector` function.
final <K, V> Single<Map<K, Collection<V>>>	toMultimap(Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, Callable<? extends Map<K, Collection<V>>> mapSupplier, Function<? super K, ? extends Collection<? super V>> collectionFactory) Returns a Single that emits a single Map, returned by a specified `mapFactory` function, that contains a custom collection of values, extracted by a specified `valueSelector` function from items emitted by the source Publisher, and keyed by the `keySelector` function.
final Observable<T>	toObservable() Converts the current Flowable into a non-backpressured `Observable`.
final Single<List<T>>	toSortedList(Comparator<? super T> comparator, int capacityHint) Returns a Single that emits a list that contains the items emitted by the source Publisher, in a sorted order based on a specified comparison function.
final Single<List<T>>	toSortedList(Comparator<? super T> comparator) Returns a Single that emits a list that contains the items emitted by the source Publisher, in a sorted order based on a specified comparison function.
final Single<List<T>>	toSortedList() Returns a Single that emits a list that contains the items emitted by the source Publisher, in a sorted order.
final Single<List<T>>	toSortedList(int capacityHint) Returns a Flowable that emits a list that contains the items emitted by the source Publisher, in a sorted order.
static <T> Flowable<T>	unsafeCreate(Publisher<T> onSubscribe) Create a Flowable by wrapping a Publisher which has to be implemented according to the Reactive-Streams specification by handling backpressure and cancellation correctly; no safeguards are provided by the Flowable itself.
final Flowable<T>	unsubscribeOn(Scheduler scheduler) Modifies the source Publisher so that subscribers will cancel it on a specified `Scheduler`.
static <T, D> Flowable<T>	using(Callable<? extends D> resourceSupplier, Function<? super D, ? extends Publisher<? extends T>> sourceSupplier, Consumer<? super D> resourceDisposer) Constructs a Publisher that creates a dependent resource object which is disposed of on cancellation.
static <T, D> Flowable<T>	using(Callable<? extends D> resourceSupplier, Function<? super D, ? extends Publisher<? extends T>> sourceSupplier, Consumer<? super D> resourceDisposer, boolean eager) Constructs a Publisher that creates a dependent resource object which is disposed of just before termination if you have set `disposeEagerly` to `true` and cancellation does not occur before termination.
final <U, V> Flowable<Flowable<T>>	window(Publisher<U> openingIndicator, Function<? super U, ? extends Publisher<V>> closingIndicator) Returns a Flowable that emits windows of items it collects from the source Publisher.
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.
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.
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.
final <B> Flowable<Flowable<T>>	window(Callable<? extends Publisher<B>> boundaryIndicatorSupplier, int bufferSize) Returns a Flowable that emits windows of items it collects from the source Publisher.
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.
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.
final <U, V> Flowable<Flowable<T>>	window(Publisher<U> openingIndicator, Function<? super U, ? extends Publisher<V>> closingIndicator, int bufferSize) Returns a Flowable that emits windows of items it collects from the source Publisher.
final <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.
final Flowable<Flowable<T>>	window(long count) Returns a Flowable that emits windows of items it collects from the source Publisher.
final Flowable<Flowable<T>>	window(long count, long skip) Returns a Flowable that emits windows of items it collects from the source Publisher.
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.
final <B> Flowable<Flowable<T>>	window(Callable<? extends Publisher<B>> boundaryIndicatorSupplier) Returns a Flowable that emits windows of items it collects from the source Publisher.
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.
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.
final <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.
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.
final Flowable<Flowable<T>>	window(long timespan, TimeUnit unit) Returns a Flowable that emits windows of items it collects from the source Publisher.
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.
final <U, R> Flowable<R>	withLatestFrom(Publisher<? extends U> other, BiFunction<? super T, ? super U, ? extends R> combiner) Merges the specified Publisher into this Publisher sequence by using the `resultSelector` function only when the source Publisher (this instance) emits an item.
final <T1, T2, T3, R> Flowable<R>	withLatestFrom(Publisher<T1> source1, Publisher<T2> source2, Publisher<T3> source3, Function4<? super T, ? super T1, ? super T2, ? super T3, R> combiner) Combines the value emission from this Publisher with the latest emissions from the other Publishers via a function to produce the output item.
final <R> Flowable<R>	withLatestFrom(Publisher[]<?> others, Function<? super Object[], R> combiner) Combines the value emission from this Publisher with the latest emissions from the other Publishers via a function to produce the output item.
final <T1, T2, R> Flowable<R>	withLatestFrom(Publisher<T1> source1, Publisher<T2> source2, Function3<? super T, ? super T1, ? super T2, R> combiner) Combines the value emission from this Publisher with the latest emissions from the other Publishers via a function to produce the output item.
final <T1, T2, T3, T4, R> Flowable<R>	withLatestFrom(Publisher<T1> source1, Publisher<T2> source2, Publisher<T3> source3, Publisher<T4> source4, Function5<? super T, ? super T1, ? super T2, ? super T3, ? super T4, R> combiner) Combines the value emission from this Publisher with the latest emissions from the other Publishers via a function to produce the output item.
final <R> Flowable<R>	withLatestFrom(Iterable<? extends Publisher<?>> others, Function<? super Object[], R> combiner) Combines the value emission from this Publisher with the latest emissions from the other Publishers via a function to produce the output item.
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, 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>	zip(Publisher<? extends Publisher<? extends T>> sources, Function<? super Object[], ? extends R> zipper) Returns a Flowable that emits the results of a specified combiner function applied to combinations of n items emitted, in sequence, by the n Publishers emitted by a specified Publisher.
static <T1, T2, 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, 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, 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, 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, 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 <T, R> Flowable<R>	zip(Iterable<? extends Publisher<? extends T>> sources, Function<? super Object[], ? extends R> zipper) Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other Publishers.
static <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 <T, R> Flowable<R>	zipArray(Function<? super Object[], ? extends R> zipper, boolean delayError, int bufferSize, Publisher...<? extends T> sources) Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of other Publishers.
static <T, R> Flowable<R>	zipIterable(Iterable<? extends Publisher<? extends T>> sources, Function<? super Object[], ? extends R> zipper, boolean delayError, int bufferSize) Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other Publishers.
final <U, R> Flowable<R>	zipWith(Publisher<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper, boolean delayError) Returns a Flowable that emits items that are the result of applying a specified function to pairs of values, one each from the source Publisher and another specified Publisher.
final <U, R> Flowable<R>	zipWith(Publisher<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper) Returns a Flowable that emits items that are the result of applying a specified function to pairs of values, one each from the source Publisher and another specified Publisher.
final <U, R> Flowable<R>	zipWith(Iterable<U> other, BiFunction<? super T, ? super U, ? extends R> zipper) Returns a Flowable that emits items that are the result of applying a specified function to pairs of values, one each from the source Publisher and a specified Iterable sequence.
final <U, R> Flowable<R>	zipWith(Publisher<? extends U> other, BiFunction<? super T, ? super U, ? extends R> zipper, boolean delayError, int bufferSize) Returns a Flowable that emits items that are the result of applying a specified function to pairs of values, one each from the source Publisher and another specified Publisher.

From class java.lang.Object

From interface org.reactivestreams.Publisher

Protected Constructors

protected GroupedFlowable (K key)

Constructs a GroupedFlowable with the given key.

Parameters

key	the key

Public Methods

public K getKey ()

Returns the key that identifies the group of items emitted by this GroupedObservable.

Returns

the key that the items emitted by this GroupedObservable were grouped by

Classes