Index

A

• accumulator
  • about / Accumulating data
• aggregate operators
  • about / The BlockingObservable class
  • using / The aggregate operators and the BlockingObservable class
  • reference link / The aggregate operators and the BlockingObservable class
  • used, for testing / Testing with the aggregate operators and the BlockingObservable class
• amb operator
  • about / The amb operator
  • using / The amb operator
  • reference link / The defaultIfEmpty( ) operator
• Android module
  • reference link / The Observable<T> observeOn(Scheduler) operator
• asynchronous Observable instances
  • testing, with TestScheduler instance / Testing asynchronous Observable instances with the help of the TestScheduler class
• AsyncSubject instance
  • about / The Subject instances

B

• backpressure operators
  • about / The backpressure operators
  • reference link / The backpressure operators
• BehaviorSubject instance
  • about / The Subject instances
• BlockingObservable instance
  • about / The BlockingObservable class
  • using / The BlockingObservable class
• BlockingObservables instance
  • with aggregate operators / The aggregate operators and the BlockingObservable class
  • used, for testing / Testing with the aggregate operators and the BlockingObservable class
• buffer() operator
  • about / The buffer and window operators
  • using / The buffer and window operators
• buffering
  • about / Buffering, throttling, and debouncing

C

• cast() operator
  • about / Additional useful transformation operators
  • using / Additional useful transformation operators
• cold Observable instance
  • about / Hot and cold Observable instances
• combineLatest operator
  • used, for combining Observable instances / The combineLatest operator
• concat operator
  • used, for combining Observable instances / The concat operator
• conditional operators
  • about / The conditional operators
  • amb operator / The amb operator
  • takeUntil() operator / The takeUntil(), takeWhile(), skipUntil(), and skipWhile() conditional operators
  • takeWhile() operator / The takeUntil(), takeWhile(), skipUntil(), and skipWhile() conditional operators
  • skipUntil() operator / The takeUntil(), takeWhile(), skipUntil(), and skipWhile() conditional operators
  • skipWhile() operator / The takeUntil(), takeWhile(), skipUntil(), and skipWhile() conditional operators
  • defaultIfEmpty operator / The defaultIfEmpty( ) operator
• ConnectableObservable method
  • about / The ConnectableObservable class
  • using / The ConnectableObservable class
• custom operator instances
  • reference link / Composing multiple operators with the Observable.compose operator
• custom operators
  • creating, with lift operator / Creating custom operators with lift

D

• data
  • filtering / Filtering data
  • accumulating / Accumulating data
  • caching, with Observable.cache / Caching data with Observable.cache
• debouncing
  • about / Buffering, throttling, and debouncing, Debouncing
  • using / Debouncing
• defaultIfEmpty operator
  • about / The defaultIfEmpty( ) operator
  • reference link / The defaultIfEmpty( ) operator
• default Scheduler instance
  • about / The interval Observable and its default scheduler

E

• error handling
  • about / Handling errors
  • with return operator / The return and resume operators
  • with resume operator / The return and resume operators
  • with retrying technique / The retrying technique

F

• factory methods
  • about / The Subject instances
• filter() method / Implementing the reactive sum example with lambdas
• filter() operator
  • using / Filtering data
• flatMap operator
  • about / Transformations with the various flatMap operators
  • using / Transformations with the various flatMap operators
  • reference link / Transformations with the various flatMap operators
• functional interfaces / Introducing the new syntax and semantics
  • in Java / Functional interfaces in Java 8 and RxJava
  • in RxJava / Functional interfaces in Java 8 and RxJava
  • Consumer<T> / Functional interfaces in Java 8 and RxJava
  • Function<T,R> / Functional interfaces in Java 8 and RxJava
  • Predicate<T> / Functional interfaces in Java 8 and RxJava
• functional programming
  • and RxJava / RxJava and functional programming

G

• groupBy() method
  • using / Grouping items
  • reference lnik / Grouping items

H

• hasNext() method / Comparing the iterator pattern and the RxJava Observable
• higher order function
  • about / Pure functions and higher order functions, Higher order functions
• higher order functions
  • about / Observable transformations
• hot Observable instance
  • about / Hot and cold Observable instances
• HTTP client example
  • about / An HTTP client example
  • reference link / An HTTP client example

I

• Indexed() operator
  • about / Creating custom operators with lift
  • reference link / Creating custom operators with lift
• interval Observable instance
  • about / The interval Observable and its default scheduler
