ConcreteSet

The following usage example is part of the test included with the source code:

package rrc12;
import java.util.*;
import rrc12.util.*;

/** Example of ConcreteSet usage.  Puts Sets through their paces. */
public class Example  {

    /** Class for objects used inside Set instances.  Pretty much the
     * same as the Integer class, but the hash codes are not so nice,
     * with every four possible elements sharing one hash code. */
    private static class Entry  implements Comparable  {
        private int  value;
        private int  hashValue;

        public Entry( int i )  {
            value = i;
            hashValue = i >> 2;
        }
        public Entry( Entry e )  { this( e.value ); }

        public int hashCode()  { return hashValue; }
        public boolean equals( Object o )  {
            return (o instanceof Entry   &&  ((Entry) o).value == value);
        }
        public String toString()  { return Integer.toString( value ); }
        public int compareTo( Object o )  {
            Entry  e = (Entry) o;
            if (value < e.value)  return -1;
            if (value > e.value)  return 1;
            return 0;
        }
    }

    /** The main program.  Runs a series of tests and timings on several
     * sets, including ConcreteSet and  HashSet. */
    public static void main( String[] args )  {
        ConcreteSet  setA = new ConcreteSet();
        Set  setB = new HashSet( 300 );
        Set  setC = new TreeSet();
        HashSet setD = new HashSet( 45000 );

        if (setB.equals( setA ))
            System.out.println(
                        "ConcreteSet equals HashSet after test" );

        setA.clear();
        setB.clear();
        setC.clear();
        setD.clear();

        runSpeedTest( "ConcreteSet", setA );
        runSpeedTest( "HashSet", setB );
        runSpeedTest( "TreeSet", setC );
        runSpeedTest( "Big HashSet", setD );
        if (setA.equals( setD ))
            System.out.println(
                        "ConcreteSet equals HashSet after speed test" );
        {
            // Test pop method.
            int  count = 0;
            boolean  mismatch = false;
            for (;;)  {
                Object  entry = setA.pop();
                if (entry == null)  break;
                if (!setD.contains( entry ))
                    mismatch = true;
                count++;
            }
            if (!mismatch  &&  count == 10000)
                System.out.println( "Pop test good." );
        }
    }

    /** Does a generic speed test. */
    private static void runSpeedTest( String title, Set set )  {
        LinkedList  all_list = generate( null, 1, 20000 );
        generate( all_list, 10001, 30000 );
        LinkedList  removelist = generate( null, 10001, 20000 );
        LinkedList  retainlist = generate( null, 5001, 25000 );
        LinkedList  containlist = generate( null, 5011, 9090 );
        generate( containlist, 20011, 24090 );

        boolean  accurate = true;
        long  time = System.currentTimeMillis();
        set.addAll( all_list );

        if (set.size() != 30000)
            accurate = false;

        set.removeAll( removelist );
        set.retainAll( retainlist );
        if (!set.containsAll( containlist ))
            accurate = false;
        Object[]  array = set.toArray();
        {
            int  count = array.length;
            if (count != 10000)
                accurate = false;
        }
        System.out.println( title + ":  speed time: " +
                    (System.currentTimeMillis() - time) + "   good: " +
                    accurate );
    }

    /** Generates a LinkedList containing Entry instances with all values
     * between s and f.
     * @param list  an existing list, to which values will be appended.
     * Set null to create a new list.
     * @param s  the first value.
     * @param f  the last value.
     * @return  a LinkedList containing the specified values. */
    private static LinkedList
                generate( LinkedList list, int s, int f )  {
        if (list == null)
            list = new LinkedList();
        for (int i = s; i <= f; i++)
            list.addLast( new Entry( i ) );
        return list;
    }
}