Question

What is reason behind supporting the syntax below on java 1.7

List<Integer> ints=new ArrayList<>();

What flexibility does it provide?
If we wanted ints to be of a different type we would explicitly cast it and it would throw an error if the conversion could not be performed.

I am also not clear on how exactly does this work.Since List is an interface how are we able to call a method on it

List<Integer> ints = Arrays.asList(1,2);
ints.get(1);

Since return type of asList() is static<T> List<T> it’s okay to access a field of a static interface without any class providing an implementation of it.But how are we able to access a method on such an interface
The collections library has a lot of them like Collections.Sort()
Who provides the implementation of these methods?

Answer 1

Question 1

Using

List<Integer> ints=new ArrayList<>();

instead of

List<Integer> ints=new ArrayList<Integer>();

doesn’t add any flexibility as they’re exactly equivalent. The diamond (<>) indicates that we don’t want the raw type but the obvious parameterized type.

Oracle describes it here :

In Java SE 7, you can substitute the parameterized type of the
constructor with an empty set of type parameters (<>):

It just makes the code a little less verbose, thus easier to read and maintain. This is probably more evident on Oracle’s example :

Map<String, List<String>> myMap = new HashMap<>();

compared to

Map<String, List<String>> myMap = new HashMap<String, List<String>>();

Question 2

Arrays.asList(1,2); returns an object from a concrete class implementing the List interface.

In Java 1.6, it’s an instance of the fixed-size java.util.Arrays.ArrayList :

3354    public static <T> List<T> asList(T... a) {
3355        return new ArrayList<T>(a);
3356    }

but the important point is that an object always is of a concrete class implementing the methods its interfaces defines.

When you’re doing Collections.sort(, you’re not using the Collection interface but the Collections class which contains this very concrete code :

132     public static <T extends Comparable<? super T>> void sort(List<T> list) {
133         Object[] a = list.toArray();
134         Arrays.sort(a);
135         ListIterator<T> i = list.listIterator();
136         for (int j=0; j<a.length; j++) {
137             i.next();
138             i.set((T)a[j]);
139         }
140     }