Reactive Programming with RxJava-Chapter3:Operators and Transformations(3)

Slicing and Dicing Using skip(),takeWhile(),and Others

take(n)

skip(n)

takeLast(n)

skipLast(n)

first()

last()

takeFirst(predicate)
The only difference between this one and first(predicate) is that ti will not break with NoSuchElementException in case of missing matching.
takeUntil(predicate)

takeWhile(predicate)

elementAt(n)

…OrDefault()
count()
all(predicate)

exists(predicate)

contains(value)

Ways of Combining Streams:concat(),merge(),and switchOnNext()

Importantly,concat() will subscribe to the second Observable if,and only if,the first one is completed

Observable<Car> found=Observable
        .concat(fromCache,fromDb)
        .first();

There is no buffering or halting events within merge()

Attention start

Observable<Observable<String>> qutoes= //...

//A
map(innerObs->
        innerObs.delay(rnd.nextInt(5),SECONDS))
//B
flatMap(innerObs->just(innerObs)
        .delay(rnd.nextInt(5),SECONDS))

In variant A,the Observable appears immediately in the outer stream but begins emitting events with some delay.In variant B,on the other hand,we shift the entire Observable event forward in time so that it appears in the outer Observable much later.
Attention end

When we have a stream of streams,switchOnNext() always forwards downstream events from the last inner stream,even if older streams keep forwarding fresh events.

Criteria-Based Splitting of Stream Using groupBy()

One of the techniques often used together with domain-driven design is event soucing.
In this architecture style,data is not stored as a snapshot of current state and mutated in place;that is using SQL UPDATE queries.Instead,a sequence of immutable domain events(facts) about events that already happended are kept in an append-only data store.Using this design,we never overwrite any data,effectively having an audit log for free.Moreover,the only way to see the data in real time is by applying these facts one after another,starting from an empty view.

Writing Customer Operators

If the operator you are creating is designed to act on the individual items emitted by a source Observable, use lift. If your operator is designed to transform the source Observable as a whole (for instance, by applying a particular set of existing RxJava operators to it) use compose.

Reusing Operators Using compose()

Implementing Advanced Operators Using lift()

最后，安利一款自己写的基于MVP的Android开发框架

https://github.com/sxenon/Pure
欢迎大家拍砖，如果觉得好，麻烦多多star