按字母順序排列的全部操作符列表

• aggregate(?) — see reduce(?)
• all(?) — determine whether all items emitted by an Observable meet some criteria
• amb(?) — given two or more source Observables, emits all of the items from the first of these Observables to emit an item
• ambWith(?) — 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 time
• byLine(?) (StringObservable) — converts an Observable of Strings into an Observable of Lines by treating the source sequence as a stream and splitting it on line-endings
• cache(?) — remember the sequence of items emitted by the Observable and emit the same sequence to future Subscribers
• cast(?) — cast all items from the source Observable into a particular type before reemitting them
• catch(?) (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 structure
• combineLatest(?) — 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 function
• combineLatestWith(?) (scala) — instance version of combineLatest(?)
• concat(?) — concatenate two or more Observables sequentially
• concatMap(?) — transform the items emitted by an Observable into Observables, then flatten this into a single Observable, without interleaving
• concatWith(?) — instance version of concat(?)
• connect(?) — instructs a Connectable Observable to begin emitting items
• cons(?) (clojure) — see concat(?)
• contains(?) — determine whether an Observable emits a particular item or not
• count(?) — counts the number of items emitted by an Observable and emits this count
• countLong(?) — counts the number of items emitted by an Observable and emits this count
• create(?) — create an Observable from scratch by means of a function
• cycle(?) (clojure) — see repeat(?)
• debounce(?) — only emit an item from the source Observable after a particular timespan has passed without the Observable emitting any other items
• decode(?) (StringObservable) — convert a stream of multibyte characters into an Observable that emits byte arrays that respect character boundaries
• defaultIfEmpty(?) — emit items from the source Observable, or emit a default item if the source Observable completes after emitting no items
• defer(?) — do not create the Observable until a Subscriber subscribes; create a fresh Observable on each subscription
• deferFuture(?) — 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 amount
• dematerialize(?) — convert a materialized Observable back into its non-materialized form
• distinct(?) — suppress duplicate items emitted by the source Observable
• distinctUntilChanged(?) — suppress duplicate consecutive items emitted by the source Observable
• do(?) (clojure) — see doOnEach(?)
• doOnCompleted(?) — register an action to take when an Observable completes successfully
• doOnEach(?) — register an action to take whenever an Observable emits an item
• doOnError(?) — register an action to take when an Observable completes with an error
• doOnNext(?) — 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 Observable
• doOnTerminate(?) — register an action to take when an Observable completes, either successfully or with an error
• doOnUnsubscribe(?) — register an action to take when an observer unsubscribes from an Observable
• doWhile(?) — 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 Observable
• elementAtOrDefault(?) — emit item n emitted by the source Observable, or a default item if the source Observable emits fewer than n items
• empty(?) — create an Observable that emits nothing and then completes
• encode(?) (StringObservable) — transform an Observable that emits strings into an Observable that emits byte arrays that respect character boundaries of multibyte characters in the original strings
• error(?) — create an Observable that emits nothing and then signals an error
• every(?) (clojure) — see all(?)
• exists(?) — determine whether an Observable emits any items or not
• filter(?) — filter items emitted by an Observable
• finally(?) (clojure) — see finallyDo(?)
• filterNot(?) (scala) — see filter(?)
• finallyDo(?) — register an action to take when an Observable completes
• first(?) (Observable) — emit only the first item emitted by an Observable, or the first item that meets some condition
• first(?) (BlockingObservable) — emit only the first item emitted by an Observable, or the first item that meets some condition
• firstOrDefault(?) (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 empty
• firstOrDefault(?) (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 empty
• firstOrElse(?) (scala) — see firstOrDefault(?) or firstOrDefault(?) (BlockingObservable)
• flatMap(?) — transform the items emitted by an Observable into Observables, then flatten this into a single Observable
• flatMapIterable(?) — create Iterables corresponding to each emission from a source Observable and merge the results into a single Observable
• flatMapIterableWith(?) (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 completes
• forEachFuture(?) (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 Observable
• from(?) (StringObservable) — convert a stream of characters or a Reader into an Observable that emits byte arrays or Strings
• fromAction(?) — 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 Iterator
• groupBy(?) — divide an Observable into a set of Observables that emit groups of items from the original Observable, organized by key
• group-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 Observable
• head(?) (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 notification
• interval(?) — create an Observable that emits a sequence of integers spaced by a given time interval
• into(?) (clojure) — see reduce(?)
• isEmpty(?) — determine whether an Observable emits any items or not
• items(?) (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 Observable
• join(?) (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 string
• just(?) — convert an object into an Observable that emits that object
• last(?) (BlockingObservable) — block until the Observable completes, then return the last item emitted by the Observable
• last(?) (Observable) — emit only the last item emitted by the source Observable
• lastOption(?) (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 item
• lastOrDefault(?) (Observable) — emit only the last item emitted by an Observable, or a default value if the source Observable is empty
• lastOrElse(?) (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 item
• length(?) (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 them
• mapcat(?) (clojure) — see concatMap(?)
• mapMany(?) — see: flatMap(?)
• materialize(?) — convert an Observable into a list of Notifications
• max(?) — 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 one
• mergeDelayError(?) — combine multiple Observables into one, allowing error-free Observables to continue before propagating errors
• merge-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 Observable
• multicast(?) — represents an Observable as a Connectable Observable
• never(?) — create an Observable that emits nothing at all
• next(?) — returns an iterable that blocks until the Observable emits another item, then returns that item
• nonEmpty(?) (scala) — see isEmpty(?)
<