Difference between an empty ArrayList and an ArrayList with null elements?

Question

I am coding some validators for a REST service which parses a JSON and I found out something that sounds weird for me (I am not a Java expert at all).

Consider having two ArrayLists:

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

Both lists have something in common, they are completely empty (or full of null elements). But if I do:

list1.add(null);

Although both remain completely empty, they have completely different behaviors. And to make some methods the results are very different:

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

Doing some research, and looking at the implementation of each of these methods, you can determine the reason for these differences, but still do not understand why it would be valid or useful to differentiate between these lists.

Why add(item) doesn't validate if item!=null?
Why contains(null) says false if the list is full of nulls?

I am mostly agree whit the answers, but I'm not yet convinced all. This is the implementation of the method 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, now if i do:

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!

What am I missing?

Java collections allow for null elements. This is a design decision you'll have to live with (or choose a different collections framework). — aioobe
– aioobe, Commented Nov 24, 2015 at 19:34
You would need to understand what null is: See stackoverflow.com/questions/2707322/what-is-null-in-java — evargas
– evargas, Commented Nov 24, 2015 at 19:36
Given only the lines of code you have shown, list2.size() should print 0, not 2. Is that a mistake in the comment or are there lines of code you didn't show? — RealSkeptic
– RealSkeptic, Commented Nov 24, 2015 at 19:38
To say list2 is full of nulls is incorrect. list2 doesn't contain anything, not even a single null element. — GriffeyDog
– GriffeyDog, Commented Nov 24, 2015 at 19:39
When I run your second program, the second System.out.println prints false. — Louis Wasserman
– Louis Wasserman, Commented Nov 24, 2015 at 20:18

dsh · Accepted Answer · 2015-11-24 19:34:04Z

13

A list containing null is NOT empty. It contains null. Lists are allowed to contain null, so you can put null in it if you want.

answered Nov 24, 2015 at 19:34

dsh

12.3k3 gold badges37 silver badges53 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

melli-182 Over a year ago

Ok! Thats right, i agree with you. But, whats the difference between list 1 and 2?

Pshemo Over a year ago

"Lists are allowed to contain null" can be misleading since there is no guarantee that all list do so. But it is true in case of ArrayList.

dsh Over a year ago

@melli-182 The difference is one is empty, and one has something (a null) in it. Write a loop to print out the elements and you'll see that one executes the loop body zero times with no output and one executes one time with one line of output. One of them will throw an ArrayIndexOutOfBounds exception if you try to .get(0) and the other will return to you the null value that is at index 0.

Wormbo · Accepted Answer · 2015-11-24 19:34:47Z

3

An ArrayList explicitly is allowed and able to store null values, because they might be meaningful to your program. And empty list is empty (i.e. doesn't contain anything, not even null. After you successfully add(null) (it returns true to signal success), the list must obviously return true on contains(null) as well. In fact, you can even remove(null) from that list and it will be empty again.

answered Nov 24, 2015 at 19:34

Wormbo

5,0102 gold badges23 silver badges43 bronze badges

Comments

soulsabr · Accepted Answer · 2015-11-24 19:36:36Z

1

Fortunately you don't have to be a java expert or an expert at all.

The best way to think of this is like a parking lot. An array with null elements is like a parking lot with nothing parked in it. An empty array is like the plans for a parking lot.

answered Nov 24, 2015 at 19:36

soulsabr

9044 silver badges16 bronze badges

Comments

John Bollinger · Accepted Answer · 2015-11-24 19:44:23Z

A List is empty if it contains zero elements. This is both the natural meaning of the term and the test performed by the isEmpty() method.

null is a value that any ArrayList may contain as an element. Clearly, in that case the list has at least one element, and therefore is not empty. No matter what the initial state of a List, if an invocation of add(null) on that list completes normally then afterward the list is not empty. Similarly, each null element in a list contributes to its size.

Why add(item) doesnt validate if item!=null ?

Ask Joshua Bloch. He designed it. Most people take him to be a pretty smart guy, and consider the Collections API a highly successful effort.

Seriously, it is a design choice that Lists may contain null elements. (Implementations are permitted to reject nulls, but ArrayList, as a general-purpose implementation, accepts them).

Why contains(null) says false if the list is full of nulls?

It doesn't. Don't just take my word for it -- the data you present also contradict you.

Matej · Accepted Answer · 2015-11-24 21:00:58Z

The entire confusion stems from the incorrect initial assumption that the ArrayLists you created are full of nulls. They are not, they are completely empty - meaning they have zero elements. As such, you will get false if you call contains(null)on them, and true when you call isEmpty().

Once you added null to list1, it ceased to be empty, and indeed contains a null element - list2 is still empty and still doesn't contain null.

In your last code sample, the second call to Collections.isNotEmpty definitely does not return true. The list had one null element, you removed it, so it's empty again.

The main take-aways here are:

Calling either the empty constructor, or the constructor with initial capacity of an ArrayList creates an empty list. This list does not contain any elements, not even null.
null is a perfectly valid element of an ArrayList. The cases where this might be useful are not extremely common but they do exist.

Ahmad Ahmad · Accepted Answer · 2024-11-17 08:18:55Z

ArrayList typically use an iterator that determines the actual number of elements (size). The rest of elements are set to null and aren't accessible (I guess for performance reasons).

ArrayList<Integer> nums = new ArrayList<>(20);
System.out.println(nums.size()); // 0
System.out.println(nums.contains(null)); // false.
nums.add(null);
System.out.println(nums.size()); // 1
System.out.println(nums.contains(null)); // true

as you can see the actual number of elements was 0 in the first code (even if the capacity is 20, method won't work based on it), so the number of accessible elements is 0, and of course null won't be found in this case.

in the second code you have 1 accessible value which is null and that's why you'll get true.

In essence, any value that isn't explicitly inserted will be treated like it doesn't exist.

Atomiz · Accepted Answer · 2022-02-22 16:36:29Z

-1

The difference is in the List size, not its capacity. When instantiating a new ArrayList<>(5), the initial capacity is set to 5, but the size remains 0, because we haven't added any elements. If we invoke add(null) only the elements size() will increase and all functions iterating through the array of elements will remain inbetween the size of the List, not the capacity.

This is so when we need to rapidly add new elements, the array doesn't get copied into another array with a size + 1, instead Java increases the capacity by half when the size is equal to it to improve the performance by reducing the functions performed.

answered Feb 22, 2022 at 16:36

Atomiz

711 silver badge4 bronze badges

Collectives™ on Stack Overflow

Difference between an empty ArrayList and an ArrayList with null elements?

7 Answers 7

3 Comments

Comments

Comments

Comments

Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

7 Answers 7

3 Comments

Comments

Comments

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related