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`					⁽²⁶⁾
`concatEagerDelayError`					⁽²⁷⁾
`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`				⁽⁶⁵⁾	⁽²⁸⁾
`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`					⁽¹¹³⁾
237 operators	216	210	118	108	84

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().
²⁷ No items to keep ordered. Use mergeDelayError().
²⁸ Always empty thus no items to map.
²⁹ Either the upstream fails (thus no inner) or the mapped-in source, but never both. Use concatMapCompletable.
³⁰ Either the upstream fails (thus no inner) or the mapped-in source, but never both. Use concatMap.
³¹ At most one item to map. Use concatMap().
³² At most one item. Use flattenAsFlowable or flattenAsObservable.
³³ Use concatMap.
³⁴ Either the upstream fails (thus no inner) or the mapped-in source, but never both. Use concatMapMaybe.
³⁵ Use concatMap().
³⁶ Either the upstream fails (thus no inner) or the mapped-in source, but never both. Use concatMapSingle.
³⁷ 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 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

Currently, all intended operators are implemented.

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