Java null element in ArrayList

Yes, take a look on a add() method implementation, for example:

public boolean add(E object) {
    Object[] a = array;
    int s = size;
    if (s == a.length) {
        Object[] newArray = new Object[s +
                (s < (MIN_CAPACITY_INCREMENT / 2) ?
                 MIN_CAPACITY_INCREMENT : s >> 1)];
        System.arraycopy(a, 0, newArray, 0, s);
        array = a = newArray;
    }
    a[s] = object;
    size = s + 1;
    modCount++;
    return true;
}

Since ArrayList.size() returns just the value of size variable, it's clear, that if you add null, the size will be increased by 1, so, yes, null is counted.

You can remove all the elements from your list

MyList.removeAll(Collections.singleton(null));
MyList.size();

Reference: http://www.mhaller.de/archives/12-How-to-remove-all-null-elements-from-a-Collection.html

Yes and Yes, you can verify it with this simple code

public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        list.add("" + i);
    }
    System.out.println(list.size() + " " + list);
    list.set(0, null);
    System.out.println(list.size() + " " + list);
}

10 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
10 [null, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Yes, the null element will still be counted in the size of the list and the indices of the remaining element will remain intact.

It's a bad idea to infer class behaviour from test code or reading the source code, also because ArrayList is not final and the class you obtain may be an extended version of ArrayList with a different implementation.

Just read List and ArrayList contracts, that must be mantained in the extending classes:

List:

An ordered collection (also known as a sequence). ... Some list implementations have restrictions on the elements that they may contain. For example, some implementations prohibit null elements, and some have restrictions on the types of their elements.

ArrayList:

Resizable-array implementation of the List interface. Implements all optional list operations, and permits all elements, including null.

the contract says that ArrayList permits null elements, so the answer to you question is yes, the list size and indices remains intact.