Operator Matrix

Operator
`all`			⁽¹⁾	⁽¹⁾	⁽²⁾
`amb`
`ambArray`
`ambWith`
`andThen`	⁽³⁾	⁽³⁾	⁽³⁾	⁽³⁾
`any`			⁽¹⁾	⁽¹⁾	⁽²⁾
`blockingAwait`	⁽⁴⁾	⁽⁴⁾	⁽⁵⁾	⁽⁵⁾
`blockingFirst`			⁽⁶⁾	⁽⁶⁾	⁽⁷⁾
`blockingForEach`			⁽⁸⁾	⁽⁸⁾	⁽⁸⁾
`blockingGet`	⁽⁴⁾	⁽⁴⁾			⁽⁷⁾
`blockingIterable`			⁽⁶⁾	⁽⁶⁾	⁽⁷⁾
`blockingLast`			⁽⁶⁾	⁽⁶⁾	⁽⁷⁾
`blockingLatest`			⁽⁶⁾	⁽⁶⁾	⁽⁷⁾
`blockingMostRecent`			⁽⁶⁾	⁽⁶⁾	⁽⁷⁾
`blockingNext`			⁽⁶⁾	⁽⁶⁾	⁽⁷⁾
`blockingSingle`			⁽⁶⁾	⁽⁶⁾	⁽⁷⁾
`blockingStream`			⁽⁶⁾	⁽⁶⁾	⁽⁷⁾
`blockingSubscribe`
`buffer`			⁽⁹⁾	⁽¹⁰⁾	⁽¹¹⁾
`cache`
`cacheWithInitialCapacity`			⁽¹²⁾	⁽¹²⁾	⁽¹²⁾
`cast`					⁽²⁾
`collect`			⁽¹³⁾	⁽¹⁴⁾	⁽¹⁵⁾
`collectInto`			⁽¹³⁾	⁽¹⁴⁾	⁽¹⁵⁾
`combineLatest`			⁽¹⁶⁾	⁽¹⁶⁾	⁽¹⁷⁾
`combineLatestArray`			⁽¹⁸⁾	⁽¹⁸⁾	⁽¹⁹⁾
`combineLatestArrayDelayError`			⁽¹⁸⁾	⁽¹⁸⁾	⁽²⁰⁾
`combineLatestDelayError`			⁽¹⁶⁾	⁽¹⁶⁾	⁽²¹⁾
`complete`	⁽²²⁾	⁽²²⁾	⁽²²⁾	⁽²³⁾
`compose`
`concat`
`concatArray`
`concatArrayDelayError`
`concatArrayEager`					⁽²⁴⁾
`concatArrayEagerDelayError`					⁽²⁵⁾
`concatDelayError`
`concatEager`					⁽²⁶⁾
`concatMap`					⁽²⁷⁾
`concatMapCompletable`					⁽²⁷⁾
`concatMapCompletableDelayError`					⁽²⁷⁾
`concatMapDelayError`
`concatMapEager`
`concatMapEagerDelayError`
`concatMapIterable`			⁽²⁸⁾	⁽²⁸⁾	⁽²⁷⁾
`concatMapMaybe`					⁽²⁷⁾
`concatMapMaybeDelayError`					⁽²⁷⁾
`concatMapSingle`					⁽²⁷⁾
`concatMapSingleDelayError`					⁽²⁷⁾
`concatMapStream`			⁽²⁹⁾	⁽²⁹⁾	⁽²⁷⁾
`concatWith`
`contains`					⁽²⁾
`count`				⁽³⁰⁾	⁽³¹⁾
`create`
`debounce`			⁽³²⁾	⁽³²⁾	⁽³³⁾
`defaultIfEmpty`				⁽²³⁾	⁽³⁴⁾
`defer`
`delay`
`delaySubscription`
`dematerialize`					⁽³³⁾
`distinct`			⁽³⁵⁾	⁽³⁵⁾	⁽³³⁾
`distinctUntilChanged`			⁽³⁵⁾	⁽³⁵⁾	⁽³³⁾
`doAfterNext`			⁽³⁶⁾	⁽³⁶⁾	⁽²⁾
`doAfterSuccess`	⁽³⁷⁾	⁽³⁷⁾			⁽³³⁾
`doAfterTerminate`
`doFinally`
`doOnCancel`		⁽³⁸⁾	⁽³⁸⁾	⁽³⁸⁾	⁽³⁸⁾
`doOnComplete`				⁽³⁹⁾
`doOnDispose`	⁽⁴⁰⁾
`doOnEach`			⁽⁴¹⁾	⁽⁴¹⁾	⁽³³⁾
`doOnError`
`doOnEvent`	⁽⁴²⁾	⁽⁴²⁾
`doOnLifecycle`
`doOnNext`			⁽⁴³⁾	⁽⁴³⁾	⁽³³⁾
`doOnRequest`		⁽⁴⁴⁾	⁽⁴⁴⁾	⁽⁴⁴⁾	⁽⁴⁴⁾
`doOnSubscribe`
`doOnSuccess`	⁽⁴⁵⁾	⁽⁴⁵⁾			⁽³³⁾
`doOnTerminate`
`elementAt`			⁽⁴⁶⁾	⁽⁴⁷⁾	⁽³³⁾
`elementAtOrError`			⁽⁴⁸⁾	⁽⁴⁷⁾	⁽³³⁾
`empty`				⁽²³⁾	⁽⁴⁹⁾
`error`
`filter`					⁽³³⁾
`first`			⁽⁵⁰⁾	⁽⁵¹⁾	⁽³⁴⁾
`firstElement`			⁽⁵²⁾	⁽⁵³⁾	⁽²⁾
`firstOrError`			⁽⁵²⁾	⁽⁵³⁾	⁽⁵⁴⁾
`firstOrErrorStage`			⁽⁵⁵⁾	⁽⁵⁵⁾	⁽⁵⁶⁾
`firstStage`			⁽⁵⁵⁾	⁽⁵⁵⁾	⁽⁵⁵⁾
`flatMap`					⁽²⁷⁾
`flatMapCompletable`					⁽²⁷⁾
`flatMapIterable`			⁽²⁸⁾	⁽²⁸⁾	⁽²⁷⁾
`flatMapMaybe`			⁽⁵⁷⁾		⁽²⁷⁾
`flatMapObservable`	⁽⁵⁸⁾	⁽⁵⁹⁾			⁽²⁷⁾
`flatMapPublisher`	⁽⁵⁹⁾	⁽⁶⁰⁾			⁽²⁷⁾
`flatMapSingle`					⁽²⁷⁾
`flatMapSingleElement`	⁽⁶¹⁾	⁽⁶¹⁾		⁽⁵⁹⁾	⁽²⁷⁾
`flatMapStream`			⁽²⁹⁾	⁽²⁹⁾	⁽²⁷⁾
`flattenAsFlowable`	⁽⁶²⁾	⁽⁶²⁾			⁽²⁷⁾
`flattenAsObservable`	⁽⁶²⁾	⁽⁶²⁾			⁽²⁷⁾
`flattenStreamAsFlowable`	⁽⁶³⁾	⁽⁶³⁾			⁽²⁷⁾
`flattenStreamAsObservable`	⁽⁶³⁾	⁽⁶³⁾			⁽²⁷⁾
`forEach`			⁽⁶⁴⁾	⁽⁶⁴⁾	⁽⁶⁴⁾
`forEachWhile`			⁽⁶⁴⁾	⁽⁶⁴⁾	⁽⁶⁴⁾
`fromAction`
`fromArray`			⁽⁶⁵⁾	⁽⁶⁶⁾	⁽⁶⁷⁾
`fromCallable`
`fromCompletable`				⁽⁶⁸⁾	⁽⁶⁹⁾
`fromCompletionStage`
`fromFuture`
`fromIterable`			⁽⁶⁵⁾	⁽⁶⁶⁾	⁽⁶⁷⁾
`fromMaybe`			⁽⁶⁹⁾
`fromObservable`		⁽⁶⁹⁾
`fromOptional`				⁽⁶⁶⁾	⁽⁶⁷⁾
`fromPublisher`
`fromRunnable`
`fromSingle`
`fromStream`			⁽⁶⁵⁾	⁽⁶⁶⁾	⁽⁶⁷⁾
`fromSupplier`
`generate`			⁽⁷⁰⁾	⁽⁷⁰⁾	⁽⁷⁰⁾
`groupBy`			⁽⁷¹⁾	⁽⁷¹⁾	⁽⁷²⁾
`groupJoin`			⁽⁷¹⁾	⁽⁷¹⁾	⁽⁷³⁾
`hide`
`ignoreElement`	⁽⁷⁴⁾	⁽⁷⁴⁾			⁽²⁾
`ignoreElements`			⁽⁷⁵⁾	⁽⁷⁵⁾	⁽²⁾
`interval`			⁽⁷⁶⁾	⁽⁷⁶⁾	⁽⁷⁶⁾
`intervalRange`			⁽⁷⁶⁾	⁽⁷⁶⁾	⁽⁷⁶⁾
`isEmpty`				⁽⁵¹⁾	⁽²⁾
`join`			⁽⁷⁷⁾	⁽⁷⁷⁾	⁽⁷³⁾
`just`
`last`			⁽⁵⁰⁾	⁽⁵¹⁾	⁽³⁴⁾
`lastElement`			⁽⁵²⁾	⁽⁵³⁾	⁽²⁾
`lastOrError`			⁽⁵²⁾	⁽⁵³⁾	⁽⁵⁴⁾
`lastOrErrorStage`			⁽⁵⁵⁾	⁽⁵⁵⁾	⁽⁵⁶⁾
`lastStage`			⁽⁵⁵⁾	⁽⁵⁵⁾	⁽⁵⁵⁾
`lift`
`map`					⁽²⁷⁾
`mapOptional`					⁽²⁷⁾
`materialize`
`merge`
`mergeArray`
`mergeArrayDelayError`
`mergeDelayError`
`mergeWith`
`never`
`observeOn`
`ofType`					⁽⁷⁸⁾
`onBackpressureBuffer`		⁽⁴⁴⁾	⁽⁴⁴⁾	⁽⁴⁴⁾	⁽⁴⁴⁾
`onBackpressureDrop`		⁽⁴⁴⁾	⁽⁴⁴⁾	⁽⁴⁴⁾	⁽⁴⁴⁾
`onBackpressureLatest`		⁽⁴⁴⁾	⁽⁴⁴⁾	⁽⁴⁴⁾	⁽⁴⁴⁾
`onErrorComplete`
`onErrorResumeNext`
`onErrorResumeWith`
`onErrorReturn`
`onErrorReturnItem`
`onTerminateDetach`
`parallel`		⁽⁷⁹⁾	⁽⁷⁹⁾	⁽⁷⁹⁾	⁽⁷⁹⁾
`publish`			⁽⁸⁰⁾	⁽⁸¹⁾	⁽⁸²⁾
`range`			⁽⁸³⁾	⁽⁸³⁾	⁽⁶⁷⁾
`rangeLong`			⁽⁸³⁾	⁽⁸³⁾	⁽⁶⁷⁾
`rebatchRequests`		⁽⁴⁴⁾	⁽⁴⁴⁾	⁽⁴⁴⁾	⁽⁴⁴⁾
`reduce`			⁽⁸⁴⁾	⁽⁸⁴⁾	⁽⁸⁵⁾
`reduceWith`			⁽⁸⁴⁾	⁽⁸⁴⁾	⁽⁸⁵⁾
`repeat`
`repeatUntil`
`repeatWhen`
`replay`			⁽⁸⁰⁾	⁽⁸¹⁾	⁽⁸²⁾
`retry`
`retryUntil`
`retryWhen`
`safeSubscribe`
`sample`			⁽⁵²⁾	⁽⁵²⁾	⁽³³⁾
`scan`			⁽⁸⁴⁾	⁽⁸⁴⁾	⁽⁸⁵⁾
`scanWith`			⁽⁸⁴⁾	⁽⁸⁴⁾	⁽⁸⁵⁾
`sequenceEqual`
`serialize`			⁽⁸⁶⁾	⁽⁸⁶⁾	⁽⁸⁶⁾
`share`			⁽⁸⁰⁾	⁽⁸¹⁾	⁽⁸²⁾
`single`			⁽⁵⁰⁾	⁽⁵¹⁾	⁽³⁴⁾
`singleElement`			⁽⁵²⁾	⁽⁵³⁾	⁽²⁾
`singleOrError`			⁽⁵²⁾	⁽⁵³⁾	⁽⁵⁴⁾
`singleOrErrorStage`			⁽⁵⁵⁾	⁽⁵⁵⁾	⁽⁵⁶⁾
`singleStage`			⁽⁵⁵⁾	⁽⁵⁵⁾	⁽⁵⁵⁾
`skip`			⁽⁵²⁾	⁽⁵²⁾	⁽⁵²⁾
`skipLast`			⁽⁵²⁾	⁽⁵²⁾	⁽⁵²⁾
`skipUntil`			⁽⁸⁷⁾	⁽⁸⁷⁾	⁽⁸⁷⁾
`skipWhile`			⁽⁸⁸⁾	⁽⁸⁸⁾	⁽²⁾
`sorted`			⁽⁷¹⁾	⁽⁷¹⁾	⁽⁷¹⁾
`startWith`
`startWithArray`			⁽⁸⁹⁾	⁽⁸⁹⁾	⁽⁸⁹⁾
`startWithItem`			⁽⁹⁰⁾	⁽⁹⁰⁾	⁽⁹⁰⁾
`startWithIterable`			⁽⁹¹⁾	⁽⁹¹⁾	⁽⁹¹⁾
`subscribe`
`subscribeOn`
`subscribeWith`
`switchIfEmpty`				⁽²³⁾	⁽⁹²⁾
`switchMap`			⁽⁹³⁾	⁽⁹³⁾	⁽²⁷⁾
`switchMapCompletable`			⁽⁹³⁾	⁽⁹³⁾	⁽²⁷⁾
`switchMapCompletableDelayError`			⁽⁹³⁾	⁽⁹³⁾	⁽²⁷⁾
`switchMapDelayError`			⁽⁹³⁾	⁽⁹³⁾	⁽²⁷⁾
`switchMapMaybe`			⁽⁹³⁾	⁽⁹³⁾	⁽²⁷⁾
`switchMapMaybeDelayError`			⁽⁹³⁾	⁽⁹³⁾	⁽²⁷⁾
`switchMapSingle`			⁽⁹³⁾	⁽⁹³⁾	⁽²⁷⁾
`switchMapSingleDelayError`			⁽⁹³⁾	⁽⁹³⁾	⁽²⁷⁾
`switchOnNext`
`switchOnNextDelayError`
`take`			⁽⁵²⁾	⁽⁵²⁾	⁽⁵²⁾
`takeLast`			⁽⁵²⁾	⁽⁵²⁾	⁽⁵²⁾
`takeUntil`
`takeWhile`			⁽⁸⁸⁾	⁽⁸⁸⁾	⁽²⁾
`test`
`throttleFirst`			⁽³²⁾	⁽³²⁾	⁽³³⁾
`throttleLast`			⁽³²⁾	⁽³²⁾	⁽³³⁾
`throttleLatest`			⁽³²⁾	⁽³²⁾	⁽³³⁾
`throttleWithTimeout`			⁽³²⁾	⁽³²⁾	⁽³³⁾
`timeInterval`
`timeout`
`timer`
`timestamp`					⁽³³⁾
`to`
`toCompletionStage`	⁽⁹⁴⁾	⁽⁹⁴⁾
`toFlowable`	⁽⁹⁵⁾
`toFuture`
`toList`			⁽¹³⁾	⁽¹⁴⁾	⁽¹⁵⁾
`toMap`			⁽¹³⁾	⁽¹⁴⁾	⁽¹⁵⁾
`toMaybe`	⁽⁹⁶⁾	⁽⁹⁶⁾	⁽⁹⁵⁾
`toMultimap`			⁽¹³⁾	⁽¹⁴⁾	⁽¹⁵⁾
`toObservable`		⁽⁹⁵⁾
`toSingle`	⁽⁹⁷⁾	⁽⁹⁷⁾		⁽⁹⁵⁾
`toSingleDefault`	⁽⁹⁸⁾	⁽⁹⁸⁾	⁽⁹⁹⁾	⁽⁹⁵⁾
`toSortedList`			⁽¹³⁾	⁽¹⁴⁾	⁽¹⁵⁾
`unsafeCreate`
`unsubscribeOn`
`using`
`window`			⁽¹⁰⁰⁾	⁽¹⁰¹⁾	⁽¹⁰²⁾
`withLatestFrom`			⁽¹⁶⁾	⁽¹⁶⁾	⁽¹⁷⁾
`wrap`	⁽¹⁰³⁾
`zip`					⁽¹⁰⁴⁾
`zipArray`					⁽¹⁰⁵⁾
`zipWith`					⁽¹⁰⁶⁾

