CODEWITHSUNDEEP
javagenericsarraylist
Tim
Tim

Reputation: 4365

Java - Are ArrayList and ArrayList<Object> two different classes?

If so, what is the difference between the two? Are there actually two separate class definitions in the java library? One for the old ArrayList and one for the new generic one? This is purely a question from curiosity.

Upvotes: 4

Views: 4893

Answers (6)

TotoroTotoro
TotoroTotoro

Reputation: 17622

ArrayList<Object> a1 = new ArrayList<Object>();
ArrayList a2 = new ArrayList();

boolean same = a1.getClass().equals(a2.getClass());
System.out.println("same="+same);

This prints "true". Both arrays are in fact objects of the same class.

Upvotes: 1

user541686
user541686

Reputation: 210755

  • ArrayList: Obsolete (unparametrized). Used only for backward-compatibility. Generates warning.

  • ArrayList<Object>: An array-based list of objects.

  • ArrayList<? extends Object>: An array-based list of some type of Object.
    For example, could be referring to an ArrayList<Integer>, an ArrayList<String>, or just a plain ArrayList<Object>.

Upvotes: 1

Thilo
Thilo

Reputation: 262834

There is just one class ArrayList, but it supports generics, which means that you can annotate it with a type. However, that is optional (mostly for backwards compatibility), so you can also continue to use the raw type (but that is discouraged).

Note that Java generics only happen for the compiler, at runtime the ArrayList instance itself has no idea what generic type you assigned to it. This means that it works exactly the same way internally if you annotate it or not.

Unlike arrays, there are no new separate classes for generic collections. So while there is actually a different class for Integer[] than for String[] (or for Integer[][]), the class for ArrayList<String> is the same as for ArrayList<Integer> (and ArrayList<?> and ArrayList and ArrayList<List<Integer>>).

And also unlike arrays, there is nothing special in generics for use by collections (although that remains their most popular application). The same mechanism can be used for completely different things, for example a Callable.

Upvotes: 6

gsteff
gsteff

Reputation: 4942

They're the same. Generic type restrictions are enforced at compile-time, but no type information is actually present at runtime. This is called type erasure, and it means that at runtime, it's actually impossible to determine what generic type(s) an instance was declared with. See this Wikipedia page for more info.

Upvotes: 1

Jack
Jack

Reputation: 133639

They are the same class, actually the difference resides only in the type checker.

ArrayList<T> is just an annotation for the compiler to enforce that just objects of type T can be added to the specific list, and consequently it automatically allows you to retrieve objects from the collection that are already of type T.

This mechanism, that is called parametric polymorphism, has been added to Java since version 5 and it's implemented through type erasure: the compiler will make sure that you use the class just with correct types, as you defined, but at runtime the old ArrayList will be used.

They're exactly the same class, indeed.

Upvotes: 1

Ernest Friedman-Hill
Ernest Friedman-Hill

Reputation: 81724

No, they're the same class, in that there's only one class file. Existing API classes were "generified" in such a way that old code could continue to be compiled with no change, and interoperate nicely with new code which used the new features.

Upvotes: 4

Related Questions