Cover Image

Learning RxJava : build concurrent, maintainable, and responsive Java in less time / Thomas Nield.

Reactive Programming with Java and ReactiveX About This Book Explore the essential tools and operators RxJava provides, and know which situations to use them in Delve into Observables and Subscribers, the core components of RxJava used for building scalable and performant reactive applications Delve...

Full description

Saved in:
Bibliographic Details
Online Access: Full Text (via O'Reilly/Safari)
Main Author: Nield, Thomas (Computer programmer) (Author)
Format: eBook
Language:English
Published: Birmingham, UK : Packt Publishing, 2017.
Subjects:
Android (Electronic resource)
Application software > Development.
Java (Computer program language)
Computer programming.
Application software > Development
Computer programming
Table of Contents:
  • Intro
  • Credits
  • About the Author
  • Acknowledgements
  • About the Reviewers
  • www.PacktPub.com
  • Customer Feedback
  • Table of Contents
  • Preface
  • Chapter 1: Thinking Reactively
  • A brief history of ReactiveX and RxJava
  • Thinking reactively
  • Why should I learn RxJava?
  • What we will learn in this book?
  • Setting up
  • Navigating the Central Repository
  • Using Gradle
  • Using Maven
  • A quick exposure to RxJava
  • RxJava 1.0 versus RxJava 2.0
  • which one do I use?
  • When to use RxJava
  • Summary
  • Chapter 2: Observables and Subscribers
  • The Observable
  • How Observables work
  • Using Observable.create()
  • Using Observable.just()
  • The Observer interface
  • Implementing and subscribing to an Observer
  • Shorthand Observers with lambdas
  • Cold versus hot Observables
  • Cold Observables
  • Hot Observables
  • ConnectableObservable
  • Other Observable sources
  • Observable.range()
  • Observable.interval()
  • Observable.future()
  • Observable.empty()
  • Observable.never()
  • Observable.error()
  • Observable.defer()
  • Observable.fromCallable()
  • Single, Completable, and Maybe
  • Single
  • Maybe
  • Completable
  • Disposing
  • Handling a Disposable within an Observer
  • Using CompositeDisposable
  • Handling Disposal with Observable.create()
  • Summary
  • Chapter 3: Basic Operators
  • Suppressing operators
  • filter()
  • take()
  • skip()
  • takeWhile() and skipWhile()
  • distinct()
  • distinctUntilChanged()
  • elementAt()
  • Transforming operators
  • map()
  • cast()
  • startWith()
  • defaultIfEmpty()
  • switchIfEmpty()
  • sorted()
  • delay()
  • repeat()
  • scan()
  • Reducing operators
  • count()
  • reduce()
  • all()
  • any()
  • contains()
  • Collection operators
  • toList()
  • toSortedList()
  • toMap() and toMultiMap()
  • collect()
  • Error recovery operators
  • onErrorReturn() and onErrorReturnItem()
  • onErrorResumeNext().
  • Retry()
  • Action operators
  • doOnNext(), doOnComplete(), and doOnError()
  • doOnSubscribe() and doOnDispose()
  • doOnSuccess()
  • Summary
  • Chapter 4: Combining Observables
  • Merging
  • Observable.merge() and mergeWith()
  • flatMap()
  • Concatenation
  • Observable.concat() and concatWith()
  • concatMap()
  • Ambiguous
  • Zipping
  • Combine latest
  • withLatestFrom()
  • Grouping
  • Summary
  • Chapter 5: Multicasting, Replaying, and Caching
  • Understanding multicasting
  • Multicasting with operators
  • When to multicast
  • Automatic connection
  • autoConnect()
  • refCount() and share()
  • Replaying and caching
  • Replaying
  • Caching
  • Subjects
  • PublishSubject
  • When to use Subjects
  • When Subjects go wrong
  • Serializing Subjects
  • BehaviorSubject
  • ReplaySubject
  • AsyncSubject
  • UnicastSubject
  • Summary
  • Chapter 6: Concurrency and Parallelization
  • Why concurrency is necessary
  • Concurrency in a nutshell
  • Understanding parallelization
  • Introducing RxJava concurrency
  • Keeping an application alive
  • Understanding Schedulers
  • Computation
  • IO
  • New thread
  • Single
  • Trampoline
  • ExecutorService
  • Starting and shutting down Schedulers
  • Understanding subscribeOn()
  • Nuances of subscribeOn()
  • Understanding observeOn()
  • Using observeOn() for UI event threads
  • Nuances of observeOn()
  • Parallelization
  • unsubscribeOn()
  • Summary
  • Chapter 7: Switching, Throttling, Windowing, and Buffering
  • Buffering
  • Fixed-size buffering
  • Time-based buffering
  • Boundary-based buffering
  • Windowing
  • Fixed-size windowing
  • Time-based windowing
  • Boundary-based windowing
  • Throttling
  • throttleLast() / sample()
  • throttleFirst()
  • throttleWithTimeout() / debounce()
  • Switching
  • Grouping keystrokes
  • Summary
  • Chapter 8: Flowables and Backpressure
  • Understanding backpressure
  • An example that needs backpressure.
  • Introducing the Flowable
  • When to use Flowables and backpressure
  • Use an Observable If...
  • Use a Flowable If...
  • Understanding the Flowable and Subscriber
  • The Subscriber
  • Creating a Flowable
  • Using Flowable.create() and BackpressureStrategy
  • Turning an Observable into a Flowable (and vice-versa)
  • Using onBackpressureXXX() operators
  • onBackPressureBuffer()
  • onBackPressureLatest()
  • onBackPressureDrop()
  • Using Flowable.generate()
  • Summary
  • Chapter 9: Transformers and Custom Operators
  • Transformers
  • ObservableTransformer
  • FlowableTransformer
  • Avoiding shared state with Transformers
  • Using to() for fluent conversion
  • Operators
  • Implementing an ObservableOperator
  • FlowableOperator
  • Custom Transformers and operators for Singles, Maybes, and Completables
  • Using RxJava2-Extras and RxJava2Extensions
  • Summary
  • Chapter 10: Testing and Debugging
  • Configuring JUnit
  • Blocking subscribers
  • Blocking operators
  • blockingFirst()
  • blockingGet()
  • blockingLast()
  • blockingIterable()
  • blockingForEach()
  • blockingNext()
  • blockingLatest()
  • blockingMostRecent()
  • Using TestObserver and TestSubscriber
  • Manipulating time with the TestScheduler
  • Debugging RxJava code
  • Summary
  • Chapter 11: RxJava on Android
  • Creating the Android project
  • Configuring Retrolambda
  • Configuring RxJava and friends
  • Using RxJava and RxAndroid
  • Using RxBinding
  • Other RxAndroid bindings libraries
  • Life cycles and cautions using RxJava with Android
  • Summary
  • Chapter 12: Using RxJava for Kotlin New
  • Why Kotlin?
  • Configuring Kotlin
  • Configuring Kotlin for Gradle
  • Configuring Kotlin for Maven
  • Configuring RxJava and RxKotlin
  • Kotlin basics
  • Creating a Kotlin file
  • Assigning properties and variables
  • Extension functions
  • Kotlin lambdas
  • Extension operators
  • Using RxKotlin.
  • Dealing with SAM ambiguity
  • Using let() and apply()
  • Using let()
  • Using apply()
  • Tuples and data classes
  • Future of ReactiveX and Kotlin
  • Summary
  • Appendix
  • Introducing lambda expressions
  • Making a Runnable a lambda
  • Making a Supplier a lambda
  • Making a Consumer a lambda
  • Making a Function a lambda
  • Functional types
  • Mixing object-oriented and reactive programming
  • Materializing and Dematerializing
  • Understanding Schedulers
  • Index.

Similar Items