Notes

¹ Use contains().
² Always empty.
³ Use concatWith.
⁴ Use blockingFirst(), blockingSingle() or blockingLast().
⁵ Use blockingGet().
⁶ At most one element to get. Use blockingGet().
⁷ No elements to get. Use blockingAwait().
⁸ Use blockingSubscribe()
⁹ Use map() and switchIfEmpty() to transform into a list/collection.
¹⁰ Use map() to transform into a list/collection.
¹¹ Always empty. Use andThen() to bring in a list/collection.
¹² At most one element to store. Use cache().
¹³ At most one element to collect. Use map() and switchIfEmpty() to transform into a list/collection.
¹⁴ One element to collect. Use map() to transform into a list/collection.
¹⁵ Always empty. Use andThen() to bring in a collection.
¹⁶ At most one element per source. Use zip().
¹⁷ Always empty. Use merge().
¹⁸ At most one element per source. Use zipArray().
¹⁹ Always empty. Use mergeArray().
²⁰ Always empty. Use mergeArrayDelayError().
²¹ Always empty. Use mergeDelayError().
²² Use empty().
²³ Never empty.
²⁴ No items to keep ordered. Use mergeArray().
²⁵ No items to keep ordered. Use mergeArrayDelayError().
²⁶ No items to keep ordered. Use merge().
²⁷ Always empty thus no items to map.
²⁸ At most one item. Use flattenAsFlowable or flattenAsObservable.
²⁹ At most one item. Use flattenStreamAsFlowable or flattenStreamAsObservable.
³⁰ Never empty thus always 1.
³¹ Always empty thus always 0.
³² At most one item signaled so no subsequent items to work with.
³³ Always empty thus no items to work with.
³⁴ Always empty. Use andThen() to chose the follow-up sequence.
³⁵ At most one item, always distinct.
³⁶ Different terminology. Use doAfterSuccess().
³⁷ Different terminology. Use doAfterNext().
³⁸ Different terminology. Use doOnDispose().
³⁹ Always succeeds or fails, there is no onComplete signal.
⁴⁰ Different terminology. Use doOnCancel().
⁴¹ At most one item. Use doOnEvent().
⁴² Use doOnEach().
⁴³ Different terminology. Use doOnSuccess().
⁴⁴ Backpressure related and not supported outside Flowable.
⁴⁵ Different terminology. Use doOnNext().
⁴⁶ At most one item with index 0. Use defaultIfEmpty.
⁴⁷ Always one item with index 0.
⁴⁸ At most one item with index 0. Use toSingle.
⁴⁹ Use complete().
⁵⁰ At most one item. Use defaultIfEmpty.
⁵¹ Always one item.
⁵² At most one item, would be no-op.
⁵³ Always one item, would be no-op.
⁵⁴ Always empty. Use andThen() and error().
⁵⁵ At most one item. Use toCompletionStage().
⁵⁶ Always empty. Use andThen(), error() and toCompletionStage().
⁵⁷ Use flatMap().
⁵⁸ Not supported. Use flatMap and toFlowable().
⁵⁹ Use flatMap.
⁶⁰ Not supported. Use flatMap and toObservable().
⁶¹ Use flatMapSingle.
⁶² Use flatMapIterable().
⁶³ Use flatMapStream().
⁶⁴ Use subscribe().
⁶⁵ At most one item. Use just() or empty().
⁶⁶ Always one item. Use just().
⁶⁷ Always empty. Use complete().
⁶⁸ Always error.
⁶⁹ Use wrap().
⁷⁰ Use fromSupplier().
⁷¹ At most one item.
⁷² Always empty thus no items to group.
⁷³ Always empty thus no items to join.
⁷⁴ Use ignoreElements().
⁷⁵ Use ignoreElement().
⁷⁶ At most one item. Use timer().
⁷⁷ At most one item. Use zip()
⁷⁸ Always empty thus no items to filter.
⁷⁹ Needs backpressure thus not supported outside Flowable.
⁸⁰ Connectable sources not supported outside Flowable and Observable. Use a MaybeSubject.
⁸¹ Connectable sources not supported outside Flowable and Observable. Use a SingleSubject.
⁸² Connectable sources not supported outside Flowable and Observable. Use a ConnectableSubject.
⁸³ At most one item. Use just().
⁸⁴ At most one item. Use map().
⁸⁵ Always empty thus no items to reduce.
⁸⁶ At most one signal type.
⁸⁷ At most one item. Use takeUntil().
⁸⁸ At most one item. Use filter().
⁸⁹ Use startWith() and fromArray() of Flowable or Observable.
⁹⁰ Use startWith() and just() of another reactive type.
⁹¹ Use startWith() and fromIterable() of Flowable or Observable.
⁹² Always empty. Use defaultIfEmpty().
⁹³ At most one item. Use flatMap().
⁹⁴ Use firstStage, lastStage or singleStage.
⁹⁵ Would be no-op.
⁹⁶ Use firstElement, lastElement or singleElement.
⁹⁷ Use firstOrError, lastOrError or singleOrError.
⁹⁸ Use first, last or single.
⁹⁹ Use defaultIfEmpty().
¹⁰⁰ Use map() and switchIfEmpty() to transform into a nested source.
¹⁰¹ Use map() to transform into a nested source.
¹⁰² Always empty. Use andThen() to bring in a nested source.
¹⁰³ Use fromPublisher().
¹⁰⁴ Use merge().
¹⁰⁵ Use mergeArray().
¹⁰⁶ Use mergeWith().

