Java SE 9 has been released in September 2017, three years after the Java SE 8 release from Oracle. The adoption of the Jigsaw module system since then is moderate in the Java community. Some developers skip the non-LTS releases (Java SE 9 is a non-LTS release) and upgrade to Java SE 11 directly. With three years of development for Java 9, there were a lot of useful Java API changes besides the Jigsaw module system. In this blog post, you'll find five useful Java 9 features you might not know yet.
Collection factory methods with Java 9
With Java 9 we now have factory methods to create collections (List,Set, Map). These .of() methods create immutable collections, so adding a new value afterward will throw an exception.
| 1 2 3 4 5 6 7 8 | final List<String> names = List.of("Mike", "Duke", "Paul"); final Map<Integer, String> user = Map.of(1, "Mike", 2, "Duke"); final Map<Integer, String> admins = Map.ofEntries(Map.entry(1, "Tom"), Map.entry(2, "Paul")); final Set<String> server = Set.of("WildFly", "Open Liberty", "Payara", "TomEE"); // names.add("Tom"); throws java.lang.UnsupportedOperationException -> unmodifiable collection is created |
This new feature might reduce boilerplate code as prior to Java 9 a collection was first initialized and all values were added afterward.
Interaction with OS processes with ProcessHandle
Prior to Java 9 the interaction with OS process to get e.g. the PID, the command, general information was cumbersome. With Java 9 we know to get a new interface ProcessHandle for more convenient process interaction.
| 1 2 3 4 5 6 7 8 9 10 11 12 | System.out.println(ProcessHandle.current().pid()); System.out.println(ProcessHandle.current().info()); System.out.println(ProcessHandle.current().info().user().get()); System.out.println(ProcessHandle.current().info().command().get()); System.out.println(ProcessHandle.current().info().totalCpuDuration().get()); ProcessHandle.allProcesses().map(ProcessHandle::info).filter(p -> p.command().isPresent()) .forEach(System.out::println); long PID = 1l; final Runnable exitHandler = () -> System.out.println("Process executed"); ProcessHandle.of(PID).get().onExit().thenRun(exitHandler); |
Update to Streams
The Stream<T> interface has now two new methods: .takeWhile(Predicate<? super T> predicate) and .dropWhile(Predicate<? super T> predicate) to control which values of the stream should be processed or dropped until a specific condition is met.
| 1 2 3 4 5 6 7 8 9 | final IntStream intStream1 = IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); System.out.println(intStream1.takeWhile(n -> n <= 5) .mapToObj(Integer::toString).collect(Collectors.joining(", "))); final IntStream intStream2 = IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); System.out.println(intStream2.dropWhile(n -> n < 5).sum()); final List<String> names = List.of("Tom", "Paul", "Mike", "Duke", "", "Michelle", "Anna"); names.stream().takeWhile(s -> !s.isEmpty()).forEach(System.out::println); |
Objects.requireNonNull updates in Java 9
For checking preconditions at the beginning of a method Objects.requireNonNull is really useful. With Java 9 this utility check has been improved with two new methods: .requireNonNullElse(T obj, T defaultObj) and .requireNonNullElseGet(T obj, Supplier<? extends T> supplier) which you behave as the methods from Optional<T>. With these methods, you can now define default values instead of throwing an exception if a value is null:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | public class ObjectsRequireNonNullUpdate { public static void main(String[] args) { transferMoney(null, null); transferMoney(null, new BigDecimal(33.33).setScale(2, RoundingMode.DOWN)); transferMoney("Duke", null); transferMoney("Duke", new BigDecimal(1995)); } public static void transferMoney(String recipient, BigDecimal amount) { amount = Objects.requireNonNullElseGet(amount, ObjectsRequireNonNullUpdate::calculateDefaultAmount); recipient = Objects.requireNonNullElse(recipient, "Phil"); System.out.println(amount + " is transfered to " + recipient); } private static BigDecimal calculateDefaultAmount() { return new BigDecimal(ThreadLocalRandom.current().nextBoolean() ? 1337 : 42); } } |
JShell feature since Java 9
Java 9 introduces a REPL (read-eval-print-loop) tool for Java JShell. With Java on your PATH, you can enter the JShell with the jshell command. With this Java shell, you can write Java code without explicit compiling and writing .java files. You can use this feature for quick evaluations or simple showcases for the Java language. With TAB you get tab-completion like coding in an IDE and the semicolon is optional at the end of a line:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | $ jshell | Welcome to JShell -- Version 9 | For an introduction type: /help intro jshell> 1337 $1 ==> 1337 jshell> System.out. append( checkError() close() equals( flush() format( getClass() hashCode() notify() notifyAll() print( printf( println( toString() wait( write( jshell> System.out.println($1) 1337 jshell> public int calc(int x, int y){ ...> return x * 2 + y; ...> } | created method calc(int,int) jshell> calc($1, 42) $4 ==> 2716 jshell> List<String> names = List.of("Mike","Duke","Paul") names ==> [Mike, Duke, Paul] jshell> names. add( addAll( clear() contains( containsAll( equals( forEach( get( getClass() hashCode() indexOf( isEmpty() iterator() lastIndexOf( listIterator( notify() notifyAll() parallelStream() remove( removeAll( removeIf( replaceAll( retainAll( set( size() sort( spliterator() stream() subList( toArray( toString() wait( jshell> names.stream().map(n -> n.toUpperCase()).forEach(System.out::println) MIKE DUKE PAUL jshell> /exit | Goodbye $ |
If you don't specify a variable name, the JShell will assign it automatically to a variable with $ as a prefix.
Additional useful commands within the JShell are:
/exitor/exleave the JShell/listlist all the previous commands/{NUMBER}re-execute a previous command/!execute the previous command/varslist all available variables/methodslist all available methods/editopen a UI editor
For a Java 9 deep-dive to the Jigsaw module system I can highly recommend the following books: Java 9 Modularity: Patterns and Practices for Developing Maintainable Applications or Java 9 – Die Neuerungen (For Germans).
For essential Java developer resources in general, take a look at this list.
The codebase is available on GitHub.
Have fun with these Java 9 features,
Phil
