Login
Search manual

Details

Title LEARNING RXJAVA: BUILD CONCURRENT APPLICATIONS USING REACTIVE PROGRAMMING WITH THE LATEST FEATURES OF RXJAVA 3.
Creators Samoylov Nick. ; Nield Thomas.
Imprint [Place of publication not identified]: PACKT Publishing, 2020
Collection Электронные книги зарубежных издательств ; Общая коллекция
Subjects Application software — Development. ; Java (Computer program language) ; Computer programming. ; EBSCO eBooks
Document type Other
File type PDF
Language English
Rights Доступ по паролю из сети Интернет (чтение, печать, копирование)
Record key on1143346249
Record create date 3/8/2020

Allowed Actions

pdf/2384225.pdf –
Action 'Read' will be available if you login or access site from another network Action 'Download' will be available if you login or access site from another network
epub/2384225.epub –
Action 'Download' will be available if you login or access site from another network
Group Anonymous
Network Internet
Network User group Action
ILC SPbPU Local Network All
Read Print Download
Internet Authorized users SPbPU
Read Print Download
Internet Anonymous
  • Cover
  • Title Page
  • Copyright and Credits
  • Dedication
  • About Packt
  • Contributors
  • Table of Contents
  • Preface
  • Section 1: Foundations of Reactive Programming in Java
  • Chapter 1: Thinking Reactively
    • A brief history of ReactiveX and RxJava
    • Thinking reactively
    • Why should I learn RxJava?
      • What will you learn in this book?
    • Setting up
      • Navigating the central repository
        • Using Gradle
        • Using Maven
    • A brief exposure to RxJava
    • RxJava 1.x, 2.x, or 3.0 – which one do I use?
    • When to use RxJava
    • Summary
  • Chapter 2: Observable and Observer
    • The Observable
      • The workings of Observable
      • Using Observable.create()
      • Using Observable.just()
    • The Observer interface
      • Implementing and subscribing to an Observer
      • Shorthand Observer with lambdas
    • Cold versus hot observables
      • A cold Observable
      • A hot Observable
      • 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
    • Conditional operators
      • takeWhile() and skipWhile()
      • defaultIfEmpty()
      • switchIfEmpty()
    • Suppressing operators
      • filter()
      • take()
      • skip()
      • distinct()
      • distinctUntilChanged()
      • elementAt()
    • Transforming operators
      • map()
      • cast()
      • startWithItem()
      • sorted()
      • scan()
    • Reducing operators
      • count()
      • reduce()
        • Boolean operators
          • all()
          • any()
          • isEmpty()
          • contains()
          • sequenceEqual()
    • Collection operators
      • toList()
      • toSortedList()
      • toMap() and toMultiMap()
      • collect()
    • Error recovery operators
      • onErrorReturnItem() and onErrorReturn()
      • onErrorResumeWith()
      • retry()
    • Action operators
      • doOnNext() and doAfterNext()
      • doOnComplete() and doOnError()
      • doOnEach()
      • doOnSubscribe() and doOnDispose()
      • doOnSuccess()
      • doFinally()
    • Utility operators
      • delay()
      • repeat()
      • single( )
      • timestamp( )
      • timeInterval()
    • Summary
  • Section 2: Reactive Operators
  • Chapter 4: Combining Observables
    • Merging factories and operators
      • Observable.merge() factory and mergeWith() operator
      • flatMap()
        • flatMap() with combiner
    • Concatenating factories and operators
      • Observable.concat() factory and concatWith() operator
      • concatMap()
    • Ambiguous operators
    • Zipping operators
    • Combining the latest operators
      • withLatestFrom()
    • Grouping operators
    • 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 Subject
      • When a Subject goes wrong
      • Serializing a Subject object
      • 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
      • I/O
      • 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
    • Understanding 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() or sample()
      • throttleFirst()
      • throttleWithTimeout() or debounce()
    • Switching
    • Grouping keystrokes
    • Summary
  • Chapter 8: Flowable and Backpressure
    • Understanding backpressure
      • An example that needs backpressure
      • Introducing the Flowable
      • When to use Flowable and backpressure
    • Understanding Flowable and Subscriber
      • Interface Subscriber
    • Creating Flowable
      • Using Flowable.create() and BackpressureStrategy
      • Turning Observable into Flowable and vice versa
    • Using onBackpressureXXX() operators
      • onBackPressureBuffer()
      • onBackPressureLatest()
      • onBackPressureDrop()
    • Using Flowable.generate()
    • Summary
  • Chapter 9: Transformers and Custom Operators
    • Composing new operators from existing ones using compose() and transformers
      • Using ObservableTransformer
      • Using FlowableTransformer
      • Avoiding a shared state with transformers
    • Using the to() operator for fluent conversion
    • Creating new operators from scratch using lift()
      • Implementing an ObservableOperator
      • Implementing a FlowableOperator
    • Creating a new operator for Single, Maybe, or Completable
    • Using RxJava2-Extras and RxJava2Extensions
    • Summary
  • Section 3: Integration of RxJava applications
  • 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 TestScheduler
    • Debugging RxJava code
    • Summary
  • Chapter 11: RxJava on Android
    • Creating an 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
    • Why Kotlin?
    • Configuring Kotlin
      • Configuring Kotlin with Gradle
      • Configuring Kotlin with Maven
      • Configuring RxJava and RxKotlin
    • Kotlin basics
      • Creating a Kotlin file
      • Assigning properties and variables
      • Extension functions
      • Kotlin lambda expressions
    • Extension operators
    • Using RxKotlin
    • Dealing with SAM ambiguity
    • Using let() and apply()
      • Using let()
      • Using apply()
    • Tuple and data classes
    • The future of ReactiveX and Kotlin
    • Summary
  • Appendix A: Introducing Lambda Expressions
  • Appendix B: Functional Types
  • Appendix C: Mixing Object-Oriented and Reactive Programming
  • Appendix D: Materializing and Dematerializing
  • Appendix E: Understanding Schedulers
  • Other Books You May Enjoy
  • Index
pdf/2384225.pdf

Access count: 0 
Last 30 days: 0

Detailed usage statistics

epub/2384225.epub

Access count: 0 
Last 30 days: 0

Detailed usage statistics