Reactive Programming on Android with RxJava

flattened
stream.
Since each emission from
.flatMap()
can return a new sequence, this has several implications: (1)
the returned
Observable
can have its own set of
Operator
s applied to it, and (2) if there is a delay
between emissions, the emitted sequence can be interleaved with the sequence of other
Observable
s
as depicted in the marble diagram. If this behavior of interleaving is not desired,
.concatMap()
can
be used instead.

---

Chapter 3: Operators
32
.flatMap()
is also useful for introducing parallelism as we’ll see in
Chapter 4: Multithreading
.
ConcatMap
.concatMap()
transforms emissions by invoking a function that you specify. Similar to
.flatMap()
,
the function you provide should also return an
Observable
.
.flatMap()
emissions, however, can be
interleaved because it will immediately subscribe to emitted
Observable
s from the function provided
(see
.flatMap()
diagram for reference).
.concatMap()
, on the other hand, will not interleave
emissions. Instead, it will wait for the previous
Observable
to complete before subscribing to
subsequent ones.
Marble diagram of .concatMap()
Note the performance implications of using
.concatMap()
–if a returned
Observable
from
.con-
catMap()
takes a while to complete, subsequent emitted
Observable
s will have to wait before sub-
scribed to. This trade-off should be kept in mind when deciding to use
.flatMap()
vs.
.concatMap()
.
Skip
Other handy
Operator
s allow you to consume only a subset of the items emitted by the sequence.
.skip(n)
ignores the first
n
items emitted by the sequence and emits the remainder of the sequence.
.skip()
is also overloaded with
.skip(time, timeUnit)
which skips any item/s emitted before the
specified time window.

---

Chapter 3: Operators
33