Java Operators

Java Control Statements

Object Oriented Programming

Java Built-in Classes

Java File Handling

Java Error & Exceptions

Java Multithreading

Java Synchronization

Java Networking

Java Collections

Java Interfaces

Java Data Structures

Java Collections Algorithms

Advanced Java

Java Miscellaneous

Java APIs & Frameworks

Java Class References

Java Useful Resources

Java - Inner Class Diamond Operator



Java Diamond Operator

The diamond operator was introduced in Java 7 to make code more readable for Generics. A generic is a type of argument. Using generic we can pass any kind of object to be processed by the class methods. For example, if we are creating a list of strings before Java 7, then we've to use the following syntax to instantiate a list of strings with an ArrayList object.

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

From Java 7 onwards, we can use diamond operator to simplify the above syntax as following −

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

But it could not be used with Anonymous inner classes. For example, we cannot omit the object type from diamond operator in below syntax prior to Java 9.

Handler<Integer> intHandler = new Handler<Integer>(1) { @Override public void handle() { System.out.println(content); } };

Diamond Operator in Anonymous Class

In Java 9, the diamond operator can be used with an anonymous class as well to simplify code and improve readability.

Handler<Integer> intHandler = new Handler<>(1) { @Override public void handle() { System.out.println(content); } };

Diamond Operator in Java 7, Java 8

In below example, we've created anonymous classes for an abstract class Handler accepting a generic argument and pass the object type while creating the anonymous class as we have to pass the type argument otherwise program won't compile.

Example

public class Tester { public static void main(String[] args) { // create an Anonymous class to handle 1 // Here we need to pass Type arguments in diamond operator // before Java 9 otherwise compiler will complain error Handler<Integer> intHandler = new Handler<Integer>(1) { @Override public void handle() { System.out.println(content); } }; intHandler.handle(); // create an Anonymous class to handle 2 Handler<? extends Number> intHandler1 = new Handler<Number>(2) { @Override public void handle() { System.out.println(content); } }; intHandler1.handle(); Handler<?> handler = new Handler<Object>("test") { @Override public void handle() { System.out.println(content); } }; handler.handle(); } } abstract class Handler<T> { public T content; public Handler(T content) { this.content = content; } abstract void handle(); }

Output

Let us compile and run the above program, this will produce the following result −

1
2
Test

Diamond Operator Java 9 Onwards

With Java 9, we can use <> operator with anonymous class as well as shown below.

Example

In below example, we've created anonymous classes for an abstract class Handler accepting a generic argument but without the object type while creating the anonymous class as we need not to pass the type argument. Compiler infers the type itself.

public class Tester { public static void main(String[] args) { // create an Anonymous class to handle 1 // Here we do not need to pass Type arguments in diamond operator // as Java 9 compiler can infer the type automatically Handler<Integer> intHandler = new Handler<>(1) { @Override public void handle() { System.out.println(content); } }; intHandler.handle(); Handler<? extends Number> intHandler1 = new Handler<>(2) { @Override public void handle() { System.out.println(content); } }; intHandler1.handle(); Handler<?> handler = new Handler<>("test") { @Override public void handle() { System.out.println(content); } }; handler.handle(); } } abstract class Handler<T> { public T content; public Handler(T content) { this.content = content; } abstract void handle(); }

Output

Let us compile and run the above program, this will produce the following result −

1
2
Test
Advertisements