Java Generics usage

Question

Kindly, why should I supply the Generic class on the left side (variable declaration) and right side (object assignment) ? I can technically skip it left or right (see alist2, or aList2), what is the drawback of aList2 and aList3 compared to aList1 ?

ArrayList<String> aList1 = new ArrayList<String>();
ArrayList<String> aList2 = new ArrayList();
ArrayList         aList3 = new ArrayList<String>();

Bonus question, just came into my mind and it compiles, but what would that mean for aList4 and aList5?

ArrayList<String> aList4 = new ArrayList<>();
ArrayList<?>      aList5 = new ArrayList<String>();

Thank you in advance.

Kind regards, Hermann

By no means a full answer, but aList3 would not be very helpful for Generics of a class you have designed. Let's say you had an `ArrayList` With aList3, you'd have to cast any item from it into a Car. Vice versa, without generics on the right, you're adding things as objects, which are technically valid, but you wouldn't want to add an object of type `Car` to an ArrayList intended to store objects of type `Person` — Compass, Nov 21 '13 at 19:41

score 3 · Answer 1 · answered Nov 21 '13 at 19:45

ArrayList is a raw type. The Java Spec says the following about them:

The use of raw types is allowed only as a concession to compatibility of legacy code. The use of raw types in code written after the introduction of generics into the Java programming language is strongly discouraged. It is possible that future versions of the Java programming language will disallow the use of raw types.

ArrayList<?> is a wildcard type, specifically the super type of all ArrayLists, regardless of their type parameter. As we don't know the type of elements in the List, you can do less with it than with an ordinary ArrayList. For instance, you can not add anything other than null to it, and every you take from the list is only known to be an Object.

ArrayList<> is a shorthand notation for ArrayList<X>, where X is replaced with the type parameter on the left hand side of the assignment. That is, ArrayList<String> list = new ArrayList<>() is totally equivalent to ArrayList<String> list = new ArrayList<String>(). The diamond operator only exists in Java 7 and higher, and can only be used in places where the compiler is smart enough to infer the type, but in these situations, it is usually the most type correct and concice way of using generics.

score 1 · Answer 2 · answered Nov 21 '13 at 19:40

1

The first list is the standard version for declaring for Java 6 and earlier, to avoid grabbing raw types from the new arraylist. As of Java 7, you can use the second list just as safely.

I am unsure if the third list is safe in Java 7, but I would assume it would either store everything as objects anyhow (raw types issue) or might not even compile.

The fourth list is the essentially equivalent to the second list, and the fifth list is equivalent to the third list.

Edit: Just tested, the third list does return raw types, so I would advise against it. I also missed that the second list is missing a diamond operator on the new declaration of ArrayList (which you should have).

answered Nov 21 '13 at 19:40

Rogue

11,105
5
45
71

1

*As of Java 7, you can use the second list just as safely* you mean `aList4`, not `aList2`. – Luiggi Mendoza Nov 21 '13 at 19:40
Ah yes, I missed the lack of the diamond operator there, one moment. – Rogue Nov 21 '13 at 19:42
Note that the second list `aList2` compiles with a warning since Java 5. – Luiggi Mendoza Nov 21 '13 at 19:43
Also, you should note that even if using `List` you can add objects from different type in the list but using *hacks* (no need to use reflection, by the way). – Luiggi Mendoza Nov 21 '13 at 19:45
@LuiggiMendoza you mean in reference to list2 re: hacks, or overall? If you mean overall then I am personally not aware of how to do this without reflection. – Rogue Nov 21 '13 at 19:46
You can do it in all the 5 cases. – Luiggi Mendoza Nov 21 '13 at 19:48
1

@Rogue `List strs = new ArrayList<>(); List raw = strs; raw.add(1234);` – yshavit Nov 21 '13 at 19:51
Just have a method `public void fooYourList(List aList) { aList.add(5); }` and send `List` there. – Luiggi Mendoza Nov 21 '13 at 19:52
1

Unless I'm badly mistaken, 3 and 5 are not equivalent. 3 is raw, 5 is not – Floegipoky Nov 21 '13 at 19:55

score 0 · Answer 3 · edited May 23 '17 at 12:12

You should use the Generic class that is best for your implementation. That is if you only care about having a collection of items you should use Collection, if you need to preserve order you should use the interface List. The reason for this is that you should:

Program to an interface not an implementation GoF

Why is this good? Well because it makes it a whole lot easier to change implementation. Suppose that you'd like to change from ArrayList to LinkedList in the future. Then it's just a matter of changing the call to new ArrayList to new LinkedList. The same goes for your own code, try to always use an interface to any class that isn't just a dataobject. This will make you think about the interfaces between your objects instead of the implementation, that way you can always code up something crappy at first and then refine your implementation whenever you find that you need to without breaking your code.

article for more info

So why is it bad to not infer the type to your examples? Well mainly because the program won't know what types the list contains, which means that either you have to cast those objects to their type by knowing the type or by figuring out the type.

As for why aList2 is bad I'll just refer to this discussion

Java Generics usage

3 Answers3