• items
  • grouping / Grouping items

J

• Java 8
  • lambdas / Lambdas in Java 8
  • functional interfaces / Functional interfaces in Java 8 and RxJava
• JavaFx module
  • about / The Observable<T> observeOn(Scheduler) operator
• Java Virtual Machine (JVM) / Introducing the new syntax and semantics
• JUnit
  • using / Testing using simple subscription
  • URL / Testing using simple subscription

L

• lambdas
  • used, for implementing reactive sum example / Implementing the reactive sum example with lambdas
• lambdas, Java 8
  • about / Lambdas in Java 8
  • new syntax / Introducing the new syntax and semantics
  • semantics / Introducing the new syntax and semantics
• lift operator
  • used, for creating custom operators / Creating custom operators with lift

M

• map() function / Implementing the reactive sum example with lambdas
  • about / Observable transformations
• marble diagrams
  • about / Observable transformations
• marker interface / Functional interfaces in Java 8 and RxJava
• merge operator
  • used, for combining Observable instances / The merge operator
• multiple operators
  • composing, with Observable.compose method / Composing multiple operators with the Observable.compose operator

N

• Netflix / Introducing RxJava
• next() method / Comparing the iterator pattern and the RxJava Observable

O

• Observable.cache
  • data, caching / Caching data with Observable.cache
• Observable.compose method
  • used, for composing multiple operators / Composing multiple operators with the Observable.compose operator
• Observable.create method
  • about / The Observable.create method
  • using / The Observable.create method
• Observable.empty() method
  • about / Other Observable factory methods
• Observable.error() method
  • about / Other Observable factory methods
• Observable.from method
  • about / The Observable.from method
  • using / The Observable.from method
  • reference link / The Observable.from method
• Observable.interval() method
  • about / Other Observable factory methods
• Observable.just method
  • about / The Observable.just method
  • using / The Observable.just method
  • reference link / The Observable.just method
• Observable.never() method
  • about / Other Observable factory methods
• Observable.range() method
  • about / Other Observable factory methods
• Observable.subscribe() method
  • about / Subscribing and unsubscribing
  • overloads / Subscribing and unsubscribing
• Observable.timer() method
  • about / Other Observable factory methods
• Observable.using method
  • used, for resource management / Introducing the Observable.using method, Creating custom operators with lift
• Observable factory methods
  • other methods, using / Other Observable factory methods
  • reference link / Other Observable factory methods
• Observable instance
  • testing, with simple subscription / Testing using simple subscription
• Observable instances
  • ConnectableObservable method / The ConnectableObservable class
  • combining, with zip operator / The zip operator
  • combining, with combineLatest operator / The combineLatest operator
  • combining, with merge operator / The merge operator
  • combining, with concat operator / The concat operator
  • reference link, for combining / The concat operator
  • debugging / Debugging Observables and their schedulers
• Observable operators
  • about / Combining Observables and schedulers
  • subscribeOn(Scheduler) method / The Observable<T> subscribeOn(Scheduler) method
  • observeOn(Scheduler) operator / The Observable<T> observeOn(Scheduler) operator
• observable side effects / Pure functions
• observeOn(Scheduler) operator
  • about / The Observable<T> observeOn(Scheduler) operator
  • using / The Observable<T> observeOn(Scheduler) operator
  • reference link / The Observable<T> observeOn(Scheduler) operator
• OddFilter() method
  • about / Composing multiple operators with the Observable.compose operator
  • reference link / Composing multiple operators with the Observable.compose operator
• operators
  • about / Observable transformations

P

• pair class
  • about / Transformations with the various flatMap operators
• parallelism
  • about / Parallelism
  • reference link / Parallelism
• println() method / Introducing the new syntax and semantics
• publish() method / Implementing the reactive sum
• PublishSubject instance
  • about / The Subject instances
• pure function
  • about / Pure functions and higher order functions
  • idempotence property / Pure functions
  • immutability / Pure functions
  • mutable objects / Pure functions

R

• Reactive Manifesto
  • URL / Why should we be reactive?
• reactive programming
  • about / What is reactive programming?
  • using, reasons / Why should we be reactive?
  • requisites, for competitive software / Why should we be reactive?
• reactive sum / What is reactive programming?
  • implementing, with lambdas / Implementing the reactive sum example with lambdas
• ReplaySubject instance
  • about / The Subject instances
• resource management
  • about / Resource management
  • with Observable.using method / Introducing the Observable.using method, Creating custom operators with lift
  • reference link / Caching data with Observable.cache
