Java Diamond Operator: Simplify Generics in Java 7+

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