difference between List and List

Question

I've read alot about this, and I know that:

List<Object> listOfObject = new ArrayList<TYPE>();   // (0)
//can only work for TYPE == Object.
//if TYPE extends Object (and thus objects of type TYPE are Objects),
//this is not the same with Lists: List<Type> is not a List<Object>

Now I've read that the following is ok:

List undefinedList = new ArrayList<TYPE>();   // (1)
//works for ANY type (except for primitives)

And

List<?> wildcardList = new ArrayList<TYPE>();   // (2)  
//also works for ANY type (except for primitives)

Then:

List undefinedlist = new ArrayList(); //no TYPE specified
undefinedList.add(new Integer(1)); //WORKS
undefinedList.add(new String("string")); //WORKS

However:

List<?> wildcardList = new ArrayList<TYPE>(); //TYPE specified
wildcardList.add(new TYPE(...)); //COMPILER ERROR

example:

List<?> wildcardList = new ArrayList<String>(); //TYPE specified
wildcardList.add(new String("string")); //COMPILER ERROR: The method add(capture#1-of ?) in the type List<capture#1-of ?> is not applicable for the arguments (String)

I do understand why you can't add anything to the wildcardList, since its type can be anything. However, why can you add to the undefinedList?? They seem the same & show the same behavior, given (1) and (2).

As with just about ANY question. It's always better to actually show what the "compiler error" actually is (the text of the error). — billjamesdev, Feb 20 '13 at 15:25
I guess you didn't read this though? http://docs.oracle.com/javase/tutorial/extra/generics/wildcards.html — Duncan Jones, Feb 20 '13 at 15:25
@joost It explains one of your problems. Search for "*Since we don't know what the element type of c stands for, we cannot add objects to it.*" :-) — Duncan Jones, Feb 20 '13 at 15:35
@DuncanJones in my first post I stated: I do understand why you can't add anything to the wildcardList, since its type can be anything. — joost, Feb 20 '13 at 16:08

lbalazscs · Answer 1 · 2013-02-20T15:59:59.750

List undefinedList and List<?> wildcardList are not the same, as you discovered yourself. The first is raw type and the second is unbounded wildcard.

Use the unbounded wildcard if you want to use a generic type but you don’t know or care what the actual type parameter is. You cannot put anything (except null) into this list, and all you know about the element you get out of it is that they extend Object (actually List<?> is the same as List<? extends Object>). Unbounded wildcards are useful, because if you would declare something naively as List<Object>, you could not assign for example List<String> to it, while you can assign a List<String> to a List<?>

You should (almost) never have the need to use raw types, they are available only for compatibility with code written before Java 5.

score 2 · Answer 2 · answered Feb 20 '13 at 18:20

List<?> is read as a list of some unknown type . As a programmer you can not make any assumption of what type that is and you can not put anything into such a collection other than null . But you can be rest assured that your list is type safe since the compiler will guarantee type safety for you .

List is basically called raw type . That is to say that it has opted out of type safety guaranteed by the compiler . So you can put elements of any type into that List destroying its invariants . Don't code with raw types any more . They are basically supported for backward compatibility because java was already in the second decade of development when Sun brought generics to the table and a awful lot of code was written using raw types and those programs would otherwise break.

score 1 · Answer 3 · answered Feb 20 '13 at 15:42

List means that this is a list of unknown type - as such you wouldnt use it at creation time (as in your example), you'd typically use it as a method parameter. Unbound wildcards are only really useful when used as parameters in methods, such as:

public void printList(List<?> items)

This could iterate of a list of (any) unknown items. In this case List items would achieve the same purpose, but client would probably get a warning.

If you had the following:

public void printList(List<Object> items)

Then only a list of Object could be processed - not a list Strings, Integers etc. Only Objects.

Take a look at Unbounded Wildcards - it explains its pretty well

Aniket Inge · Answer 4 · 2013-02-20T15:31:05.550

0

The "undefined" List contain list of type Object which is the father of all types and hence the List is not type-safe(is interconvertible)

which is why this:

List undefinedlist = new ArrayList<TYPE>(); //IS LIST OF OBJECTS
undefinedList.add(new Integer(1)); //WORKS
undefinedList.add(new String("string")); //WORKS

well.. works!

edited Feb 20 '13 at 15:31

answered Feb 20 '13 at 15:25

Aniket Inge

25,375
5
50
78

1

`Object` is not type-safe? Sorry, I did not understand this. – m0skit0 Feb 20 '13 at 15:26
if this were true, then what is the difference between (0) and (1)? – joost Feb 20 '13 at 15:27
difference between that is one is a zero and the other is a 1? @joost – Aniket Inge Feb 20 '13 at 15:28
@Aniket, I meant in the sample i provided. – joost Feb 20 '13 at 15:29
1

`List` is not "undefined", it's a "raw type". – Joachim Sauer Feb 20 '13 at 15:30

Bhesh Gurung · Answer 5 · 2013-02-20T15:48:12.900

0

Basically, ? in the following

List<?> wildcardList = new ArrayList<TYPE>();

means some unknown (particular) type. So, it doesn't allow you add something like String, or Integer to a list of some unknown type, because generics is meant to be type-safe.

While, in the following

List<Object> listOfObject = new ArrayList<TYPE>();

you can add anything to it because everything is an Object in Java. So it's type-safe.

And also with the following

List undefinedList = new ArrayList<TYPE>();

you are telling the compiler that you don't want to use generics there. Which means every method you invoke on undefinedList will be non-generic since you have decided to use the raw List. Non-generic versions of all the containers in the collection framework were written to work for Object (which any object in Java is).

edited Feb 20 '13 at 15:48

answered Feb 20 '13 at 15:32

Bhesh Gurung

50,430
22
93
142

thanks. However I don't get the difference between raw and generic.. – joost Feb 20 '13 at 15:47
`List – Bhesh Gurung Feb 20 '13 at 15:50
this means they are both different classes? Because: of no type argument were provided, which type would be used? – joost Feb 20 '13 at 15:57
useful links: http://stackoverflow.com/questions/1351299/what-is-difference-between-unbounded-wildcard-type-list-and-raw-type-list http://stackoverflow.com/questions/7360594/whats-the-difference-between-raw-types-unbounded-wild-cards-and-using-object-i – joost Feb 20 '13 at 16:00

score -1 · Answer 6 · answered Feb 20 '13 at 15:27

The List<?> type is generic: whatever type you put in place of the question mark will be used in the methods of the list. So you can do list.add(item) and it will only allow you to put in a String if you created a List<String>. Type-safety first.

List<String> list = new List<String>();
list.add("A");             // <-- Correct
list.add((Integer)10);     // <-- Error, it is a List of Strings

The List on the other hand allows any Object to be put in there. So you can make a List, put a Giraffe in there, and later a Squid. It does not care, and could be a source of programming errors if you expect only Giraffe objects to be in there.

List list = new List();
list.add("A");             // <-- Allowed
list.add((Integer)10);     // <-- Also allowed,
                           // but now the list contains not only strings

This is very clear, but is not an answer to my question. – joost Feb 20 '13 at 15:32 — joost, Feb 20 '13 at 15:32

difference between List and List

6 Answers6

Linked