I've run into a bit of a snag.

When I insert an object into the hash table, I pass in (a reference to)
the object, and a hash code, which can either be based on the last name
or the student number.  To deal with collisions, I use a quadratic
probing technique...

    void insert(Object obj, int hash) throws HashTableFull
    {
        if( count == table.length ) throw new HashTableFull("Cannot insert:
hash table is full");
        int key = probe(hash);
        table[key] = obj;
        ++count;
    }

    int sign(int i)
    {
        if( i < 0 ) return -1;
        return 1;
    }

    int probe(int hash)
    {
        int probe = 0;

        while(true)
        {
            int key = (hash + probe*probe*sign(probe)) % table.length;

            if( table[key] == null )
                return key;

            if( probe <= 0 )
                probe = -probe+1;
            else
                probe = -probe;
        }
    }

Which, in theory, should work nicely.  However... when retrieving the
object, how do I know when I've found the right one?

    Object find(int hash) throws ObjectNotFound
    {
        int probe = 0;

        for(int i=0; i<table.length; i++)
        {
            int key = (hash + probe*probe*sign(probe)) % table.length;

            if( /* table[key] == ??? */ )
                return table[key];

            if( probe <= 0 )
                probe = -probe+1;
            else
                probe = -probe;
        }
       
        throw new ObjectNotFound("Object not found");
    }

...>

Not sure quite what you mean by 'the number is dependent on the name'.
You would need to be able to map to a student's number given a student
name but the name does not determine the ID -- they are associated
by a table.   If you have students who have a name but no number
then this approach won't work but if every student has a number if
should be fine.

In practice one normally uses a student number because student
names are not reliable indices for the database.  It's common for
multiple students to have the same name and there can be many
variations on how the name is coded. E.g., I've seen just my last name
written as McGlynn, Mc Glynn, MCGLYNN or Mcglynn.
Numbers (or some equivalent coding) insure uniqueness and standardize
how the a coding for the record indices.

The database records are indexed by the number/code and when users
want to query by name there is a translation from the name to the
number and
then a search for  the associated record.

This allows graceful handling of the case when two students
have the same name.  If multiple numbers match a name,
the user is asked for additional information to resolve the ambiguity.

This code is cleanly separated from the code that uses the student
records.   There is a single method for getting  the student's records
once we have resolved any ambiguities about which student is
involved.

Of course, this may not fit with your database or your other
requirements
but it's a bit of what database programmers call database normalization
poking into a Java implementation.

    Regards,
    Tom McGlynn