创建泛型ArrayList时，List<Object>与List<?>该优先选择哪一种？

Great question—this is a super common point of confusion when getting to grips with Java generics. Let’s break down the key differences clearly, then talk about when to pick each approach.

Key Differences #

1. Adding Elements to the List #

• List<Object>: This is a list explicitly built to hold any type of Object (since every Java class inherits from Object). You can add any object to it without hitting compilation errors:

  List<Object> t1 = new ArrayList<>();
  t1.add("Hello"); // Totally valid
  t1.add(42);      // Works too
  t1.add(new HashMap<>()); // No issues here
  

• List<?>: This is a wildcard list representing "a list of some unknown type". The compiler has no clue what type the list is supposed to hold, so it blocks almost all add operations (only null is allowed, since null plays nice with any type):

  List<?> t2 = new ArrayList<>();
  t2.add("Hello"); // Compilation error!
  t2.add(null);    // Only valid option
  

2. Retrieving Elements from the List #

Both behave exactly the same here: when you pull an element from either list, it comes back as an Object (since Object is the universal supertype for all Java objects). You can use Object methods directly, or cast to a specific type (just watch out for type safety risks with casting):

Object elem1 = t1.get(0);
Object elem2 = t2.get(0);

3. Flexibility for Method Parameters #

• List<Object>: It’s invariant, meaning you can’t pass a List<String> or List<Integer> to a method expecting List<Object>—the types have to match exactly. This limits its usefulness for generic operations.
• List<?>: It’s a wildcard that accepts any list type. This makes it perfect for writing utility methods that need to work with lists of any type (without modifying them). For example:

  public static void printAllElements(List<?> list) {
      for (Object item : list) {
          System.out.println(item.toString());
      }
  }
  

  This method can handle List<String>, List<Integer>, List<Double>, etc.—something List<Object> can’t do.

Which to Prefer? #

• Choose List<Object> when: You need to modify the list (add/remove elements) and intend to store a mix of different object types. For example, a general-purpose cache or a collection that holds arbitrary user input objects.
• Choose List<?> when: You only need to read from the list, or you’re writing a generic utility method that should work with any list type. It’s safer (prevents accidental modifications) and far more flexible for read-only operations.

If you’re unsure whether you’ll need to modify the list later, List<?> is often the safer choice—it enforces a read-only contract and avoids unnecessary type restrictions.

内容的提问来源于stack exchange，提问作者Nicky