舉報(bào) 
會(huì)員
Learning RxJava
Thomas Nield 著
更新時(shí)間：2021-07-02 22:23:29
開(kāi)會(huì)員，本書(shū)免費(fèi)讀 >
最新章節(jié)：
Understanding Schedulers
TheprimaryaudienceforthisbookisdeveloperswithatleastafundamentalmasteryofJava.SomereaderswilllikelybeinterestedinRxJavatomakeprogramsmoreresilient,concurrent,andscalable.Othersmaybecheckingoutreactiveprogrammingjusttoseewhatitisallabout,andtojudgewhetheritcansolveanyproblemstheymayhave.
最新章節(jié)
- Understanding Schedulers
- Materializing and Dematerializing
- Mixing object-oriented and reactive programming
- Functional types
- Making a Function a lambda
- Making a Consumer a lambda
品牌：中圖公司
上架時(shí)間：2021-07-02 18:44:55
出版社：Packt Publishing
本書(shū)數(shù)字版權(quán)由中圖公司提供，并由其授權(quán)上海閱文信息技術(shù)有限公司制作發(fā)行
- Understanding Schedulers 更新時(shí)間：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 更新時(shí)間：2021-07-02 22:23:29
