RxJava操作符分类
创建操作符 Creating Observables
变换操作符 Transforming Observables
过滤操作符 Filtering Observables
组合操作符 Combining Observables
错误处理操作符 Error Handling Operators
通用操作符 Observable Utility Operators
Conditional and Boolean Operators
Mathematical and Aggregate Operators
背压操作符 Backpressure Operators
Connectable Observable Operators
Operators to Convert Observables
Operators that originate new Observables.
Create
— create an Observable from scratch by calling observer methods programmaticallyDefer
— do not create the Observable until the observer subscribes, and create a fresh Observable for each observerEmpty
/Never
/Throw
— create Observables that have very precise and limited behaviorFrom
— convert some other object or data structure into an ObservableInterval
— create an Observable that emits a sequence of integers spaced by a particular time intervalJust
— convert an object or a set of objects into an Observable that emits that or those objectsRange
— create an Observable that emits a range of sequential integersRepeat
— create an Observable that emits a particular item or sequence of items repeatedlyStart
— create an Observable that emits the return value of a functionTimer
— create an Observable that emits a single item after a given delay
RxJava创建Observable的几个方法 Creating Observables · ReactiveX/RxJava Wiki · GitHub
Transforming Observables
Operators that transform items that are emitted by an Observable.
-
Buffer
— periodically gather items from an Observable into bundles and emit these bundles rather than emitting the items one at a time -
FlatMap
— transform the items emitted by an Observable into Observables, then flatten the emissions from those into a single Observable -
GroupBy
— divide an Observable into a set of Observables that each emit a different group of items from the original Observable, organized by key -
Map
— transform the items emitted by an Observable by applying a function to each item -
Scan
— apply a function to each item emitted by an Observable, sequentially, and emit each successive value -
Window
— periodically subdivide items from an Observable into Observable windows and emit these windows rather than emitting the items one at a time
Filtering Observables
Operators that selectively emit items from a source Observable.
Debounce
— only emit an item from an Observable if a particular timespan has passed without it emitting another itemDistinct
— suppress duplicate items emitted by an ObservableElementAt
— emit only item n emitted by an ObservableFilter
— emit only those items from an Observable that pass a predicate testFirst
— emit only the first item, or the first item that meets a condition, from an ObservableIgnoreElements
— do not emit any items from an Observable but mirror its termination notificationLast
— emit only the last item emitted by an ObservableSample
— emit the most recent item emitted by an Observable within periodic time intervalsSkip
— suppress the first n items emitted by an ObservableSkipLast
— suppress the last n items emitted by an ObservableTake
— emit only the first n items emitted by an ObservableTakeLast
— emit only the last n items emitted by an Observable
Combining Observables
Operators that work with multiple source Observables to create a single Observable
And
/Then
/When
— combine sets of items emitted by two or more Observables by means ofPattern
andPlan
intermediariesCombineLatest
— 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 functionJoin
— combine items emitted by two Observables whenever an item from one Observable is emitted during a time window defined according to an item emitted by the other ObservableMerge
— combine multiple Observables into one by merging their emissionsStartWith
— emit a specified sequence of items before beginning to emit the items from the source ObservableSwitch
— convert an Observable that emits Observables into a single Observable that emits the items emitted by the most-recently-emitted of those ObservablesZip
— combine the emissions of multiple Observables together via a specified function and emit single items for each combination based on the results of this function
Error Handling Operators
Operators that help to recover from error notifications from an Observable
Catch
— recover from anonError
notification by continuing the sequence without errorRetry
— if a source Observable sends anonError
notification, resubscribe to it in the hopes that it will complete without error
Observable Utility Operators
A toolbox of useful Operators for working with Observables
Delay
— shift the emissions from an Observable forward in time by a particular amountDo
— register an action to take upon a variety of Observable lifecycle eventsMaterialize
/Dematerialize
— represent both the items emitted and the notifications sent as emitted items, or reverse this processObserveOn
— specify the scheduler on which an observer will observe this ObservableSerialize
— force an Observable to make serialized calls and to be well-behavedSubscribe
— operate upon the emissions and notifications from an ObservableSubscribeOn
— specify the scheduler an Observable should use when it is subscribed toTimeInterval
— convert an Observable that emits items into one that emits indications of the amount of time elapsed between those emissionsTimeout
— mirror the source Observable, but issue an error notification if a particular period of time elapses without any emitted itemsTimestamp
— attach a timestamp to each item emitted by an ObservableUsing
— create a disposable resource that has the same lifespan as the Observable
Conditional and Boolean Operators
Operators that evaluate one or more Observables or items emitted by Observables
All
— determine whether all items emitted by an Observable meet some criteriaAmb
— given two or more source Observables, emit all of the items from only the first of these Observables to emit an itemContains
— determine whether an Observable emits a particular item or notDefaultIfEmpty
— emit items from the source Observable, or a default item if the source Observable emits nothingSequenceEqual
— determine whether two Observables emit the same sequence of itemsSkipUntil
— discard items emitted by an Observable until a second Observable emits an itemSkipWhile
— discard items emitted by an Observable until a specified condition becomes falseTakeUntil
— discard items emitted by an Observable after a second Observable emits an item or terminatesTakeWhile
— discard items emitted by an Observable after a specified condition becomes false
Mathematical and Aggregate Operators
Operators that operate on the entire sequence of items emitted by an Observable
Average
— calculates the average of numbers emitted by an Observable and emits this averageConcat
— emit the emissions from two or more Observables without interleaving themCount
— count the number of items emitted by the source Observable and emit only this valueMax
— determine, and emit, the maximum-valued item emitted by an ObservableMin
— determine, and emit, the minimum-valued item emitted by an ObservableReduce
— apply a function to each item emitted by an Observable, sequentially, and emit the final valueSum
— calculate the sum of numbers emitted by an Observable and emit this sum
Backpressure Operators
- backpressure operators — strategies for coping with Observables that produce items more rapidly than their observers consume them
Connectable Observable Operators
Specialty Observables that have more precisely-controlled subscription dynamics
Connect
— instruct a connectable Observable to begin emitting items to its subscribersPublish
— convert an ordinary Observable into a connectable ObservableRefCount
— make a Connectable Observable behave like an ordinary ObservableReplay
— ensure that all observers see the same sequence of emitted items, even if they subscribe after the Observable has begun emitting items
Operators to Convert Observables
To
— convert an Observable into another object or data structure