aggregate(?)
— see reduce(?)
all(?)
— determine whether all items emitted by an Observable meet some criteriaamb(?)
— given two or more source Observables, emits all of the items from the first of these Observables to emit an itemambWith(?)
— instance version of amb(?)
and(?)
— combine the emissions from two or more source Observables into a Pattern
(rxjava-joins
)apply(?)
(scala) — see create(?)
asObservable(?)
(kotlin) — see from(?)
(et al.)asyncAction(?)
— convert an Action into an Observable that executes the Action and emits its return value (rxjava-async
)asyncFunc(?)
— convert a function into an Observable that executes the function and emits its return value (rxjava-async
)averageDouble(?)
— calculates the average of Doubles emitted by an Observable and emits this average (rxjava-math
)averageFloat(?)
— calculates the average of Floats emitted by an Observable and emits this average (rxjava-math
)averageInteger(?)
— calculates the average of Integers emitted by an Observable and emits this average (rxjava-math
)averageLong(?)
— calculates the average of Longs emitted by an Observable and emits this average (rxjava-math
)blocking(?)
(clojure) — see toBlocking(?)
buffer(?)
— periodically gather items from an Observable into bundles and emit these bundles rather than emitting the items one at a timebyLine(?)
(StringObservable
) — converts an Observable of Strings into an Observable of Lines by treating the source sequence as a stream and splitting it on line-endingscache(?)
— remember the sequence of items emitted by the Observable and emit the same sequence to future Subscriberscast(?)
— cast all items from the source Observable into a particular type before reemitting themcatch(?)
(clojure) — see onErrorResumeNext(?)
chunkify(?)
— returns an iterable that periodically returns a list of items emitted by the source Observable since the last list (?)collect(?)
— collects items emitted by the source Observable into a single mutable data structure and returns an Observable that emits this structurecombineLatest(?)
— when an item is emitted by either of two Observables, combine the latest item emitted by each Observable via a specified function and emit items based on the results of this functioncombineLatestWith(?)
(scala) — instance version of combineLatest(?)
concat(?)
— concatenate two or more Observables sequentiallyconcatMap(?)
— transform the items emitted by an Observable into Observables, then flatten this into a single Observable, without interleavingconcatWith(?)
— instance version of concat(?)
connect(?)
— instructs a Connectable Observable to begin emitting itemscons(?)
(clojure) — see concat(?)
contains(?)
— determine whether an Observable emits a particular item or notcount(?)
— counts the number of items emitted by an Observable and emits this countcountLong(?)
— counts the number of items emitted by an Observable and emits this countcreate(?)
— create an Observable from scratch by means of a functioncycle(?)
(clojure) — see repeat(?)
debounce(?)
— only emit an item from the source Observable after a particular timespan has passed without the Observable emitting any other itemsdecode(?)
(StringObservable
) — convert a stream of multibyte characters into an Observable that emits byte arrays that respect character boundariesdefaultIfEmpty(?)
— emit items from the source Observable, or emit a default item if the source Observable completes after emitting no itemsdefer(?)
— do not create the Observable until a Subscriber subscribes; create a fresh Observable on each subscriptiondeferFuture(?)
— convert a Future that returns an Observable into an Observable, but do not attempt to get the Observable that the Future returns until a Subscriber subscribes (rxjava-async
)deferCancellableFuture(?)
— convert a Future that returns an Observable into an Observable in a way that monitors the subscription status of the Observable to determine whether to halt work on the Future, but do not attempt to get the returned Observable until a Subscriber subscribes (?)(rxjava-async
)delay(?)
— shift the emissions from an Observable forward in time by a specified amountdematerialize(?)
— convert a materialized Observable back into its non-materialized formdistinct(?)
— suppress duplicate items emitted by the source ObservabledistinctUntilChanged(?)
— suppress duplicate consecutive items emitted by the source Observabledo(?)
(clojure) — see doOnEach(?)
doOnCompleted(?)
— register an action to take when an Observable completes successfullydoOnEach(?)
— register an action to take whenever an Observable emits an itemdoOnError(?)
— register an action to take when an Observable completes with an errordoOnNext(?)
— see doOnEach(?)
doOnRequest(?)
— register an action to take when items are requested from an Observable via reactive-pull backpressure (?)doOnSubscribe(?)
— register an action to take when an observer subscribes to an ObservabledoOnTerminate(?)
— register an action to take when an Observable completes, either successfully or with an errordoOnUnsubscribe(?)
— register an action to take when an observer unsubscribes from an ObservabledoWhile(?)
— emit the source Observable's sequence, and then repeat the sequence as long as a condition remains true (contrib-computation-expressions
)drop(?)
(scala/clojure) — see skip(?)
dropRight(?)
(scala) — see skipLast(?)
dropUntil(?)
(scala) — see skipUntil(?)
dropWhile(?)
(scala) — see skipWhile(?)
drop-while(?)
(clojure) — see skipWhile(?)
elementAt(?)
— emit item n emitted by the source ObservableelementAtOrDefault(?)
— emit item n emitted by the source Observable, or a default item if the source Observable emits fewer than n itemsempty(?)
— create an Observable that emits nothing and then completesencode(?)
(StringObservable
) — transform an Observable that emits strings into an Observable that emits byte arrays that respect character boundaries of multibyte characters in the original stringserror(?)
— create an Observable that emits nothing and then signals an errorevery(?)
(clojure) — see all(?)
exists(?)
— determine whether an Observable emits any items or notfilter(?)
— filter items emitted by an Observablefinally(?)
(clojure) — see finallyDo(?)
filterNot(?)
(scala) — see filter(?)
finallyDo(?)
— register an action to take when an Observable completesfirst(?)
(Observable
) — emit only the first item emitted by an Observable, or the first item that meets some conditionfirst(?)
(BlockingObservable
) — emit only the first item emitted by an Observable, or the first item that meets some conditionfirstOrDefault(?)
(Observable
) — emit only the first item emitted by an Observable, or the first item that meets some condition, or a default value if the source Observable is emptyfirstOrDefault(?)
(BlockingObservable
) — emit only the first item emitted by an Observable, or the first item that meets some condition, or a default value if the source Observable is emptyfirstOrElse(?)
(scala) — see firstOrDefault(?)
or firstOrDefault(?)
(BlockingObservable
)flatMap(?)
— transform the items emitted by an Observable into Observables, then flatten this into a single ObservableflatMapIterable(?)
— create Iterables corresponding to each emission from a source Observable and merge the results into a single ObservableflatMapIterableWith(?)
(scala) — instance version of flatMapIterable(?)
flatMapWith(?)
(scala) — instance version of flatmap(?)
flatten(?)
(scala) — see merge(?)
flattenDelayError(?)
(scala) — see mergeDelayError(?)
foldLeft(?)
(scala) — see reduce(?)
forall(?)
(scala) — see all(?)
forEach(?)
(Observable
) — see subscribe(?)
forEach(?)
(BlockingObservable
) — invoke a function on each item emitted by the Observable; block until the Observable completesforEachFuture(?)
(Async
) — pass Subscriber methods to an Observable but also have it behave like a Future that blocks until it completes (rxjava-async
)forEachFuture(?)
(BlockingObservable
)— create a futureTask that will invoke a specified function on each item emitted by an Observable (?)forIterable(?)
— apply a function to the elements of an Iterable to create Observables which are then concatenated (?)from(?)
— convert an Iterable, a Future, or an Array into an Observablefrom(?)
(StringObservable
) — convert a stream of characters or a Reader into an Observable that emits byte arrays or StringsfromAction(?)
— convert an Action into an Observable that invokes the action and emits its result when a Subscriber subscribes (rxjava-async
)fromCallable(?)
— convert a Callable into an Observable that invokes the callable and emits its result or exception when a Subscriber subscribes (rxjava-async
)fromCancellableFuture(?)
— convert a Future into an Observable in a way that monitors the subscription status of the Observable to determine whether to halt work on the Future, but do not attempt to get the Future's value until a Subscriber subscribes (?)(rxjava-async
)fromFunc0(?)
— see fromCallable(?)
(rxjava-async
)fromFuture(?)
— convert a Future into an Observable, but do not attempt to get the Future's value until a Subscriber subscribes (?)fromRunnable(?)
— convert a Runnable into an Observable that invokes the runable and emits its result when a Subscriber subscribes (rxjava-async
)generate(?)
— create an Observable that emits a sequence of items as generated by a function of your choosing (?)generateAbsoluteTime(?)
— create an Observable that emits a sequence of items as generated by a function of your choosing, with each item emitted at an item-specific time (?)generator(?)
(clojure) — see generate(?)
getIterator(?)
— convert the sequence emitted by the Observable into an IteratorgroupBy(?)
— divide an Observable into a set of Observables that emit groups of items from the original Observable, organized by keygroup-by(?)
(clojure) — see groupBy(?)
groupByUntil(?)
— a variant of the groupBy(?)
operator that closes any open GroupedObservable upon a signal from another Observable (?)groupJoin(?)
— combine the items emitted by two Observables whenever one item from one Observable falls within a window of duration specified by an item emitted by the other Observablehead(?)
(scala) — see first(?)
(BlockingObservable
)headOption(?)
(scala) — see firstOrDefault(?)
or firstOrDefault(?)
(BlockingObservable
)headOrElse(?)
(scala) — see firstOrDefault(?)
or firstOrDefault(?)
(BlockingObservable
)ifThen(?)
— only emit the source Observable's sequence if a condition is true, otherwise emit an empty or default sequence (contrib-computation-expressions
)ignoreElements(?)
— discard the items emitted by the source Observable and only pass through the error or completed notificationinterval(?)
— create an Observable that emits a sequence of integers spaced by a given time intervalinto(?)
(clojure) — see reduce(?)
isEmpty(?)
— determine whether an Observable emits any items or notitems(?)
(scala) — see just(?)
join(?)
— combine the items emitted by two Observables whenever one item from one Observable falls within a window of duration specified by an item emitted by the other Observablejoin(?)
(StringObservable
) — converts an Observable that emits a sequence of strings into an Observable that emits a single string that concatenates them all, separating them by a specified stringjust(?)
— convert an object into an Observable that emits that objectlast(?)
(BlockingObservable
) — block until the Observable completes, then return the last item emitted by the Observablelast(?)
(Observable
) — emit only the last item emitted by the source ObservablelastOption(?)
(scala) — see lastOrDefault(?)
or lastOrDefault(?)
(BlockingObservable
)lastOrDefault(?)
(BlockingObservable
) — block until the Observable completes, then return the last item emitted by the Observable or a default item if there is no last itemlastOrDefault(?)
(Observable
) — emit only the last item emitted by an Observable, or a default value if the source Observable is emptylastOrElse(?)
(scala) — see lastOrDefault(?)
or lastOrDefault(?)
(BlockingObservable
)latest(?)
— returns an iterable that blocks until or unless the Observable emits an item that has not been returned by the iterable, then returns the latest such itemlength(?)
(scala) — see count(?)
limit(?)
— see take(?)
longCount(?)
(scala) — see countLong(?)
map(?)
— transform the items emitted by an Observable by applying a function to each of themmapcat(?)
(clojure) — see concatMap(?)
mapMany(?)
— see: flatMap(?)
materialize(?)
— convert an Observable into a list of Notificationsmax(?)
— emits the maximum value emitted by a source Observable (rxjava-math
)maxBy(?)
— emits the item emitted by the source Observable that has the maximum key value (rxjava-math
)merge(?)
— combine multiple Observables into onemergeDelayError(?)
— combine multiple Observables into one, allowing error-free Observables to continue before propagating errorsmerge-delay-error(?)
(clojure) — see mergeDelayError(?)
mergeMap(?)
* — see: flatMap(?)
mergeMapIterable(?)
— see: flatMapIterable(?)
mergeWith(?)
— instance version of merge(?)
min(?)
— emits the minimum value emitted by a source Observable (rxjava-math
)minBy(?)
— emits the item emitted by the source Observable that has the minimum key value (rxjava-math
)mostRecent(?)
— returns an iterable that always returns the item most recently emitted by the Observablemulticast(?)
— represents an Observable as a Connectable Observablenever(?)
— create an Observable that emits nothing at allnext(?)
— returns an iterable that blocks until the Observable emits another item, then returns that itemnonEmpty(?)
(scala) — see isEmpty(?)