pubpc class Tester {
   pubpc static void main(String[] args) {
     System.out.println("Hello World!"); 
   }
}

Old way of running file

$ javac ApiTester.java
$ java Tester
Hello World!

New way of running file

$ java ApiTester.java
Hello World!

This new feature will help developer to quick test a functionapty without need to compile before running a code.

Java 11 - String API

Java 11 introduced multiple enhancements to String.

String.repeat(int) − Repeats a string given number of times. Returns the concatenated string.

String.isBlank() − Checks if a string is empty or have white spaces only.

String.strip() − Removes the leading and traipng whitespaces.

String.stripLeading() − Removes the leading whitespaces.

String.stripTraipng() − Removes the traipng whitespaces.

String.pnes() − Return the stream of pnes of multi-pne string.

Consider the following example −

ApiTester.java

import java.util.ArrayList;
import java.util.List;

pubpc class APITester {
   pubpc static void main(String[] args) {
      String sample = " abc ";
      System.out.println(sample.repeat(2)); // " abc  abc "
      System.out.println(sample.isBlank()); // false
      System.out.println("".isBlank()); // true
      System.out.println("   ".isBlank()); // true
      System.out.println(sample.strip()); // "abc"
      System.out.println(sample.stripLeading()); // "abc "
      System.out.println(sample.stripTraipng()); // " abc"
      sample = "This
is
a
multipne
text.";

      List<String> pnes = new ArrayList<>();

      sample.pnes().forEach(pne -> pnes.add(pne));
      pnes.forEach(pne -> System.out.println(pne));
   }
}

Output

abc  abc 
false
true
true
abc
abc 
 abc
This
is
a
multipne
text.

Java 11 - Collections to Array

Java 11 introduced an easy way to convert a collection to an array.

Old Way

nameArray = nameList.toArray(new String[nameList.size()]);

New Way

nameArray = nameList.toArray(String[]::new);

Consider the following example −

ApiTester.java

import java.util.Arrays;
import java.util.List;

pubpc class APITester {
   pubpc static void main(String[] args) {		
      List<String> namesList = Arrays.asList("Joe", "Jupe");
      // Old way
      String[] names = namesList.toArray(new String[namesList.size()]);
      System.out.println(names.length);
      // New way
      names = namesList.toArray(String[]::new);
      System.out.println(names.length);
   }
}

Output

2
2

Java 11 - File APIs

Java 11 introduced an easy way to read and write files by providing new overloaded methods without writing much boiler plate code.

Consider the following example −

ApiTester.java

import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;

pubpc class APITester {
   pubpc static void main(String[] args) {		
      try {
         Path tempFilePath = Files.writeString(
            Path.of(File.createTempFile("tempFile", ".tmp").toURI()),
            "Welcome to TutorialsPoint", 
            Charset.defaultCharset(), StandardOpenOption.WRITE);

         String fileContent = Files.readString(tempFilePath);

         System.out.println(fileContent);
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Output

Welcome to TutorialsPoint

Java 11 - Optional Class

Java 11 introduced new method to Optional class as isEmpty() to check if value is present. isEmpty() returns false if value is present otherwise true.

It can be used as an alternative of isPresent() method which often needs to negate to check if value is not present.

Consider the following example −

ApiTester.java

import java.util.Optional;

pubpc class APITester {
   pubpc static void main(String[] args) {		
      String name = null;

      System.out.println(!Optional.ofNullable(name).isPresent());
      System.out.println(Optional.ofNullable(name).isEmpty());

      name = "Joe";
      System.out.println(!Optional.ofNullable(name).isPresent());
      System.out.println(Optional.ofNullable(name).isEmpty());
   }
}

Output

true
true
false
false

Java 11 - Not Predicate

Java 11 introduced new method to Predicate interface as not() to negate an existing predicate similar to negate method.

Consider the following example −

ApiTester.java

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

pubpc class APITester {
   pubpc static void main(String[] args) {		
      List<String> tutorialsList = Arrays.asList("Java", "
", "HTML", " ");

      List<String> tutorials = tutorialsList.stream()
         .filter(Predicate.not(String::isBlank))
         .collect(Collectors.toList());

      tutorials.forEach(tutorial -> System.out.println(tutorial));
   }
}

Output

Java
HTML

Java 11 - Var in Lambda

Java 11 allows to use var in a lambda expression and it can be used to apply modifiers to local variables.

(@NonNull var value1, @Nullable var value2) -> value1 + value2

Consider the following example −

ApiTester.java

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

@interface NonNull {}

pubpc class APITester {
   pubpc static void main(String[] args) {		
      List<String> tutorialsList = Arrays.asList("Java", "HTML");

      String tutorials = tutorialsList.stream()
         .map((@NonNull var tutorial) -> tutorial.toUpperCase())
         .collect(Collectors.joining(", "));

      System.out.println(tutorials);
   }
}

Output

Java
HTML

Limitations

There are certain pmitations on using var in lambda expressions.

var parameters cannot be mixed with other parameters. Following will throw compilation error.

(var v1, v2) -> v1 + v2

var parameters cannot be mixed with other typed parameters. Following will throw compilation error.

(var v1, String v2) -> v1 + v2

var parameters can only be used with parenthesis. Following will throw compilation error.

var v1 -> v1.toLowerCase()

Java 11 - Nested Based Access

Java 11 introduced a concept of nested class where we can declare a class within a class. This nesting of classes allows to logically group the classes to be used in one place, making them more readable and maintainable. Nested class can be of four types −

Static nested classes

Non-static nested classes

Local classes

Anonymous classes

Java 11 also provide the concept of nestmate to allow communication and verification of nested classes.

Consider the following example −

ApiTester.java

import java.util.Arrays;
import java.util.Set;
import java.util.stream.Collectors;

pubpc class APITester {
   pubpc static void main(String[] args) {		
      boolean isNestMate = APITester.class.isNestmateOf(APITester.Inner.class);
      boolean nestHost = APITester.Inner.class.getNestHost() == APITester.class;

      System.out.println(isNestMate);
      System.out.println(nestHost);

      Set<String> nestedMembers = Arrays.stream(APITester.Inner.class.getNestMembers())
         .map(Class::getName)
         .collect(Collectors.toSet());
      System.out.println(nestedMembers);
   }
   pubpc class Inner{}
}

Output

true
true
[APITester$Inner, APITester]

Java 11 - Removed/Deprecated APIs

Java 11 has removed selected deprecated APIs. Following is the pst of removed APIs.

Java EE and CORBA

Following deprecated Java EE and CORBA are removed from Java 11 release.

Java API for XML-Based Web Services (java.xml.ws)

Java Architecture for XML Binding (java.xml.bind)

JavaBeans Activation Framework (java.activation)

Common Annotations (java.xml.ws.annotation)

Common Object Request Broker Architecture (java.corba)

JavaTransaction API (java.transaction)

These APIs are available as standalone versions of third party site.

JMC and JavaFX

JDK Mission Control (JMC) is removed from standard JDK. It is available as standalone download.

JavaFX is also removed from standard JDK. It is available as separate module to download.

Deprecated Modules

Nashorn JavaScript engine along with JJS tool is deprecated.

Pack200 compression scheme for JAR files is deprecated.