全部操作符列表

桃扇骨 2022-07-29 10:32 127阅读 0赞

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

*  **`aggregate( )`** — *see [**`reduce( )`**][reduce]*
 *  [**`all( )`**][all] — determine whether all items emitted by an Observable meet some criteria
 *  [**`amb( )`**][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( )`**][amb]*
 *  [**`and( )`**][and] — combine the emissions from two or more source Observables into a `Pattern` (`rxjava-joins`)
 *  **`apply( )`** (scala) — *see [**`create( )`**][create]*
 *  **`asObservable( )`** (kotlin) — *see [**`from( )`**][from] (et al.)*
 *  [**`asyncAction( )`**][asyncAction] — convert an Action into an Observable that executes the Action and emits its return value (`rxjava-async`)
 *  [**`asyncFunc( )`**][asyncAction] — convert a function into an Observable that executes the function and emits its return value (`rxjava-async`)
 *  [**`averageDouble( )`**][averageDouble] — calculates the average of Doubles emitted by an Observable and emits this average (`rxjava-math`)
 *  [**`averageFloat( )`**][averageDouble] — calculates the average of Floats emitted by an Observable and emits this average (`rxjava-math`)
 *  [**`averageInteger( )`**][averageDouble] — calculates the average of Integers emitted by an Observable and emits this average (`rxjava-math`)
 *  [**`averageLong( )`**][averageDouble] — calculates the average of Longs emitted by an Observable and emits this average (`rxjava-math`)
 *  **`blocking( )`** (clojure) — *see [**`toBlocking( )`**][toBlocking]*
 *  [**`buffer( )`**][buffer] — periodically gather items from an Observable into bundles and emit these bundles rather than emitting the items one at a time
 *  [**`byLine( )`**][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( )`**][cache] — remember the sequence of items emitted by the Observable and emit the same sequence to future Subscribers
 *  [**`cast( )`**][cast] — cast all items from the source Observable into a particular type before reemitting them
 *  **`catch( )`** (clojure) — *see [**`onErrorResumeNext( )`**][onErrorResumeNext]*
 *  [**`chunkify( )`**][chunkify] — returns an iterable that periodically returns a list of items emitted by the source Observable since the last list (⁇)
 *  [**`collect( )`**][collect] — collects items emitted by the source Observable into a single mutable data structure and returns an Observable that emits this structure
 *  [**`combineLatest( )`**][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( )`**][combineLatest 1]*
 *  **`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( )`**][concat]*
 *  [**`connect( )`**][connect] — instructs a Connectable Observable to begin emitting items
 *  **`cons( )`** (clojure) — *see **`concat( )`***
 *  [**`contains( )`**][contains] — determine whether an Observable emits a particular item or not
 *  [**`count( )`**][count] — counts the number of items emitted by an Observable and emits this count
 *  [**`countLong( )`**][count] — counts the number of items emitted by an Observable and emits this count
 *  [**`create( )`**][create 1] — create an Observable from scratch by means of a function
 *  **`cycle( )`** (clojure) — *see **`repeat( )`***
 *  [**`debounce( )`**][debounce] — only emit an item from the source Observable after a particular timespan has passed without the Observable emitting any other items
 *  [**`decode( )`**][decode] (`StringObservable`) — convert a stream of multibyte characters into an Observable that emits byte arrays that respect character boundaries
 *  [**`defaultIfEmpty( )`**][defaultIfEmpty] — emit items from the source Observable, or emit a default item if the source Observable completes after emitting no items
 *  [**`defer( )`**][defer] — do not create the Observable until a Subscriber subscribes; create a fresh Observable on each subscription
 *  [**`deferFuture( )`**][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( )`**][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( )`**][delay] — shift the emissions from an Observable forward in time by a specified amount
 *  [**`dematerialize( )`**][dematerialize] — convert a materialized Observable back into its non-materialized form
 *  [**`distinct( )`**][distinct] — suppress duplicate items emitted by the source Observable
 *  **`distinctUntilChanged( )`** — suppress duplicate consecutive items emitted by the source Observable
 *  **`do( )`** (clojure) — *see **`doOnEach( )`***
 *  [**`doOnCompleted( )`**][doOnCompleted] — register an action to take when an Observable completes successfully
 *  [**`doOnEach( )`**][doOnEach] — register an action to take whenever an Observable emits an item
 *  [**`doOnError( )`**][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( )`**][doOnSubscribe] — register an action to take when an observer subscribes to an Observable
 *  [**`doOnTerminate( )`**][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( )`**][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( )`**][skip]*
 *  **`dropRight( )`** (scala) — *see [**`skipLast( )`**][skipLast]*
 *  **`dropUntil( )`** (scala) — *see [**`skipUntil( )`**][skipUntil]*
 *  **`dropWhile( )`** (scala) — *see [**`skipWhile( )`**][skipWhile]*
 *  **`drop-while( )`** (clojure) — *see [**`skipWhile( )`**][skipWhile]*
 *  **`elementAt( )`** — emit item *n* emitted by the source Observable
 *  [**`elementAtOrDefault( )`**][elementAtOrDefault] — emit item *n* emitted by the source Observable, or a default item if the source Observable emits fewer than *n* items
 *  [**`empty( )`**][empty] — create an Observable that emits nothing and then completes
 *  [**`encode( )`**][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( )`**][empty] — create an Observable that emits nothing and then signals an error
 *  **`every( )`** (clojure) — *see [**`all( )`**][all]*
 *  [**`exists( )`**][exists] — determine whether an Observable emits any items or not
 *  [**`filter( )`**][filter] — filter items emitted by an Observable
 *  **`finally( )`** (clojure) — *see [**`finallyDo( )`**][finallyDo]*
 *  **`filterNot( )`** (scala) — *see [**`filter( )`**][filter 1]*
 *  [**`finallyDo( )`**][finallyDo] — register an action to take when an Observable completes
 *  [**`first( )`**][first] (`Observable`) — emit only the first item emitted by an Observable, or the first item that meets some condition
 *  [**`first( )`**][first 1] (`BlockingObservable`) — emit only the first item emitted by an Observable, or the first item that meets some condition
 *  [**`firstOrDefault( )`**][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( )`**][first 1] (`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( )`**][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( )`**][flatMapIterable]*
 *  **`flatMapWith( )`** (scala) — *instance version of **`flatmap( )`***
 *  **`flatten( )`** (scala) — *see [**`merge( )`**][merge]*
 *  **`flattenDelayError( )`** (scala) — *see [**`mergeDelayError( )`**][mergeDelayError]*
 *  **`foldLeft( )`** (scala) — *see [**`reduce( )`**][reduce]*
 *  **`forall( )`** (scala) — *see [**`all( )`**][all]*
 *  **`forEach( )`** (`Observable`) — *see **`subscribe( )`***
 *  **`forEach( )`** (`BlockingObservable`) — invoke a function on each item emitted by the Observable; block until the Observable completes
 *  [**`forEachFuture( )`**][forEachFuture] (`Async`) — pass Subscriber methods to an Observable but also have it behave like a Future that blocks until it completes (`rxjava-async`)
 *  [**`forEachFuture( )`**][forEachFuture 1] (`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( )`**][from 1] — convert an Iterable, a Future, or an Array into an Observable
 *  [**`from( )`**][from 2] (`StringObservable`) — convert a stream of characters or a Reader into an Observable that emits byte arrays or Strings
 *  [**`fromAction( )`**][fromAction] — convert an Action into an Observable that invokes the action and emits its result when a Subscriber subscribes (`rxjava-async`)
 *  [**`fromCallable( )`**][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( )`**][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( )`**][generate] — create an Observable that emits a sequence of items as generated by a function of your choosing (⁇)
 *  [**`generateAbsoluteTime( )`**][generate] — 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( )`**][groupBy]*
 *  [**`groupByUntil( )`**][groupByUntil] — a variant of the `groupBy( )` operator that closes any open GroupedObservable upon a signal from another Observable (⁇)
 *  [**`groupJoin( )`**][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( )`**][first 1] (`BlockingObservable`)*
 *  **`headOption( )`** (scala) — *see [**`firstOrDefault( )`**][firstOrDefault 1] or **`firstOrDefault( )`** (`BlockingObservable`)*
 *  **`headOrElse( )`** (scala) — *see [**`firstOrDefault( )`**][firstOrDefault 1] or **`firstOrDefault( )`** (`BlockingObservable`)*
 *  [**`ifThen( )`**][ifThen] — only emit the source Observable’s sequence if a condition is true, otherwise emit an empty or default sequence (`contrib-computation-expressions`)
 *  [**`ignoreElements( )`**][ignoreElements] — discard the items emitted by the source Observable and only pass through the error or completed notification
 *  [**`interval( )`**][interval] — create an Observable that emits a sequence of integers spaced by a given time interval
 *  **`into( )`** (clojure) — *see [**`reduce( )`**][reduce]*
 *  **`isEmpty( )`** — determine whether an Observable emits any items or not
 *  **`items( )`** (scala) — *see **`just( )`***
 *  [**`join( )`**][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
 *  [**`join( )`**][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( )`**][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( )`**][last] (`Observable`) — emit only the last item emitted by the source Observable
 *  **`lastOption( )`** (scala) — *see [**`lastOrDefault( )`**][lastOrDefault] or **`lastOrDefault( )`** (`BlockingObservable`)*
 *  [**`lastOrDefault( )`**][lastOrDefault 1] (`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( )`***
 *  **`nth( )`** (clojure) — *see **`elementAt( )`** and **`elementAtOrDefault( )`***
 *  **`observeOn( )`** — specify on which Scheduler a Subscriber should observe the Observable
 *  **`ofType( )`** — emit only those items from the source Observable that are of a particular class
 *  **`onBackpressureBlock( )`** — block the Observable’s thread until the Observer is ready to accept more items from the Observable (⁇)
 *  **`onBackpressureBuffer( )`** — maintain a buffer of all emissions from the source Observable and emit them to downstream Subscribers according to the requests they generate
 *  **`onBackpressureDrop( )`** — drop emissions from the source Observable unless there is a pending request from a downstream Subscriber, in which case emit enough items to fulfill the request
 *  **`onErrorFlatMap( )`** — instructs an Observable to emit a sequence of items whenever it encounters an error (⁇)
 *  **`onErrorResumeNext( )`** — instructs an Observable to emit a sequence of items if it encounters an error
 *  **`onErrorReturn( )`** — instructs an Observable to emit a particular item when it encounters an error
 *  **`onExceptionResumeNext( )`** — instructs an Observable to continue emitting items after it encounters an exception (but not another variety of throwable)
 *  **`orElse( )`** (scala) — *see **`defaultIfEmpty( )`***
 *  **`parallel( )`** — split the work done on the emissions from an Observable into multiple Observables each operating on its own parallel thread (⁇)
 *  **`parallelMerge( )`** — combine multiple Observables into smaller number of Observables (⁇)
 *  **`pivot( )`** — combine multiple sets of grouped observables so that they are arranged primarily by group rather than by set (⁇)
 *  **`publish( )`** — represents an Observable as a Connectable Observable
 *  **`publishLast( )`** — represent an Observable as a Connectable Observable that emits only the last item emitted by the source Observable (⁇)
 *  **`range( )`** — create an Observable that emits a range of sequential integers
 *  **`reduce( )`** — apply a function to each emitted item, sequentially, and emit only the final accumulated value
 *  **`reductions( )`** (clojure) — *see **`scan( )`***
 *  **`refCount( )`** — makes a Connectable Observable behave like an ordinary Observable
 *  **`repeat( )`** — create an Observable that emits a particular item or sequence of items repeatedly
 *  **`repeatWhen( )`** — create an Observable that emits a particular item or sequence of items repeatedly, depending on the emissions of a second Observable
 *  **`replay( )`** — ensures that all Subscribers see the same sequence of emitted items, even if they subscribe after the Observable begins emitting the items
 *  **`rest( )`** (clojure) — *see **`next( )`***
 *  **`return( )`** (clojure) — *see **`just( )`***
 *  **`retry( )`** — if a source Observable emits an error, resubscribe to it in the hopes that it will complete without error
 *  **`retrywhen( )`** — if a source Observable emits an error, pass that error to another Observable to determine whether to resubscribe to the source
 *  **`runAsync( )`** — returns a `StoppableObservable` that emits multiple actions as generated by a specified Action on a Scheduler (`rxjava-async`)
 *  **`sample( )`** — emit the most recent items emitted by an Observable within periodic time intervals
 *  **`scan( )`** — apply a function to each item emitted by an Observable, sequentially, and emit each successive value
 *  **`seq( )`** (clojure) — *see **`getIterator( )`***
 *  **`sequenceEqual( )`** — test the equality of sequences emitted by two Observables
 *  **`sequenceEqualWith( )`** (scala) — *instance version of **`sequenceEqual( )`***
 *  **`serialize( )`** — force an Observable to make serialized calls and to be well-behaved
 *  **`share( )`** — *see **`refCount( )`***
 *  **`single( )`** (`BlockingObservable`) — if the source Observable completes after emitting a single item, return that item, otherwise throw an exception
 *  **`single( )`** (`Observable`) — if the source Observable completes after emitting a single item, emit that item, otherwise notify of an exception
 *  **`singleOption( )`** (scala) — *see **`singleOrDefault( )`** (`BlockingObservable`)*
 *  **`singleOrDefault( )`** (`BlockingObservable`) — if the source Observable completes after emitting a single item, return that item, otherwise return a default item
 *  **`singleOrDefault( )`** (`Observable`) — if the source Observable completes after emitting a single item, emit that item, otherwise emit a default item
 *  **`singleOrElse( )`** (scala) — *see **`singleOrDefault( )`***
 *  **`size( )`** (scala) — *see **`count( )`***
 *  **`skip( )`** — ignore the first *n* items emitted by an Observable
 *  **`skipLast( )`** — ignore the last *n* items emitted by an Observable
 *  **`skipUntil( )`** — discard items emitted by a source Observable until a second Observable emits an item, then emit the remainder of the source Observable’s items
 *  **`skipWhile( )`** — discard items emitted by an Observable until a specified condition is false, then emit the remainder
 *  **`sliding( )`** (scala) — *see **`window( )`***
 *  **`slidingBuffer( )`** (scala) — *see **`buffer( )`***
 *  [**`split( )`**][split] (`StringObservable`) — converts an Observable of Strings into an Observable of Strings that treats the source sequence as a stream and splits it on a specified regex boundary
 *  [**`start( )`**][start] — create an Observable that emits the return value of a function (`rxjava-async`)
 *  **`startCancellableFuture( )`** — convert a function that returns Future into an Observable that emits that Future’s return value in a way that monitors the subscription status of the Observable to determine whether to halt work on the Future (⁇)(`rxjava-async`)
 *  [**`startFuture( )`**][startFuture] — convert a function that returns Future into an Observable that emits that Future’s return value (`rxjava-async`)
 *  [**`startWith( )`**][startWith] — emit a specified sequence of items before beginning to emit the items from the Observable
 *  [**`stringConcat( )`**][stringConcat] (`StringObservable`) — converts an Observable that emits a sequence of strings into an Observable that emits a single string that concatenates them all
 *  [**`subscribeOn( )`**][subscribeOn] — specify which Scheduler an Observable should use when its subscription is invoked
 *  [**`sumDouble( )`**][sumDouble] — adds the Doubles emitted by an Observable and emits this sum (`rxjava-math`)
 *  [**`sumFloat( )`**][sumDouble] — adds the Floats emitted by an Observable and emits this sum (`rxjava-math`)
 *  [**`sumInteger( )`**][sumDouble] — adds the Integers emitted by an Observable and emits this sum (`rxjava-math`)
 *  **`sumLong( )`** — adds the Longs emitted by an Observable and emits this sum (`rxjava-math`)
 *  **`switch( )`** (scala) — *see [**`switchOnNext( )`**][switchOnNext]*
 *  [**`switchCase( )`**][switchCase] — emit the sequence from a particular Observable based on the results of an evaluation (`contrib-computation-expressions`)
 *  [**`switchMap( )`**][switchMap] — transform the items emitted by an Observable into Observables, and mirror those items emitted by the most-recently transformed Observable
 *  [**`switchOnNext( )`**][switchOnNext 1] — convert an Observable that emits Observables into a single Observable that emits the items emitted by the most-recently emitted of those Observables
 *  **`synchronize( )`** — *see **`serialize( )`***
 *  [**`take( )`**][take] — emit only the first *n* items emitted by an Observable
 *  [**`takeFirst( )`**][first] — emit only the first item emitted by an Observable, or the first item that meets some condition
 *  [**`takeLast( )`**][takeLast] — only emit the last *n* items emitted by an Observable
 *  [**`takeLastBuffer( )`**][takeLastBuffer] — emit the last *n* items emitted by an Observable, as a single list item
 *  **`takeRight( )`** (scala) — *see [**`last( )`**][last 1] (`Observable`) or **`takeLast( )`***
 *  [**`takeUntil( )`**][takeUntil] — emits the items from the source Observable until a second Observable emits an item
 *  [**`takeWhile( )`**][takeWhile] — emit items emitted by an Observable as long as a specified condition is true, then skip the remainder
 *  **`take-while( )`** (clojure) — *see [**`takeWhile( )`**][takeWhile]*
 *  [**`then( )`**][and] — transform a series of `Pattern` objects via a `Plan` template (`rxjava-joins`)
 *  [**`throttleFirst( )`**][throttleFirst] — emit the first items emitted by an Observable within periodic time intervals
 *  [**`throttleLast( )`**][throttleLast] — emit the most recent items emitted by an Observable within periodic time intervals
 *  [**`throttleWithTimeout( )`**][debounce] — only emit an item from the source Observable after a particular timespan has passed without the Observable emitting any other items
 *  **`throw( )`** (clojure) — *see [**`error( )`**][error]*
 *  [**`timeInterval( )`**][timeInterval] — emit the time lapsed between consecutive emissions of a source Observable
 *  [**`timeout( )`**][timeout] — emit items from a source Observable, but issue an exception if no item is emitted in a specified timespan
 *  [**`timer( )`**][timer] — create an Observable that emits a single item after a given delay
 *  [**`timestamp( )`**][timestamp] — attach a timestamp to every item emitted by an Observable
 *  [**`toAsync( )`**][asyncAction] — convert a function or Action into an Observable that executes the function and emits its return value (`rxjava-async`)
 *  [**`toBlocking( )`**][toBlocking] — transform an Observable into a BlockingObservable
 *  **`toBlockingObservable( )`** \- *see [**`toBlocking( )`**][toBlocking]*
 *  [**`toFuture( )`**][toFuture] — convert the Observable into a Future
 *  [**`toIterable( )`**][toFuture] — convert the sequence emitted by the Observable into an Iterable
 *  **`toIterator( )`** — *see [**`getIterator( )`**][toFuture]*
 *  **`toList( )`** — collect all items from an Observable and emit them as a single List
 *  **`toMap( )`** — convert the sequence of items emitted by an Observable into a map keyed by a specified key function
 *  **`toMultimap( )`** — convert the sequence of items emitted by an Observable into an ArrayList that is also a map keyed by a specified key function
 *  **`toSeq( )`** (scala) — *see **`toList( )`***
 *  **`toSortedList( )`** — collect all items from an Observable and emit them as a single, sorted List
 *  **`tumbling( )`** (scala) — *see **`window( )`***
 *  **`tumblingBuffer( )`** (scala) — *see **`buffer( )`***
 *  [**`using( )`**][using] — create a disposable resource that has the same lifespan as an Observable
 *  [**`when( )`**][and] — convert a series of `Plan` objects into an Observable (`rxjava-joins`)
 *  **`where( )`** — *see: [**`filter( )`**][filter 1]*
 *  [**`whileDo( )`**][whileDo] — if a condition is true, emit the source Observable’s sequence and then repeat the sequence as long as the condition remains true (`contrib-computation-expressions`)
 *  [**`window( )`**][window] — periodically subdivide items from an Observable into Observable windows and emit these windows rather than emitting the items one at a time
 *  [**`zip( )`**][zip] — combine sets of items emitted by two or more Observables together via a specified function and emit items based on the results of this function
 *  **`zipWith( )`** — *instance version of [**`zip( )`**][zip 1]*
 *  **`zipWithIndex( )`** (scala) — *see [**`zip( )`**][zip 1]*
 *  **`++`** (scala) — *see [**`concat( )`**][concat]*
 *  **`+:`** (scala) — *see [**`startWith( )`**][startWith 1]*

(⁇) — 表示这个操作符不是RxJava 1.0.0核心模块的组成部分

[reduce]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Mathematical-and-Aggregate-Operators.md#reduce
[all]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Conditional-and-Boolean-Operators.md#all
[amb]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Conditional-and-Boolean-Operators.md#amb
[and]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Combining-Observables.md#and-then-and-when
[create]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Creating-Observables#create
[from]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Creating-Observables#from
[asyncAction]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Async-Operators.md#toasync-or-asyncaction-or-asyncfunc
[averageDouble]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Mathematical-and-Aggregate-Operators.md#averageinteger-averagelong-averagefloat-and-averagedouble
[toBlocking]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Blocking-Observable-Operators
[buffer]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Transforming-Observables.md#buffer
[byLine]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/String-Observables.md#byline
[cache]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Observable-Utility-Operators.md#cache
[cast]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Transforming-Observables.md#cast
[onErrorResumeNext]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Error-Handling-Operators.md#onerrorresumenext
[chunkify]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Phantom-Operators.md#chunkify
[collect]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Mathematical-and-Aggregate-Operators.md#collect
[combineLatest]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Combining-Observables.md#combinelatest
[combineLatest 1]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Combining-Observables#combinelatest
[concat]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Mathematical-and-Aggregate-Operators.md#concat
[connect]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Connectable-Observable-Operators.md#connectableobservableconnect
[contains]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Conditional-and-Boolean-Operators.md#contains
[count]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Mathematical-and-Aggregate-Operators.md#count-and-countlong
[create 1]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Creating-Observables.md#create
[debounce]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Filtering-Observables.md#throttlewithtimeout-or-debounce
[decode]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/String-Observables.md#decode
[defaultIfEmpty]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Conditional-and-Boolean-Operators.md#defaultifempty
[defer]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Creating-Observables.md#defer
[deferFuture]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Async-Operators.md#deferfuture
[deferCancellableFuture]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Phantom-Operators.md#fromcancellablefuture-startcancellablefuture-and-defercancellablefuture-
[delay]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Observable-Utility-Operators.md#delay
[dematerialize]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Observable-Utility-Operators.md#dematerialize
[distinct]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Filtering-Observables.md#distinct
[doOnCompleted]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Observable-Utility-Operators.md#dooncompleted
[doOnEach]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Observable-Utility-Operators.md#dooneach
[doOnError]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Observable-Utility-Operators.md#doonerror
[doOnSubscribe]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Observable-Utility-Operators.md#doonsubscribe
[doOnTerminate]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Observable-Utility-Operators.md#doonterminate
[doWhile]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Conditional-and-Boolean-Operators.md#dowhile
[skip]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Filtering-Observables#skip
[skipLast]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Filtering-Observables#skiplast
[skipUntil]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Conditional-and-Boolean-Operators.md#skipuntil
[skipWhile]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Conditional-and-Boolean-Operators.md#skipwhile
[elementAtOrDefault]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Filtering-Observables.md#elementatordefault
[empty]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Creating-Observables.md#empty-error-and-never
[encode]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/String-Observables.md#encode
[exists]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Conditional-and-Boolean-Operators.md#exists-and-isempty
[filter]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Filtering-Observables.md#filter
[finallyDo]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Observable-Utility-Operators.md#finallydo
[filter 1]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Filtering-Observables#filter
[first]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Filtering-Observables.md#first-and-takefirst
[first 1]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Blocking-Observable-Operators.md#first-and-firstordefault
[firstOrDefault]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Filtering-Observables.md#firstordefault
[flatMap]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Transforming-Observables.md#flatmap-concatmap-and-flatmapiterable
[flatMapIterable]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Transforming-Observables#flatmap-concatmap-and-flatmapiterable
[merge]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Combining-Observables#merge
[mergeDelayError]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Combining-Observables#mergedelayerror
[forEachFuture]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Async-Operators.md#foreachfuture
[forEachFuture 1]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Phantom-Operators.md#foreachfuture
[from 1]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Creating-Observables.md#from
[from 2]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/String-Observables.md#from
[fromAction]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Async-Operators.md#fromaction
[fromCallable]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Async-Operators.md#fromcallable
[generate]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Phantom-Operators.md#generate-and-generateabsolutetime
[groupBy]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Transforming-Observables#groupby
[groupByUntil]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Phantom-Operators.md#groupbyuntil
[groupJoin]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Combining-Observables.md#join-and-groupjoin
[firstOrDefault 1]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Filtering-Observables#firstordefault
[ifThen]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Conditional-and-Boolean-Operators.md#ifthen
[ignoreElements]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Filtering-Observables.md#ignoreelements
[interval]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Creating-Observables.md#interval
[join]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/String-Observables.md#join
[just]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Creating-Observables.md#just
[last]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Filtering-Observables.md#last
[lastOrDefault]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Filtering-Observables#lastOrDefault
[lastOrDefault 1]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Blocking-Observable-Operators.md#last-and-lastordefault
[split]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/String-Observables.md#split
[start]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Async-Operators.md#start
[startFuture]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Async-Operators.md#startfuture
[startWith]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Combining-Observables.md#startwith
[stringConcat]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/String-Observables.md#stringconcat
[subscribeOn]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Observable-Utility-Operators.md#subscribeon
[sumDouble]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Mathematical-and-Aggregate-Operators.md#suminteger-sumlong-sumfloat-and-sumdouble
[switchOnNext]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Combining-Observables#switchonnext
[switchCase]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Conditional-and-Boolean-Operators.md#switchcase
[switchMap]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Transforming-Observables.md#switchmap
[switchOnNext 1]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Combining-Observables.md#switchonnext
[take]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Filtering-Observables.md#take
[takeLast]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Filtering-Observables.md#takelast
[takeLastBuffer]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Filtering-Observables.md#takelastbuffer
[last 1]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Filtering-Observables#last
[takeUntil]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Conditional-and-Boolean-Operators.md#takeuntil
[takeWhile]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Conditional-and-Boolean-Operators.md#takewhile
[throttleFirst]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Filtering-Observables.md#throttlefirst
[throttleLast]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Filtering-Observables.md#sample-or-throttlelast
[error]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Creating-Observables#empty-error-and-never
[timeInterval]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Observable-Utility-Operators.md#timeinterval
[timeout]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Filtering-Observables.md#timeout
[timer]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Creating-Observables.md#timer
[timestamp]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Observable-Utility-Operators.md#timestamp
[toFuture]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Blocking-Observable-Operators.md#transformations-tofuture-toiterable-and-getiterator
[using]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Observable-Utility-Operators.md#using
[whileDo]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Conditional-and-Boolean-Operators.md#whiledo
[window]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Transforming-Observables.md#window
[zip]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Combining-Observables.md#zip
[zip 1]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Combining-Observables#zip
[startWith 1]: https://github.com/mcxiaoke/RxDocs/blob/master/operators/Combining-Observables#startwith