Preparing for Java and Spring Boot Interview?

Join my Newsletter, its FREE

Wednesday, January 31, 2024

Difference between List of ? (any type) and List of Object in Java Generics

No doubt that Generics is one of the most confusing topics in Java and you can easily forget concepts and rules, especially, if you don't code Java everyday. For example, both List<?> and List<Object> looks similar but there is a subtle difference between them, the List<?> is basically a list of any type, you can assign a list of String i.e. List<String> or list of Integer i.e. List<Integer> to it. You see the point, it uses the unbounded wildcard <?>, which means any type. It provides it the much needed Polymorphism require while writing Generic methods. Basically, if your method has a type List<?> which means you can pass any type of List to it but remember the type is unknown, until you assign it i.e. List<?> myList = new List<String>(). 

Now, coming back to List<Object>, it's not different than a List<String> it just that it will only accepts Objects instead of String. Now, since every class in Java extends Object class, they are essentially object, which means you can store any type of Object in this list. 

Read carefully, the List<?> means you can assign any type of List to it and List<Object> means you can store any type of Object into it. That's the real difference between List<?> and List<Object> in Java.  This one is also a popular Java Interview question from Java Generics topics. 

List<?> vs List<Object> in Java

No concept is complete until we validate our assumption by running some code. Since I have said that List<?> means you can assign any type of List to it, it should not throw compile time error when we assign List<String> or List<Integer>, but you cannot do the same with the List<Object>

Similarly, you can store String, Integer, Float, or whatever you want into List<Object> but you can't do that with List<?> because type is unknown. 

Let's see if these concepts are true or not by writing a Java program and running it for validation

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

public class Demo {

public static void main(String[] args){

printElements(new ArrayList<String>()); //OK
printElements(new ArrayList<Integer>()); //OK

printObjects(new ArrayList<String>()); //NOT OK compile time error
printObjects(new ArrayList<Integer>()); //NOT OK compile time error

public static void printElements(List<?> listOfUnknownType){
listOfUnknownType.add("abc"); // compile time error

for(Object o: listOfUnknownType){
System.out.println(o); //OK 

public static void printObjects(List<Object> listOfObjects){
listOfObjects.add("abc"); // OK
listOfObjects.add(101); // OK

for(Object o: listOfObjects){
System.out.println(o); //OK 

You can see from above code that, you can pass ArrayList<String> and ArrayList<Integer> to the printElements() method but not to printObjects() method because of their different arguments. 

First one accept because it uses List<?> as method argument which can accept any type of List. The printObjects(List<Object> listOfObject) throws error because it can only accept list of object and nothing else

This also means you should prefer bounded wildcards while writing API e.g. for method arguments and return types. 

Similarly, inside the method, when you try to read values both List<?> and List<Object> will work but when you try to add objects, the List<?> will give error because type is unknown.

Compiler doesn't know what types are valid for that List hence it cannot provide type safety guarantee, hence it throws error, but this is not the case with List<Object>

Here compiler does know that it is list of Object and since every class implicitly extends java.lang.Object, you can store anything in this list e.g. String, Integer, Float etc. 

Difference between List of ? (any type) and List of Object  in Java Generics

So, the real difference between List<?> and List<Object> comes depending upon what you are trying to do with them. If you are just reading objects e.g. printing elements from list using enhanced for loop then both are ok, but if you want to add elements then you should use List<Object>

Similarly, if you are writing methods which should work with any type of list then you should be using wildcards i.e. List<?> as method arguments. If you still have any doubt then let me know. 

1 comment :

Anonymous said...

Nice article, just to add List is also known as List of unknown type and should be used to declare reference variables like you showed in method arguments, return types and as local variable.

Post a Comment