• resume operator
  • used, for error handling / The return and resume operators
• retrying technique
  • about / The retrying technique
  • with retry() operator / The retrying technique
  • reference link / The retrying technique
  • HTTP client example / An HTTP client example
• return operator
  • used, for error handling / The return and resume operators
• RxApacheHttp module
  • about / An HTTP client example
  • URL / An HTTP client example
• Rx contract
  • about / Subscribing and unsubscribing
• RxJava
  • about / Introducing RxJava
  • URL, for downloading / Downloading and setting up RxJava
  • setting up / Downloading and setting up RxJava
  • on GitHub, URL / Downloading and setting up RxJava, Comparing the iterator pattern and the RxJava Observable, Implementing the reactive sum
  • iterator pattern and observable, comparing / Comparing the iterator pattern and the RxJava Observable
  • iterator pattern, comparing / Comparing the iterator pattern and the RxJava Observable
  • reactive sum, implementing / Implementing the reactive sum
  • functional interfaces / Functional interfaces in Java 8 and RxJava
  • and functional programming / RxJava and functional programming
• rxjava-apache-http module API
  • about / Introducing the Observable.using method
  • URL / Introducing the Observable.using method
• RxJava projects
  • reference link / An HTTP client example

S

• scan(Func2) operator
  • about / Accumulating data
  • using / Accumulating data
• Scheduler instances
  • about / RxJava's schedulers
  • debugging / Debugging Observables and their schedulers
  • default Scheduler instance / The interval Observable and its default scheduler
  • interval Observable instance / The interval Observable and its default scheduler
  • types / Types of schedulers
  • Schedulers.immediate method / The Schedulers.immediate scheduler
  • Schedulers.trampoline method / The Schedulers.trampoline scheduler
  • Schedulers.newThread method / The Schedulers.newThread scheduler
  • Schedulers.computation method / The Schedulers.computation scheduler
  • Schedulers.io method / The Schedulers.io scheduler
  • Schedulers.from(Executor) method / The Schedulers.from(Executor) method
  • Observable operators / Combining Observables and schedulers
  • parallelism / Parallelism
• scheduler operators
  • about / Combining Observables and schedulers
• skipUntil() operator
  • about / The takeUntil(), takeWhile(), skipUntil(), and skipWhile() conditional operators
• skipWhile() operator
  • about / The takeUntil(), takeWhile(), skipUntil(), and skipWhile() conditional operators
• startWith() operator
  • about / The concat operator
• Subject instance
  • about / The Subject instances
  • implementing / The Subject instances
  • PublishSubject / The Subject instances
  • ReplaySubject / The Subject instances
  • BehaviorSubject / The Subject instances
  • AsyncSubject / The Subject instances
  • reference link / The Subject instances
• subscribeOn(Scheduler) method
  • about / The Observable<T> subscribeOn(Scheduler) method
  • using / The Observable<T> subscribeOn(Scheduler) method
  • reference link / The Observable<T> observeOn(Scheduler) operator
• subscribing
  • implementation / Subscribing and unsubscribing
• Swing module
  • about / The Observable<T> observeOn(Scheduler) operator

T

• takeUntil() operator
  • about / The takeUntil(), takeWhile(), skipUntil(), and skipWhile() conditional operators
• takeWhile() operator
  • about / The takeUntil(), takeWhile(), skipUntil(), and skipWhile() conditional operators
• TestScheduler instance
  • used, for testing asynchronous Observable instances / Testing asynchronous Observable instances with the help of the TestScheduler class
• TestSubscriber instance
  • used, for in-depth testing / Using the TestSubscriber class for in-depth testing
  • reference link / Using the TestSubscriber class for in-depth testing
• throttling
  • about / Buffering, throttling, and debouncing
  • using / Throttling
• transformations
  • about / Observable transformations
  • with flatMap operator / Transformations with the various flatMap operators
  • items, grouping / Grouping items
  • additional operators / Additional useful transformation operators
• transforming operators
  • about / Observable transformations
• tuple class
  • about / Transformations with the various flatMap operators

U

• unsubscribing
  • implementation / Subscribing and unsubscribing

W

• window() operator
  • about / The buffer and window operators
  • using / The buffer and window operators

X

• Xtend
  • about / Composing multiple operators with the Observable.compose operator
  • reference link / Composing multiple operators with the Observable.compose operator

Z

• zip operator
  • used, for combining Observable instances / The zip operator