Helper to remove null references in a Java List?

Question

Given the following List:

List<String> list = new ArrayList<String>();

list.add("s1");
list.add("s2");
list.add(null);
list.add("s3");
list.add(null);
list.add("s4");

I need a helper class that removes null references. Something like:

SomeHelper.removeNullReference(list);

such that the list only contains "s1", "s2", "s4", "s4" (non-null references).

What should I use to fulfill this requirement?

Answer 1

list.removeAll(Collections.singleton(null));

Answer 2

Java 8 added Collection.removeIf(Predicate) that removes all elements matching the predicate, so you can remove all occurrences of null from a list (or any collection) with

list.removeIf(Objects::isNull);

using java.util.Objects.isNull as a Predicate.

You can also use .removeIf(x -> x == null) if you prefer; the difference is very minor.

Answer 3

A drawback of Don's approach is that it extends from ArrayList. That may be good enough for now, but what happens when you want to use a different List implementation? You could make a NoNullsLinkedList and a NoNullsCopyOnWriteArrayList, etc, but then you wind up with a bunch of little classes that differ only in their extends clause. It might be better to create a List wrapper that doesn't accept null values. For example:

public class NonNullList<E> extends AbstractList<E> {
  private final List<E> delegate;

  public NonNullList(List<E> delegate) {
    this.delegate = delegate;
  }

  @Override
  public E get(int index) {
    return delegate.get( index );
  }

  @Override
  public int size() {
    return delegate.size();
  }

  @Override
  public E set(int index, E element) {
    return delegate.set( index, element );
  }

  @Override
  public void add(int index, E element) {
    if( element != null ) {
      delegate.add( index, element );
    }
  }

  @Override
  public E remove(int index) {
    return delegate.remove( index );
  }
}

It's more code, but now you have the flexibility of choosing a List implementation when you create the object.

A possible problem is that you can still insert nulls into the underlying List object. Don's approach doesn't have the same limitation.

Answer 4

If you can control the instantiation of the List then you could prevent the nulls being added by writing a custom List implementation such as:

public class NoNullsList<E> extends ArrayList<E> {

  public void add(int index, E element) {
    if (element != null) {
      super.add(index, element);
    }
  }

  public boolean add(E e) {
    return e == null ? false : super.add(e);
  }
}

AFAIK, you don't need to override addAll because the ArrayList implementation thereof calls add.

List<String> list = new NoNullsList<String>();

list.add("s1");
list.add("s2");
list.add(null);
list.add("s3");
list.add(null);
list.add("s4");

Answer 5

I really like the Java 8's new concise solution, I believe you should use that whenever possible.

list.removeIf(Objects::isNull);

On the other side, if you are looking for a simple implementation to learn how it could be done, such as a helper class that returns new non-null list, you can take a look at the following code. It can also be made to accept generic types, for the sake of simplicity I used the same collection type (as in the question) in the helper class.

package removenullrefdemo;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

class ListHelper {
    public static List<String> removeNullReference(List<String> list) {
        List<String> newList = new ArrayList<>();

        list.forEach(item -> {
            if (item != null)
                newList.add(item);
        });

        return newList;
    }
}

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();

        list.add("s1");
        list.add("s2");
        list.add(null);
        list.add("s3");
        list.add(null);
        list.add("s4");

        println("Items:");
        list.forEach(item -> println(item));

        // Remove null refs
        println("Items (after nulls removed):");
        boolean useJava8removeIf = false;
        if (useJava8removeIf) {
            println("Using Java8 removeIf method with predicate.");
            list.removeIf(Objects::isNull);
        }
        else {
            println("Using our own helper.");
            list = ListHelper.removeNullReference(list);
        }

        list.forEach(item -> println(item));

    }

    static void println(String msg) {
        System.out.println(msg);
    }
}