”;
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
”;