Gain insights into Java 17, cloud and microservices, reactive programming, and top JVM languages. Explore hands-on projects using Scala, Groovy, and Gradle to boost your software development career.

Modern Java Second Edition by Adam L. Davis.png

file.tar.gz

modern_java

Groovy

Scala

Java 12

Java 14

Java 16

Java 17

Java 16-copy

Play

jshell

SPA-play

Gradle-uppercase

Gradle-copyimages

Gradle-properties

Java 14-copy

Java 16-fruits

Java 16-strings

Gradle-java

This course is meant for Java programmers or aspiring programmers who want to know about the latest Java and JVM technology. Throughout this course, you will get several opportunities to get hands-on experience with various Java concepts. 

This course will help you understand the latest in Java up to version 17; cloud and microservices; build, testing, and web frameworks; reactive programming in Java; and the best JVM languages so you can advance your career in software development. 

Moreover, you will also get to work with Scala, Groovy, and Gradle. The course explains Java concepts in detail and also draws comparisons with its older versions, as well as JVM languages.

The All-in-One Guide to Java Programming

RxJava is the open-source library for reactive programming in Java that is part of the ReactiveX project. In short, RxJava is an asynchronous framework for handling data using callbacks, including callbacks for errors and completion.

[ReactiveX](http://reactivex.io/) is based on reactive streams and includes implementations in several languages, including rxjs, RxRuby, RxSwift, RxPHP, RxGroovy, and many more. Reactive Streams provide an abstraction for highly concurrent, asynchronous applications with support for asynchronous handling of backpressure.

RxJava 2 was rebuilt to be compatible with the Reactive Streams specification and is preferable to
RxJava 1.x since it is scheduled for end-of-life. There were many changes from version 1 to 2 that
could be confusing. To avoid confusion, we will focus on RxJava 2.

Project [Reactor](https://projectreactor.io/) is a similar but different implementation of reactive streams that integrates well
with Spring.

# Flowable
The basic entry class in RxJava is `io.reactivex.Flowable`. It is similar to `io.reactivex.Observable` but implements the reactive `Publisher` interface).

It implements the Reactive-Streams Pattern and offers factory methods, intermediate operators, and the ability to consume reactive dataflows.

The following example demonstrates using RxJava to do a simple calculation on a range of numbers:

``` java
public static List doSquares() {
      List squares = new ArrayList();
      Flowable.range(1, 64) //1
         .observeOn(Schedulers.computation()) //2
         .map(v -> v * v) //3
         .blockingSubscribe(squares::add); //4

      return squares;
}
```

1. Create a range from 1 to 64.
2. Call the method `observeOn` to determine which `Scheduler` to use. This determines on which
Thread the flow will run.
3. The `map` method transforms each value. In this case, we calculate the square.
4. Finally, we initiate the flow by calling a `subscribe` method. In this case, `blockingSubscribe`
blocks until the entire flow has been completed. This means that the squares list will be populated
before the return statement. Otherwise, the flow would run on a different thread, and the values
in the squares list would be unpredictable at any given time.

Learn about RxJava and its class, Flowable.

Introduction

Introduction

Java Syntax and Conventions

Java 7

Idiomatic Java 8: Lambdas, Streams, and Dates

New Date and Time API

Java 8 Miscellaneous

Advantages of Java 9

Java 10 - 17

Java Ecosystem

Maven and JUnit

Utilizing Essential Libraries

Modern Java Concurrency

RxJava

Other JVM Languages

Groovy

Gradle

Spock

Scala

RESTful

Microservices and Clouds

Grails

Spark

Spring Boot

Play Framework

Ratpack

Final Thoughts

Appendix

Introduction

What is RxJava?