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

The following features have been added to the Java language:

* Diamond operator
* Strings in switch
* Automatic resource management
* Improved exception handling
* Numbers with underscores




## Diamond operator
The **Diamond operator** simplifies the declaration of generic classes. The generic types are inferred from the definition of the field or variable. 
```Java
Map<String, List<Double>> nums = new HashMap<String, List<Double>> ();
```
For example, the above code can also be written in Java 7 as: 

```Java
Map<String, List<Double>> nums = new HashMap <> ();
```

## Strings in switch
We can now use strings in switch statements. For example, the following code would compile and work in Java 7:

```Java
public static <T> Collection<T> makeNew(String type, Class<T> tClass) {
		switch (type) {
		case "set":
			return new HashSet<>();
		case "lset":
			return new LinkedHashSet<>();
		case "treeset":
			return new TreeSet<>();
		case "vector":
			return new Vector<>();
		case "array":
			return new ArrayList<>();
		case "deque":
		case "queue":
		case "list":
		default:
			return new LinkedList<>();
		}
	}
```
As seen above, Strings can now be used just like any other primitive data type would in a switch statement.

## Automatic resource management

The new automatic resource management feature makes dealing with resources much easier, such as files. Before Java 7, we needed to explicitly close all open streams, causing some very verbose code. Now we can do the following:

```Java
public void writeWithTry(){
     try (FileOutputStream fos = new FileOutputStream("books.txt");
                DataOutputStream dos = new DataOutputStream(fos)) {
            dos.writeUTF("Modern Java");} 
     catch (IOException e) { 
         // log the exception
     }
}
```
As seen in the code above, there is no need to close the streams as they are taken care of automatically. 

## Improved exception handling
Improved exception handling in Java 7 means that we can catch more than one exception in one catch statement. Previously, we had to write a different catch block for each exception. This may seem trivial but will make Java development somewhat easier. Here’s an example of the new style:

```Java
public static Integer fetchURLAsInteger(String urlString){ 
    try {
          URL url = new URL(urlString);
          String str = url.openConnection().getContent().toString(); 
          return Integer.parseInt(str);

    } catch (NullPointerException | NumberFormatException | IOException e) {
          return null;
    } 
}
```
The above code would fetch content from the given URL and attempt to convert it to an integer. If anything goes wrong, it returns null. Although this is a contrived example, similar situations do occur in real code.

## Numbers with underscores
Numbers with underscores are exactly what you think. Humans have difficulty reading long streams of numbers, so Java 7 allows us to put underscores in numeric literals to make them easier to understand. For example, three million would be written as follows:






# Diamond operator
The **Diamond operator** simplifies the declaration of generic classes. The generic types are inferred from the definition of the field or variable. 
```Java
Map<String, List<Double>> nums = new HashMap<String, List<Double>> ();
```
For example, the above code can also be written in Java 7 as: 

```Java
Map<String, List<Double>> nums = new HashMap <> ();
```

# Strings in switch
We can now use strings in switch statements. For example, the following code would compile and work in Java 7:

```Java
public static <T> Collection<T> makeNew(String type, Class<T> tClass) {
		switch (type) {
		case "set":
			return new HashSet<>();
		case "lset":
			return new LinkedHashSet<>();
		case "treeset":
			return new TreeSet<>();
		case "vector":
			return new Vector<>();
		case "array":
			return new ArrayList<>();
		case "deque":
		case "queue":
		case "list":
		default:
			return new LinkedList<>();
		}
	}
```
As seen above, Strings can now be used just like any other primitive data type would in a switch statement.

# Automatic resource management

The new automatic resource management feature makes dealing with resources much easier, such as files. Before Java 7, we needed to explicitly close all open streams, causing some very verbose code. Now we can do the following:

```Java
public void writeWithTry(){
     try (FileOutputStream fos = new FileOutputStream("books.txt");
                DataOutputStream dos = new DataOutputStream(fos)) {
            dos.writeUTF("Modern Java");} 
     catch (IOException e) { 
         // log the exception
     }
}
```
As seen in the code above, there is no need to close the streams as they are taken care of automatically. 

# Improved exception handling
Improved exception handling in Java 7 means that we can catch more than one exception in one catch statement. Previously, we had to write a different catch block for each exception. This may seem trivial but will make Java development somewhat easier. Here’s an example of the new style:

```Java
public static Integer fetchURLAsInteger(String urlString){ 
    try {
          URL url = new URL(urlString);
          String str = url.openConnection().getContent().toString(); 
          return Integer.parseInt(str);

    } catch (NullPointerException | NumberFormatException | IOException e) {
          return null;
    } 
}
```
The above code would fetch content from the given URL and attempt to convert it to an integer. If anything goes wrong, it returns null. Although this is a contrived example, similar situations do occur in real code.

# Numbers with underscores
Numbers with underscores are exactly what you think. Humans have difficulty reading long streams of numbers, so Java 7 allows us to put underscores in numeric literals to make them easier to understand. For example, three million would be written as follows:



Learn about language updates made in Java 7.

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

Language Updates

Diamond operator