Menu
In practical terms there is no difference, they both compile down to the exact same code. List<Object> though is showing that you have thought about what will go in the list and know it could be anything, whereas List on its own shows nothing.
In Java, a list interface is an ordered collection of objects in which duplicate values can be stored. Since a List preserves the insertion order, it allows positional access and insertion of elements. List interface is implemented by the following classes: ArrayList. LinkedList.
The List is an interface, and the ArrayList is a class of Java Collection framework. The List creates a static array, and the ArrayList creates a dynamic array for storing the objects. So the List can not be expanded once it is created but using the ArrayList, we can expand the array when needed.
Well there's no difference between the first two - they're just using different names for the type parameter ( E or T ). The third isn't a valid declaration - ? is used as a wildcard which is used when providing a type argument, e.g. List<?>
1) Correct
2) You can think of that one as "read only" list, where you don't care about the type of the items.Could e.g. be used by a method that is returning the length of the list.
3) T, E and U are the same, but people tend to use e.g. T for type, E for Element, V for value and K for key. The method that compiles says that it took an array of a certain type, and returns an array of the same type.
4) You can't mix oranges and apples. You would be able to add an Object to your String list if you could pass a string list to a method that expects object lists. (And not all objects are strings)
For the last part: Although String is a subset of Object, but List<String> is not inherited from List<Object>.
The notation List<?> means "a list of something (but I'm not saying what)". Since the code in test works for any kind of object in the list, this works as a formal method parameter.
Using a type parameter (like in your point 3), requires that the type parameter be declared. The Java syntax for that is to put <T> in front of the function. This is exactly analogous to declaring formal parameter names to a method before using the names in the method body.
Regarding List<Object> not accepting a List<String>, that makes sense because a String is not Object; it is a subclass of Object. The fix is to declare public static void test(List<? extends Object> set) .... But then the extends Object is redundant, because every class directly or indirectly extends Object.
The reason you cannot cast List<String> to List<Object> is that it would allow you to violate the constraints of the List<String>.
Think about the following scenario: If I have a List<String>, it is supposed to only contain objects of type String. (Which is a final class)
If I can cast that to a List<Object>, then that allows me to add Object to that list, thus violating the original contract of List<String>.
Thus, in general, if class C inherits from class P, you cannot say that GenericType<C> also inherits from GenericType<P>.
N.B. I already commented on this in a previous answer but wanted to expand on it.
I would advise reading Java puzzlers. It explains inheritance, generics, abstractions, and wildcards in declarations quite well. http://www.javapuzzlers.com/
Let us talk about them in the context of Java history ;
List: List means it can include any Object. List was in the release before Java 5.0; Java 5.0 introduced List, for backward compatibility.
List list=new ArrayList();
list.add(anyObject);
List<?>: ? means unknown Object not any Object; the wildcard ? introduction is for solving the problem built by Generic Type; see wildcards;
but this also causes another problem:
Collection<?> c = new ArrayList<String>();
c.add(new Object()); // Compile time error
List< T> List< E> Means generic Declaration at the premise of none T or E type in your project Lib.
List< Object> means generic parameterization.If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With