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

# A little history
Java 10 was released on March 20, 2018. Java 11 was released in September 2018. As Java 11 is the long-term service release (LTS), many developers may move directly from Java 8.

The main substantial update of Java 10 was **Local Variable Type Inference** (`var`). It also included enhancements for garbage collection and compilation, but that will not affect how we write our code.



# Local variable types
Although `var` is not a new keyword, it is a context-sensitive type and represents a huge leap forward for Java developers. It allows us to substitute a type declaration with `var` whenever
the type can be clearly inferred from context by the Java compiler.

Let's look at a code snippet written using Java 10+:

``` java
@Test
public void testDoParallelSquares() {
     var result = demo.doParallelSquares()
            .stream().sorted().collect(Collectors.toList());
     assertArrayEquals(squares.toArray(), result.toArray());
}
```
Here, the result type is inferred from the right side of the assignment. It infers the type is List in this case.

Without loss of meaning to human readers, we can use `var` whenever the type is clear from the right side of the assignment. For example, the following initialization of a list:

```
var list = new ArrayList();
```
Keep in mind that the type of list will be a raw ArrayList. However, in some cases, that might be fine for our purposes.

With any Java code, it can be helpful to use `var` to simplify code in many cases without losing anything. For example:

``` java
var foo = Flowable.just("foo"); //1
var flow = Flowable.just(1, 4, 9); //2
var flowable = flow.map(i -> "string " + i); //3
```
1. Create a RxJava Flowable wrapping a single value.
2. Declare a Flowable with initial values.
3. Declare an intermediate step.

Especially in testing, `var` can be useful for simplifying Java code.

``` java
var publisher = TestPublisher.create(); //1
var flux = publisher.flux(); //2
```

1. Create a TestPublisher from Reactor.
2. Convert it into a Flux.

# Lambda expression local variable types
In Java 11, `var` can also be used in Lambda expression parameters for consistency. For example, the
following code:

``` java
flowable.subscribe(next -> list.add(next), ex -> ex.printStackTrace());
```

This could be changed to the following in Java 11:

``` java
flowable.subscribe((var next) -> list.add(next),
      (var ex) -> ex.printStackTrace());
```
Although a bit longer in syntax, this adds better consistency to the Java language and allows for adding annotations to those parameters without specifying a type. For example:

``` java
flowable.subscribe((@NonNull var next) -> list.add(next),
      (@NonNull var ex) -> ex.printStackTrace());
```




Learn about lambda expressions and local variable types in Java 10 and 11.

Local Variable Types and Lambda Expressions

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

Local Variable Types and Lambda Expressions

A little history