Q about generic compiler warnings

[S Ali]

  List<String>l = new ArrayList();
List l2 = new ArrayList <String>();  

When I run this from the CMD first line compiles with warnings ,second compiles without (although they both produce warnings on eclipse).I am very confused because the first declaration of ArrayList can only take Strings ,but second one can take any type of object which will make a mess at runtime so shouldn't it be the other way round? Could you please explain to me this issue because I'm so confused and please correct me if I'm wrong.

[Deepak Bala]

I am a little confused about what you are trying to ask. Are you asking if line 1 or line 2 should not compile or if one of them should not throw a warning message ?

[Anastasia Sirotenko]

S Ali wrote:
When I run this from the CMD first line compiles with warnings ,second compiles without (although they both produce warnings on eclipse).I am very confused because the first declaration of ArrayList can only take Strings ,but second one can take any type of object which will make a mess at runtime so shouldn't it be the other way round? Could you please explain to me this issue because I'm so confused and please correct me if I'm wrong.

  
List<String>l = new ArrayList(); // declares a list that can take only String, but initializes it with some god-only-knows-what-is-there-List, that is why compiler upset
List l2 = new ArrayList <String>();  // declares List of everything, but initialize it with definitely  only String list. 
//First - you still have homogeneous collection of Strings, second - you declared a List-of-everything, and String is fit there, so nothing to complain.
 

[Harsh Pensi]

second one can take any type of object which will make a mess at runtime so shouldn't it be the other way round?

I'm able to add any object to this list : List l2 = new ArrayList<String>();
And it does not give any runtime exceptions also. Then what is the effect of initializing ArrayList<String>(). It is the same as without the generic declaration. Am I right?

[Nitish Bangera]

What exactly is a generic.....type safety and what is the broader class for a generic type that is a raw type.
Generic instantiation assigned to a raw reference type. This compiles without warnings as the compiler knows only about the reference type. I will create a class cast exception at runtime if the programmer has a cast like (Integer)l2. This is allowed at compile time as l2 is a raw type and the list may contain Integer which is not known to the compiler.

  List l2 = new ArrayList<String>();   

This following can be seen as unsafe as the arraylist can contain many other things but the compiler allows only String.

  List<String>l = new ArrayList();  

This code can be viewed as in

 List l2 = new ArrayList(); 
 List<String>l = l2;  

First the compiler is upset that you are assigning a raw type to a generic type but the compiler cannot do anything but give a warning because both the classes are the same after type erasure.

[Muhammad Khojaye]

Murtuza Arzai wrote:
I'm able to add any object to this list : List l2 = new ArrayList<String>();
And it does not give any runtime exceptions also. Then what is the effect of initializing ArrayList<String>(). It is the same as without the generic declaration. Am I right?

Yes. If you declare List l2 = new ArrayList<String>() then you lose all the safety benefits provided by generics. The row types are only allowed because of compatibility. In general, you should never use row type such as List in your code.

[Ankit Garg]

The compiler will issue a warning only it thinks that it can't ensure type safety (as Nitish mentioned). The warnings are issued if some of the statements might result in a run-time exception (and thus break type safety). Let's take the statements one by one

List<String> l = new ArrayList();

Here the compiler issues warning. As Anastasia explained this is because the right hand operand might contain a List of any type of objects (like below).

List untyped = new ArrayList();
untyped.add(new Integer(10));
List<String> l = untyped;       //warning

After this point it is the responsibility of the compiler to ensure that l contains only elements of type String. But since the list might already contain a different type that String (like in the second code), thus later a get() operation on the typed list might result in a ClassCastException (thus break type safety). This is why the compiler issues a warning as this statement might break type safety

List untyped = new ArrayList();
untyped.add(new Integer(10));
List<String> l = untyped;          //warning
String s = l.get(0);               //ClassCastException

Now lets examine the other statement

List l2 = new ArrayList <String>();

This time you don't get any warning. This is because you are just assigning the typed list to an untyped list. You'll only get a warning if you try to add anything to l2. This is because that might break type safety somewhere else

List typed = new ArrayList<String>();
List l2 = typed;
l2.add(new Integer(10));           //warning
String s = l.get(0);               //ClassCastException

This is why the compiler issues a warning when you try to add an element to an untyped collection...

[S Ali]

Thanks to you all for clarifying this to me ,especially Ankit I totally got your explanation.