public SymbolTable() 
{
        this(TABLE_SIZE, 0.75f);
}

Constructs a new, empty SymbolTable with a default initial capacity (101) and load factor, which is 0.75.

 public SymbolTable(int initialCapacity) 
{
        this(initialCapacity, 0.75f);
}

Constructs a new, empty SymbolTable with the specified initial capacity and default load factor, which is 0.75.

Parameters:

initialCapacity - the initial capacity of the hashtable.

Throws:

IllegalArgumentException - if the initial capacity is less than zero.

 public SymbolTable(int initialCapacity,
    float loadFactor) 
{
    //
    // Constructors
    //
        if (initialCapacity <  0) {
            throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
        }
        if (loadFactor < = 0 || Float.isNaN(loadFactor)) {
            throw new IllegalArgumentException("Illegal Load: " + loadFactor);
        }
        if (initialCapacity == 0) {
            initialCapacity = 1;
        }
        fLoadFactor = loadFactor;
        fTableSize = initialCapacity;
        fBuckets = new Entry[fTableSize];
        fThreshold = (int)(fTableSize * loadFactor);
        fCount = 0;
}

Constructs a new, empty SymbolTable with the specified initial capacity and the specified load factor.

Parameters:

initialCapacity - the initial capacity of the SymbolTable.

loadFactor - the load factor of the SymbolTable.

Throws:

IllegalArgumentException - if the initial capacity is less than zero, or if the load factor is nonpositive.

 public String addSymbol(String symbol) 
{
        
        // search for identical symbol
        int bucket = hash(symbol) % fTableSize;
        for (Entry entry = fBuckets[bucket]; entry != null; entry = entry.next) {
            if (entry.symbol.equals(symbol)) {
                return entry.symbol;
            }
        }
        if (fCount  >= fThreshold) {
            // Rehash the table if the threshold is exceeded
            rehash();
            bucket = hash(symbol) % fTableSize;
        } 
        // create new entry
        Entry entry = new Entry(symbol, fBuckets[bucket]);
        fBuckets[bucket] = entry;
        ++fCount;
        return entry.symbol;
}

Adds the specified symbol to the symbol table and returns a reference to the unique symbol. If the symbol already exists, the previous symbol reference is returned instead, in order guarantee that symbol references remain unique.

 public String addSymbol(char[] buffer,
    int offset,
    int length) 
{
        
        // search for identical symbol
        int bucket = hash(buffer, offset, length) % fTableSize;
        OUTER: for (Entry entry = fBuckets[bucket]; entry != null; entry = entry.next) {
            if (length == entry.characters.length) {
                for (int i = 0; i <  length; i++) {
                    if (buffer[offset + i] != entry.characters[i]) {
                        continue OUTER;
                    }
                }
                return entry.symbol;
            }
        }
        if (fCount  >= fThreshold) {
            // Rehash the table if the threshold is exceeded
            rehash();
            bucket = hash(buffer, offset, length) % fTableSize;
        } 
        // add new entry
        Entry entry = new Entry(buffer, offset, length, fBuckets[bucket]);
        fBuckets[bucket] = entry;
        ++fCount;
        return entry.symbol;
}

Adds the specified symbol to the symbol table and returns a reference to the unique symbol. If the symbol already exists, the previous symbol reference is returned instead, in order guarantee that symbol references remain unique.

 public boolean containsSymbol(String symbol) 
{
        // search for identical symbol
        int bucket = hash(symbol) % fTableSize;
        int length = symbol.length();
        OUTER: for (Entry entry = fBuckets[bucket]; entry != null; entry = entry.next) {
            if (length == entry.characters.length) {
                for (int i = 0; i <  length; i++) {
                    if (symbol.charAt(i) != entry.characters[i]) {
                        continue OUTER;
                    }
                }
                return true;
            }
        }
        return false;
}

Returns true if the symbol table already contains the specified symbol.

 public boolean containsSymbol(char[] buffer,
    int offset,
    int length) 
{
        // search for identical symbol
        int bucket = hash(buffer, offset, length) % fTableSize;
        OUTER: for (Entry entry = fBuckets[bucket]; entry != null; entry = entry.next) {
            if (length == entry.characters.length) {
                for (int i = 0; i <  length; i++) {
                    if (buffer[offset + i] != entry.characters[i]) {
                        continue OUTER;
                    }
                }
                return true;
            }
        }
        return false;
}

Returns true if the symbol table already contains the specified symbol.

 public int hash(String symbol) 
{
        return symbol.hashCode() & 0x7FFFFFF;
}

Returns a hashcode value for the specified symbol. The value returned by this method must be identical to the value returned by the hash(char[],int,int) method when called with the character array that comprises the symbol string.

 public int hash(char[] buffer,
    int offset,
    int length) 
{
        int code = 0;
        for (int i = 0; i <  length; ++i) {
            code = code * 31 + buffer[offset + i];
        }
        return code & 0x7FFFFFF;
}

Returns a hashcode value for the specified symbol information. The value returned by this method must be identical to the value returned by the hash(String) method when called with the string object created from the symbol information.

 protected  void rehash() 
{
        int oldCapacity = fBuckets.length;
        Entry[] oldTable = fBuckets;
        int newCapacity = oldCapacity * 2 + 1;
        Entry[] newTable = new Entry[newCapacity];
        fThreshold = (int)(newCapacity * fLoadFactor);
        fBuckets = newTable;
        fTableSize = fBuckets.length;
        for (int i = oldCapacity ; i--  > 0 ;) {
            for (Entry old = oldTable[i] ; old != null ; ) {
                Entry e = old;
                old = old.next;
                int index = hash(e.characters, 0, e.characters.length) % newCapacity;
                e.next = newTable[index];
                newTable[index] = e;
            }
        }
}

Increases the capacity of and internally reorganizes this SymbolTable, in order to accommodate and access its entries more efficiently. This method is called automatically when the number of keys in the SymbolTable exceeds this hashtable's capacity and load factor.