Is there any null free list data structure?

Question

I am using LinkedList data structure serverList to store the elements in it. As of now, it can also insert null in the LinkedList serverList which is not what I want. Is there any other data structure which I can use which will not add null element in the serverList list but maintain the insert ordering?

    public List<String> getServerNames(ProcessData dataHolder) {
        // some code

        String localIP = getLocalIP(localPath, clientId);
        String localAddress = getLocalAddress(localPath, clientId);

        // some code

        List<String> serverList = new LinkedList<String>();

        serverList.add(localIP);
        if (ppFlag) {
            serverList.add(localAddress);
        }
        if (etrFlag) {
            for (String remotePath : holderPath) {
                String remoteIP = getRemoteIP(remotePath, clientId);
                String remoteAddress = getRemoteAddress(remotePath, clientId);
                serverList.add(remoteIP);
                if (ppFlag) {
                    serverList.add(remoteAddress);
                }
            }
        }

        return serverList;
    }

This method will return a List which I am iterating it in a for loop in normal way. I can have empty serverList if everything is null, instead of having four null values in my list. In my above code, getLocalIP, getLocalAddress, getRemoteIP and getRemoteAddress can return null and then it will add null element in the linked list. I know I can add a if check but then I need to add if check four time just before adding to Linked List. Is there any better data structure which I can use here?

One constraint I have is - This library is use under very heavy load so this code has to be fast since it will be called multiple times.

Answer 1

I am using LinkedList data structure serverList to store the elements in it.

That's most probably wrong, given that you're aiming at speed. An ArrayList is much faster unless you're using it as a Queue or alike.

I know I can add a if check but then I need to add if check four time just before adding to Linked List. Is there any better data structure which I can use here?

A collection silently ignoring nulls would be a bad idea. It may be useful sometimes and very surprising at other times. Moreover, it'd violate the List.add contract. So you won't find it in any serious library and you shouldn't implement it.

---

Just write a method

void <E> addIfNotNullTo(Collection<E> collection, E e) {
     if (e != null) {
         collection.add(e);
     }
}

and use it. It won't make your code really shorter, but it'll make it clearer.

---

One constraint I have is - This library is use under very heavy load so this code has to be fast since it will be called multiple times.

Note that any IO is many orders of magnitude slower than simple list operations.

Answer 2

Use Apache Commons Collection:

ListUtils.predicatedList(new ArrayList(), PredicateUtils.notNullPredicate());

Adding null to this list throws IllegalArgumentException. Furthermore you can back it by any List implementation you like and if necessary you can add more Predicates to be checked.

Same exists for Collections in general.

Answer 3

There are data structures that do not allow null elements, such as ArrayDeque, but these will throw an exception rather than silently ignore a null element, so you'd have to check for null before insertion anyway.

If you're dead set against adding null checks before insertion, you could instead iterate over the list and remove null elements before you return it.

Answer 4

The simplest way would be to just override LinkedList#add() in your getServerNames() method.

List<String> serverList = new LinkedList<String>() {
    public boolean add(String item) {
        if (item != null) {
          super.add(item);
          return true;
        } else
          return false;
    }
};

serverList.add(null);
serverList.add("NotNULL");
System.out.println(serverList.size()); // prints 1

If you then see yourself using this at several places, you can probably turn it into a class.

Answer 5

You can use a plain Java HashSet to store your paths. The null value may be added multiple times, but it will only ever appears once in the Set. You can remove null from the Set and then convert to an ArrayList before returning.

Set<String> serverSet = new HashSet<String>();

    serverSet.add(localIP);
    if (ppFlag) {
        serverSet.add(localAddress);
    }
    if (etrFlag) {
        for (String remotePath : holderPath) {
            String remoteIP = getRemoteIP(remotePath, clientId);
            String remoteAddress = getRemoteAddress(remotePath, clientId);
            serverSet.add(remoteIP);
            if (ppFlag) {
                serverSet.add(remoteAddress);
            }
        }
    }

serverSet.remove(null);     // remove null from your set - no exception if null not present
List<String> serverList = new ArrayList<String>(serverSet);

return serverList;

Answer 6

Since you use Guava (it's tagged), I have this alternative if you have the luxury of being able to return a Collection instead of a List.

Why Collection ? Because List forces you to either return true or throw an exception. Collection allows you to return false if you didn't add anything to it.

class MyVeryOwnList<T> extends ForwardingCollection<T> { // Note: not ForwardingList
  private final List<T> delegate = new LinkedList<>(); // Keep a linked list
  @Override protected Collection<T> delegate() { return delegate; }

  @Override public boolean add(T element) {
    if (element == null) {
      return false;
    } else {
      return delegate.add(element);
    }
  }

  @Override public boolean addAll(Collection<? extends T> elements) {
    return standardAddAll(elements);
  }
}