Hello all!

I've written a custom array list that simply denies adding null
elements and duplicates. I build lists with string, which at some
point need to get sorted alphanumerically (using Collections.sort).

However, when using the custom list with Collections.sort, the list is
*not* sorted, but standard array list is...

Does anyone know why it is not sorted?

Here's a SSCCE:

import java.util.*;

/**
* An array list that does not allow duplicate and null elements.
*
* @author kw
*
* @param <E>
*/
public class NoDupesNoNullsArrayList<E> extends ArrayList<E>
{
    public static void main(String[] strArgs)
    {
        String[] strs = {"one", "two", "three", "four", "five", "six",
"seven", "eight", "nine", "ten", "ten", "ten"};

        System.out.println("Number of strings: " + strs.length);

        List<String> lsNormal = new ArrayList<String>();
        List<String> lsCustom = new NoDupesNoNullsArrayList<String>();

        //some manual null adds to show the custom list should work
        lsCustom.add(null);
        lsCustom.add(null);
        lsCustom.add(null);
        lsCustom.add(null);
        lsCustom.add(null);
        lsCustom.add(null);

        //add all
        for ( String str : strs )
        {
            lsNormal.add(str);
            lsCustom.add(str);
        }

        System.out.println("Number of list entries: normal = " +
lsNormal.size() + ", custom = " + lsCustom.size());

        //now do standard alphanumeric sort
        Collections.sort(lsNormal);
        Collections.sort(lsCustom);

        //result should be: eight, five, four, nine, one, seven, six, ten,
three, two

        System.out.println();
        System.out.print("Normal: ");

        //print normal sorted
        for ( String str : lsNormal )
        {
            System.out.print(str + ", ");
        }

        System.out.println();
        System.out.print("Custom: ");

        //print custom sorted
        for ( String str : lsCustom )
        {
            System.out.print(str + ", ");
        }

    }

    public NoDupesNoNullsArrayList()
    {
        super();
    }

    public NoDupesNoNullsArrayList(Collection<? extends E> cln)
    {
        super(cln);
    }

    public NoDupesNoNullsArrayList(int initialCapacity)
    {
        super(initialCapacity);
    }

    @Override
    public boolean add(E elem)
    {
        if ( elem == null )
        {
            return false;
        }

        if ( contains(elem) )
        {
            return false;
        }

        return super.add(elem);
    }

    @Override
    public void add(int index, E elem)
    {
        if ( elem == null )
        {
            return;
        }

        if ( contains(elem) )
        {
            return;
        }

        super.add(index, elem);
    }

    @Override
    public boolean addAll(Collection<? extends E> cln)
    {
        return addAll(size(), cln);
    }

    @Override
    public boolean addAll(int index, Collection<? extends E> cln)
    {
        if ( cln == this )
        {
            throw new IllegalArgumentException("Collection is this!");
        }

        if ( cln == null || containsAll(cln) )
        {
            return false;
        }

        //build list without dupes (always, no case as in NoNulls... lists)
        ArrayList<E> al = new ArrayList<E>(cln.size());

        Iterator<? extends E> itr = cln.iterator();

        while ( itr.hasNext() )
        {
            E elem = itr.next();

            if ( elem != null && !contains(elem) )
            {
                al.add(elem);
            }
        }

        cln = al;

        //allows dupes and nulls
        return super.addAll(index, cln);
    }

    @Override
    public E set(int index, E elem)
    {
        if ( elem == null )
        {
            return null;
        }

        if ( contains(elem) )
        {
            return null;
        }

        return super.set(index, elem);
    }

}

It might not appear THAT short, just don't care too much about the
array list implementation...

Any ideas?

Karsten