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

# Introduction
No discussion of modern Java development would be complete without mentioning Guava.

Google started releasing some internal Java code as open-source under the name Google Collections back in 2007. Its creation and architecture were partly motivated by generics introduced in JDK 1.5. This became much more than only collection support and was rebranded as “Guava.” Guava contains a lot of extremely useful code and provides some hints into modern Java practice.



# Collections

It adds a bunch of very useful Collection-related classes and interfaces:
* `Collections2`:  Utility methods for filtering, transforming, and getting all possible permutations
of Collections.
* `BiMap`: A Map that goes both ways (one-to-one mapping where values can map back to keys).
* `Multimap`: A Map that can associate keys with an arbitrary number of values. Use instead of
Map<Foo, Collection<Bar>>.
* `Multiset`: A set that also keeps track of the number of occurrences of each element.
* `Table`: Uses a row and column as keys to values.

For every Collection type, it also has a static utility class with useful methods. For example:
* **Lists:** `newArrayList`, `asList`, `partition`, `reverse`, `transform`
* **Sets:** `newHashSet`, `filter`, `difference`, `union`
* **Maps:** `newHashMap`, `newTreeMap`, `filterKeys`, `filterValues`, `asMap`

# Objects
Guava’s `Objects` class contains a bunch of useful methods for dealing with a lot of the broiler-plate code in generic Java, such as writing `equals` and `hashCode` methods.

* `Objects.equal(Object, Object)`: Null safe equals
* `Objects.hashCode(Object...)`: An easy way to get a hash code based on multiple fields of our class.
* `Objects.firstNonNull(Object,Object)`: One way to deal with null-return values (returns the first non-null value).

# Concurrency
It also contains some concurrency support, such as the following:

## ListenableFuture

A ListenableFuture allows us to register callbacks to be executed once the computation is complete or if the computation is already immediately completed. This simple addition makes it possible to efficiently support many operations that the basic Future interface cannot support.

``` java
ListeningExecutorService srv = MoreExecutors
          .listeningDecorator(Executors.newFixedThreadPool(10));
ListenableFuture<Rocket> rocket = srv.submit(new Callable<Rocket>(){
     public Rocket call() {
           return launchIntoSpace();
     }
});
Futures.addCallback(rocket, new FutureCallback<Rocket>() {
// we want this handler to run immediately after we launch!
    public void onSuccess(Rocket rocket) {
       navigateToMoon(rocket);
    }
    public void onFailure(Throwable thrown) {
       launchEscapePod();
    }
});
```

# Functional programming
Guava contains a lot of Functional programming paradigms. It has interfaces (`Function`, `Predicate`) and utility classes (`Functions`, `Predicates`) for dealing with functional programming in Java. However, the Guava team warns against overuse of these classes in the following from the [guava wiki](https://github.com/google/guava#Functions_and_Predicates).

> "Excessive use of Guava’s functional programming idioms can lead to verbose, confusing, unreadable, and inefficient code. These are by far the most easily (and most commonly) abused parts of Guava, and when you go to preposterous lengths to make your code 'a one-liner,' the Guava team weeps."

# Optional

Guava also has `Optional` for avoiding null return values .

We can use `Optional.of(x)` to wrap a non-null value, `Optional.absent()` to represent a missing value, or `Optional.fromNullable(x)` to create an `Optional` from a reference that may or may not be null.

After creating an instance of `Optional`, we then use `isPresent()` to determine if there is a value.
`Optional` provides a few other helpful methods for dealing with missing values:
* `or(T)`: Returns the given default value if the `Optional` is empty.
* `or(Supplier<T>)`: Calls on the given Supplier to provide a value if the `Optional` is empty.
* `or(Optional<? extends T>)`: Useful for method-chaining, and returns the given Optional if the Optional is empty.
* `orNull()`: Simply unwraps the value (not recommended).
* `asSet()`: Returns a set of one element if there is a value; otherwise, it returns an empty set.

# Other useful classes
Guava also contains tons of helpful utilities for general software development, such as the following:

## EventBus
EventBus allows publish-subscribe-style communication between components without requiring the components to explicitly register with one another (and thus be aware of each other).

## CacheBuilder
This builds caches that can load and evict values. Caches are tremendously useful in a wide variety of use cases. For example, we should consider using caches when a value is expensive to compute or retrieve. We will need its value on a certain input more than once.

## BloomFilter
Bloom filters are a probabilistic data structure, allowing us to test if an object is definitely not in the filter or to test if it was added to the Bloom filter.

## ComparisonChain
A small, easily overlooked class that’s useful when we want to write a comparison method that compares multiple values in succession and should return when the first difference is found. It removes all the tedium of that, making it just a few lines of chained method calls.

## CharMatchers
A really fast way to match characters, such as whitespace and digits.

## Throwables
This lets us do some nice things with throwables such as `Throwables.propagate`, which rethrows a throwable if it’s a RuntimeException or an Error. It wraps it in a RuntimeException and throws that otherwise.

Learn about Guava, an open-source Java code library.

Guava

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

Guava

Introduction