最新章節

• Understanding Schedulers
• Materializing and Dematerializing
• Mixing object-oriented and reactive programming
• Functional types
• Making a Function a lambda
• Making a Consumer a lambda

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

• coverpage
• Title Page
• Credits
• About the Author
• Acknowledgements
• About the Reviewers
• www.PacktPub.com
• Customer Feedback
• Preface
• What this book covers
• What you need for this book
• Who this book is for
• Conventions
• Reader feedback
• Customer support
• Downloading the example code
• Errata
• Piracy
• Questions
• 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
• 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
• 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
• Combining Observables
• Merging
• Observable.merge() and mergeWith()
• flatMap()
• Concatenation
• Observable.concat() and concatWith()
• concatMap()
• Ambiguous
• Zipping
• Combine latest
• withLatestFrom()
• Grouping
• Summary
• 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
• 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
• 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
• 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
• 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
• 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
• 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
• 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 更新時間：2021-07-02 22:23:29