Question

Reading other people’s code, I’ve seen a lot of:

List<E> ints = new ArrayList<E>();
Map<K, V> map = new HashMap<K, V>();

My question is: what is the point/advantage of instantiating them that way as opposed to:

ArrayList<E> ints = new ArrayList<E>();
HashMap<K, V> map = new HashMap<K, V>();

What also makes it odd is that I’ve never seen anything like:

CharSequence s = new String("String");

or

OutputStream out = new PrintStream(OutputStream);

Duplicates (of the first part of the question):

When/why to use/define an interface

Use interface or type for variable definition in java?

When should I use an interface in java?

why are interfaces created instead of their implementations for every class

What's the difference between these two java variable declarations?

Answer 1

Quick answer? Using interfaces and superclasses increases the portability and maintainability of your code, principally by hiding implementation detail. Take the following hypothetical example:

class Account {
    private Collection<Transaction> transactions;

    public Account() {
        super();
        transactions = new ArrayList<Transaction>(4);
    }

    public Collection<Transaction> getTransactions() {
        return transactions;
    }
}

I’ve declared a contract for an Account that states that the transactions posted to the account can be retrieved as a Collection. The callers of my code don’t have to care what kind of collection my method actually returns, and shouldn’t. And that frees me to change up the internal implementation if I need to, without impacting (aka breaking) unknown number of clients. So to wit, if I discover that I need to impose some kind of uniqueness on my transactions, I can change the implementation shown above from an ArrayList to a HashSet, with no negative impact on anyone using my class.

public Account() {
    super();
    transactions = new HashSet<Transaction>(4);
}

As far as your second question, I can say that you use the principal of portability and encapsulation wherever they make sense. There are not a terrible lot of CharSequence implementations out there, and String is by far the most used common. So you just won’t see alot of developers declaring CharSequence variables in their code.