What is difference between new ArrayList<>() and new ArrayList() ?

[Mushfiq Mammadov]

It is written on page 130 of Java OCA 8 book

Java 5 introduced generics, which allow you to specify the type of class that the ArrayList will contain.

    ArrayList<String> list4 = new ArrayList<String>();
    ArrayList<String> list5 = new ArrayList<>();

Java 5 allows you to tell the compiler what the type would be by specifying it between < and >. Starting in Java 7, you can even omit that type from right side. The < and > are still required, though.

If we remove <> from the right side the code does compile too. I couldn't find any difference and I want to know what is the difference between line1 and line2 in the following code?

    ArrayList<String> list5 = new ArrayList<>();      //line1
    list5.add("element1");
    list5.add("element2");
    list5.add(1,"element3");
    System.out.println(list5);      // Output: [element1, element3, element2]

    ArrayList<String> list6 = new ArrayList();       //line2
    list6.add("element1");
    list6.add("element2");
    list6.add(1,"element3");
    System.out.println(list6);      // Output: [element1, element3, element2]

[Sergej Smoljanov]

when you use ArrayList<String> list6 = new ArrayList(); - this is only for old code work.
when you compile it you get warning (not compilation error)

uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

lest make some modifies:

        ArrayList raw = new ArrayList(); 
        raw.add(10);
        raw.add("hello");
        raw.add(new Object());
        ArrayList<String> list6 = raw;       //line2
        for(String val: list6){
            System.out.println(val);
        }

[Roel De Nijs]

Mushfiq Mammadov wrote:I couldn't find any difference and I want to know what is the difference between line1 and line2 in the following code?

Before Java 5 generics didn't exist at all. So you created an ArrayList as follows

ArrayList list = new ArrayList();

This code has several issues:

you can add anything to list (strings, integers, cats, dogs,...), so no type checking by the compiler

if you get an element of list, its type is always Object. Even if it was guaranteed to be a list with only strings, list.get(0) would return an Object (the actual object is of course a String). So if you wanted to invoke the length method, you had to cast to String first (and you know casting could be dangerous)

Some code to illustrate the above

list.add("Java");
list.add(new Cat());
list.add(Integer.valueOf(10));

Object o = list.get(0);
if (o instanceof String) {
  System.out.println("string length: " + ((String)o).length());
}

As you can see, it was a lot harder to make sure a list contained only strings. And even if it was such a list, you had to write some lines of code to treat the elements as strings instead of objects. Therefore adding generics to Java was a huge improvement! Code becomes smaller, easier to read and you get type checking at compile time.

That was a little history lesson! Now back to your original question. If you write

ArrayList<String> list5 = new ArrayList();

the list will work exactly the same as when you would have used ArrayList<String> list5 = new ArrayList<String>(); or ArrayList<String> list5 = new ArrayList<>();. But the compiler will produce a warning because you are mixing generic with non-generic code. Because the type of the reference variable is ArrayList<String>, you'll get the type checking at compile time.
If you do it the other way round (ArrayList list5 = new ArrayList<String>(); or ArrayList list5 = new ArrayList<>();), the code will still compile (with the same warning about mixing generic with non-generic code). But now list5 can hold any object (strings, integers, cats, dogs,...), because type of the reference variable is ArrayList and thus no type checking occurs at compile time (as in pre Java 5 code).

Hope it helps!
Kind regards,
Roel

(Disclaimer: for the OCAJP exams you don't have to worry about combining generic with non-generic code, it's not on these exams. But for the OCPJP exam you have to know all little intricacies about combining generic with non-generic code)

[Mushfiq Mammadov]

Sergej Smoljanov wrote: when you compile it you get warning (not compilation error)

uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

I often get this warning in console, but I don't know it so far. Thanks, Sergej

Roel De Nijs wrote: If you do it the other way round (ArrayList list5 = new ArrayList<String>(); or ArrayList list5 = new ArrayList<>();), the code will still compile (with the same warning about mixing generic with non-generic code). But now list5 can hold any object (strings, integers, cats, dogs,...), because type of the reference variable is ArrayList and thus no type checking occurs at compile time (as in pre Java 5 code).

I don't know this way is possible, thanks for your explanation, Roel