Unterschied zwischen einer leeren ArrayList und eine ArrayList mit null Elemente?

Ich bin der Codierung einige Prüfungen für einen REST-service, die Parsen einer JSON und ich fand heraus, etwas, das klingt verrückt für mich (ich bin kein JAVA Experte überhaupt).

In Erwägung ziehen, mit zwei ArrayLists:

ArrayList<Object> list1 = new ArrayList<Object>();
ArrayList<Object> list2 = new ArrayList<Object>();

Beide Listen haben etwas gemeinsamen: Sie sind komplett leer (oder full-null-Elemente). Aber wenn ich das Tue:

list1.add(null);

Obwohl beide bleiben völlig leer, Sie haben ganz unterschiedliche Verhaltensweisen. Zu machen, und einige Methoden sind die Ergebnisse sehr unterschiedliche:

System.out.println(list1.contains(null));  //prints true!
System.out.println(list2.contains(null));  //prints false

System.out.println(CollectionUtils.isNotEmpty(list1));  //prints true
System.out.println(CollectionUtils.isNotEmpty(list2));  //prints false

System.out.println(list1.size());  //prints 1
System.out.println(list2.size());  //prints 0

Etwas Forschung zu tun, und im Blick auf die Umsetzung jedes der folgenden Methoden können Sie bestimmen, der Grund für diese Unterschiede, aber immer noch nicht verstehen, warum es gültig oder nützlich, zu unterscheiden zwischen diesen Listen.

• Warum add(item) nicht überprüfen, ob Element!=null ?
• Warum enthält(null) sagt false wenn die Liste voll ist von null?

Vielen Dank im vorraus!!!!!!

EDIT:

Bin ich meistens einverstanden mit den Antworten, aber ich bin noch nicht überzeugt alle. Dies ist die Implementierung der Methode remove:

/**
 * Removes the first occurrence of the specified element from this list,
 * if it is present.  If the list does not contain the element, it is
 * unchanged.  More formally, removes the element with the lowest index
 * <tt>i</tt> such that
 * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>
 * (if such an element exists).  Returns <tt>true</tt> if this list
 * contained the specified element (or equivalently, if this list
 * changed as a result of the call).
 *
 * @param o element to be removed from this list, if present
 * @return <tt>true</tt> if this list contained the specified element
 */
public boolean remove(Object o) {
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}


/*
 * Private remove method that skips bounds checking and does not
 * return the value removed.
 */
private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; //clear to let GC do its work
}

So, jetzt, wenn ich tun:

ArrayList<Object> list = new ArrayList<Object>();
list.add(null);
System.out.println(list.contains(null)); //prints true!
list.remove(null);
System.out.println(list.contains(null));  //prints false!

, was ich bin fehlt?