Under development

Single.concatArrayDelayError()
Completable.concatArrayDelayError()
Maybe.concatArrayEagerDelayError()
Single.concatArrayEagerDelayError()
Single.concatDelayError()
Completable.concatDelayError()
Single.concatMap()
Maybe.concatMapCompletable()
Single.concatMapCompletable()
Maybe.concatMapCompletableDelayError()
Single.concatMapCompletableDelayError()
Maybe.concatMapDelayError()
Single.concatMapDelayError()
Completable.concatMapDelayError()
Maybe.concatMapEager()
Single.concatMapEager()
Completable.concatMapEager()
Maybe.concatMapEagerDelayError()
Single.concatMapEagerDelayError()
Completable.concatMapEagerDelayError()
Maybe.concatMapMaybe()
Single.concatMapMaybe()
Maybe.concatMapMaybeDelayError()
Single.concatMapMaybeDelayError()
Maybe.concatMapSingle()
Single.concatMapSingle()
Maybe.concatMapSingleDelayError()
Single.concatMapSingleDelayError()
Maybe.dematerialize()
Maybe.doOnLifecycle()
Single.doOnLifecycle()
Completable.doOnLifecycle()
Single.flatMapSingle()
Flowable.fromAction()
Observable.fromAction()
Single.fromAction()
Flowable.fromCompletable()
Observable.fromCompletable()
Flowable.fromMaybe()
Observable.fromMaybe()
Single.fromMaybe()
Flowable.fromObservable()
Maybe.fromObservable()
Maybe.fromPublisher()
Flowable.fromRunnable()
Observable.fromRunnable()
Single.fromRunnable()
Flowable.fromSingle()
Observable.fromSingle()
Single.fromSingle()
Completable.just()
Single.mergeArray()
Single.mergeArrayDelayError()
Single.ofType()
Completable.onErrorResumeWith()
Completable.onErrorReturn()
Completable.onErrorReturnItem()
Single.retryUntil()
Completable.retryUntil()
Maybe.safeSubscribe()
Single.safeSubscribe()
Completable.safeSubscribe()
Completable.sequenceEqual()
Maybe.startWith()
Single.startWith()
Maybe.switchOnNext()
Single.switchOnNext()
Completable.switchOnNext()
Maybe.switchOnNextDelayError()
Single.switchOnNextDelayError()
Completable.switchOnNextDelayError()
Maybe.timeInterval()
Single.timeInterval()
Completable.timeInterval()
Maybe.timestamp()
Single.timestamp()
Maybe.toFuture()
Completable.toFuture()

Copyright (c) 2016-present, RxJava Contributors.
Twitter @RxJava | Gitter @RxJava

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Operator Matrix

Notes

Under development

Clone this wiki locally