Find my Bug?

Hey I'm sorry to make a request on my first post on these forums, but the TA that usually answers these kind of questions via email is away on vacation. Maybe one of you can spot my bug?

This assignment (due tomorrow at 7 PM MST) requires that I count all the probes into a hash table as well as all insertions (and attempted insertions). This is coupled with a main method that uses this Class but the bug is certain to be in this class somewhere. I am either counting too many probes, or more likely, too few insertions. Perhaps someone can give me a tip on what I'm doing wrong?

public class SimpleHashSet
{
    // Instance variables.
    
    private Object[] table;
    private int      capacity;    
    private int      probeCount;
    public int[] probeCountArray;
    public int[] insertionAttempts;
    private int numFilled;
    
    /**
     * Builds a hash set with the specified maximum size.
     * 
     * @param capacity the size of the hash table
     */
    public SimpleHashSet (int capacity)
    {
        this.capacity   = capacity;
        this.table      = new Object[capacity];
        this.probeCount = 0;
        this.numFilled = 0;

this.probeCountArray = new int[capacity + 1];
        this.insertionAttempts = new int[capacity + 1];
    }
    
    /**
     * Adds the specified element to the set.  If the hash
     * table already contains an object equal to the specified
     * object, the specified object will not be added.
     * 
     * @param element any object
     * @throws TableFullException if the hash table is full
     */
    public void add (Object element)
    {
        ///// You must complete this method /////
        
        // 1. Compute the hash code for the element, confine it to the table size.
        //   (A simple mod-based hash function.)  This will be the array index.
        //   Watch out for negative hash codes!
        
        int hash = Math.abs(element.hashCode()) % capacity;
        
        // 2. Try to insert the element at the hash code location.  Use a loop instead of an if statement.
        // If the loop repeats, advance by one to the next open spot (linear probing).

for(int retry = 0; retry < capacity; retry++)
        {
            Object retrieved = table[(retry + hash) % capacity];
            this.probeCountArray[numFilled]++;
            
            if(retrieved == null)
            {
                table[(retry + hash) % capacity] = element;
                insertionAttempts[numFilled]++;
                numFilled++;
                return;
            }
            else if(retrieved.equals(element))
            {
                insertionAttempts[numFilled]++;
                return;
            }
        }
        
        insertionAttempts[numFilled]++;
        throw new TableFullException();
        
    }
    
    /**
     * Returns true if this element is in the set.  The
     * element is considered to be in the set if it is
     * equal to any object in the set.
     * 
     * @param element any object
     * @return true if the element is in the set
     */
    public boolean contains (Object element)
    {
        ///// You must write this method /////
        
        
        int hash = Math.abs(element.hashCode()) % capacity;
        
        for(int retry = 0; retry < capacity; retry++)
        {
            Object retrieved = table[(retry + hash) % capacity];
            this.probeCountArray[numFilled]++;
            
            if(retrieved == null)
            {
                return false;
            }
            else if(retrieved.equals(element))
            {
                return true;
            }
        }
        
        return false;  
    }
    
    /**
     * Removes the specified element from the set.  If the
     * set does not contain an object equal to the element,
     * nothing happens.
     */
    public void delete (Object element)
    {
        // Compute the hash code for the element, confine it to the table size.
        //   (A simple division-based hash function.)
        
        int hash = Math.abs(element.hashCode()) % capacity;
        
        // Try to locate the element at the hashed position.  If it is not
        //   there, simply return.
        
        int retry = 0;
        for (; retry < capacity; retry++)
        {
            // Determine what is in the hash table by probing it.
            
            Object probed = table[(hash + retry) % capacity];
            probeCountArray[numFilled]++;
            
            // If that location in the table is empty, the element is not in the table.
            
            if (probed == null)
                return;
            
            // If that location contains the element, terminate the loop.

if (probed.equals(element))
                break;
        }
        
        // If the table was full, but the element was not found, return.
        
        if (retry == capacity)
            return;
        
        // Remove the element.  This involves possibly moving other elements
        //   in the hash table to collapse the cluster.
        
        int freePosition = (hash + retry) % capacity;
        
        for (int count = 1; (freePosition + count) % capacity != hash; count++)
        {
            // Determine what is in the hash table by probing it.
            
            Object probed = table[(freePosition + count) % capacity];
            probeCountArray[numFilled]++;
            
            // If null, we're done collapsing the cluster.
            
            if (probed == null)
                break;
            
            // If the probed object could legally occupy the free position, put it in the free position.
            //   To do this, determine the retry count that was used to place the probed element
            //   in the cache.
            
            int probedHash  = Math.abs(probed.hashCode()) % capacity;
            int probedRetry = ((freePosition + count) - probedHash + capacity) % capacity; 
            
            // If the probed retry is greater than or equal to our offset from the free
            //   position, move the element into the free position.
            
            if (probedRetry >= count)
            {                
                table[freePosition] = probed;
                freePosition = (freePosition + count) % capacity;
                count = 0;
            }
        }
        
        // Clear the free position.
        
        table[freePosition] = null;
        numFilled--;
    }
    
    /**
     * Returns a string that indicates which elements of the
     * table are used.
     * 
     * @return a string that shows table usage.
     */
    public String getClusterMap ()
    {
        StringBuilder result = new StringBuilder(table.length);
        for (Object o : table)
            result.append(o == null ? '.' : 'X');
        
        return result.toString();
    }
    
    /**
     * Displays the number of probes made to the table and the number of insertions
     * as arrays.  Furthermore, this will display the number of probes per capacity
     * per insertion as a function of load.  That is, the position in the arrays
     * is the number of elements at that time.  
     * 
     * 
     * @return the probe count
     */
    public void displayStatistics ()
    {
        System.out.println("Probes:");
        for(int i = 0; i < capacity; i++)
        {
            System.out.print(probeCountArray[i] + " ");
        }
        System.out.println();
        System.out.println("Insertions:");
        for(int i = 0; i < capacity; i++)
        {
            System.out.print(insertionAttempts[i] + " ");
        }
        System.out.println();
        System.out.println("Probes per capacity per insertion:");
        for(int i = 0; i < capacity; i++)
        {
            System.out.print((probeCountArray[i] / capacity) / insertionAttempts[i] + " ");
        }
    }

/**
     * Resets the probe count to 0.
     */
    public void resetProbeCount ()
    {
        probeCount = 0;
    }
    
    /**
     * A debugging method for printing out the table contents.
     */
    public void debugTable ()
    {
        for (int i = 0; i < capacity; i++)
        {
            System.out.print ("Position " + i + ": " + table[i]);
            if (table[i] != null)
                System.out.println (" (hashes to location " + (Math.abs(table[i].hashCode()) % capacity) + ")");
            else
                System.out.println ();            
        }
        System.out.println();
    }
    
    /**
     * An exception class for indicating the table is full.
     */
    static class TableFullException extends RuntimeException
    {
        TableFullException ()
        {
            super ("The hash table is full.");
        }
    }    
}

Any help or suggestions will be VERY much appreciated.

Thanks!