Chapter 7: Observable transformers operators

3 min readJan 5, 2021

We will see the following operators on Observables:

map (and flatMap)
cast
startWith
defaultIfEmpty
switchIfEmpty
sorted
delay
repeat
scan
count
reduce
all
any
contains

map (and flatMap)

map: Convert the Observable into an Observable using a lambda Function<T,R>. One item of T type will be converted into one item of R type. It’s one to one relation.

flatMap: Convert every item of the Observable into an Observable. So the lambda Function is <T,Observable> and you ends up with a merge of Observable. It’s a one to many relation. We will see this notion later.

So using map you can convert a specific stream of object T into another stream of object R.

cast

It helps to cast the Observable to Observable.
Mainly it’s usefull when you have a mother class (or interface) and cast all the elements into this class.

startWith

It helps to start the emission with a specific item.

defaultIfEmpty and switchIfEmpty

It helps to emits an element if the original stream is empty.
defaultIfEmpty: Helps you emits a specific item if the stream is empty; onComplete is called even if no item has been emitted.
switchIfEmpty: Helps you switch to an other observable if the stream is empty; onComplete is called even if no item has been emitted.

defaultIfEmpty

Simple example on how to use defaultIfEmpty.Has to wait the onComplete.

switchIfEmpty

Simple example on how to use switchIfEmpty by returning a new streams of items. Has to wait the onComplete.

sorted

It helps you sorts the items emitted. Has to wait the onComplete. Sorted objects need to implement comparable or you can provide it.

delay

Delay: It helps you delay the emission of the items.
By default the delay applies only on the emission of the items, the errors are immediately fired. but you can also specify if error needs to have a delay.

repeat

Repeat: It helps you delay the emission of the items.
By default the delay applies only on the emission of the items, the errors are immediately fired. but you can also specify if error needs to hae a delay.

scan

Scan: It’s a reducing operator.
It’s based on a lambda function which take the item emitted and concatenate it with an accumulator:(accumulator,next)->accumulator + next.
The accumulator is emitted for every item received.
The accumulator is initialized with the first item.
You can provide an initial value, it will be emitted first and used for the accumulation. This is the trick to change the item emitted type.

reduce

Reduce: It helps you accumulate the item into an accumulator which will be emitted when onComplete is reached on the initial stream.
reduce==scan().takeLast(1)
Reduce returns a Single or MayBE.
It’s based on a lambda function which take the item emitted and concatenate it with an accumulator:(accumulator,next)->accumulator + next.
The accumulator is emitted when the last item is received, it needs to wait the onComplete.
The accumulator is initialized with the first item, if no initial value is provided.
You can provide an initial value, it will be used for the accumulation. This is the trick to change the item emitted type.

count

count: It returns the number of emitted elements. It has to wait the onComplete to fire it.
count returns a Single.

all,any,contains

all: check a condition for every item, if each condition is true, the return is true else it will be false. The emission is done when a condition is calculated as false or when the onComplete is reached(and return true).
any: check a condition for every item, if one condition is true, the return is true else it will be false.The emission is done when a condition is calculated as true or when the onComplete is reached(and return false).
contains: check if the emitted item is the one expected, when the expected item is found, it immediately returns true else it wait onComplete (and return false)
all is a Single
any is a Single
contains is a Single