inthashtable.java

这个是网络上下载的一个struct框架的程序

// Decompiled by DJ v3.5.5.77 Copyright 2003 Atanas Neshkov  Date: 2003-6-23 11:15:39
// Home Page : http://members.fortunecity.com/neshkov/dj.html  - Check often for new version!
// Decompiler options: packimports(3) 
// Source File Name:   IntHashtable.java

package com.struts2.framework.util;

import java.util.*;

// Referenced classes of package org.fat32.util:
//            IntHashtableEnumerator, IntHashtableEntry

public class IntHashtable extends Dictionary
    implements Map, Cloneable
{

    public int size()
    {
        return count;
    }

    public boolean isEmpty()
    {
        return count == 0;
    }

    public synchronized Enumeration keys()
    {
        return new IntHashtableEnumerator(table, true);
    }

    public synchronized Enumeration elements()
    {
        return new IntHashtableEnumerator(table, false);
    }

    public synchronized boolean contains(Object value)
    {
        if(value == null)
            throw new NullPointerException();
        IntHashtableEntry tab[] = table;
        for(int i = tab.length; i-- > 0;)
        {
            for(IntHashtableEntry e = tab[i]; e != null; e = e.next)
                if(e.value.equals(value))
                    return true;

        }

        return false;
    }

    public synchronized boolean containsKey(int key)
    {
        IntHashtableEntry tab[] = table;
        int hash = key;
        int index = (hash & 0x7fffffff) % tab.length;
        for(IntHashtableEntry e = tab[index]; e != null; e = e.next)
            if(e.hash == hash && e.key == key)
                return true;

        return false;
    }

    public synchronized Object get(int key)
    {
        IntHashtableEntry tab[] = table;
        int hash = key;
        int index = (hash & 0x7fffffff) % tab.length;
        for(IntHashtableEntry e = tab[index]; e != null; e = e.next)
            if(e.hash == hash && e.key == key)
                return e.value;

        return null;
    }

    public Object get(Object okey)
    {
        if(!(okey instanceof Integer))
        {
            throw new InternalError("key is not an Integer");
        } else
        {
            Integer ikey = (Integer)okey;
            int key = ikey.intValue();
            return get(key);
        }
    }

    protected void rehash()
    {
        int oldCapacity = table.length;
        IntHashtableEntry oldTable[] = table;
        int newCapacity = oldCapacity * 2 + 1;
        IntHashtableEntry newTable[] = new IntHashtableEntry[newCapacity];
        threshold = (int)((float)newCapacity * loadFactor);
        table = newTable;
        for(int i = oldCapacity; i-- > 0;)
        {
            for(IntHashtableEntry old = oldTable[i]; old != null;)
            {
                IntHashtableEntry e = old;
                old = old.next;
                int index = (e.hash & 0x7fffffff) % newCapacity;
                e.next = newTable[index];
                newTable[index] = e;
            }

        }

    }

    public synchronized Object put(int key, Object value)
    {
        if(value == null)
            throw new NullPointerException();
        IntHashtableEntry tab[] = table;
        int hash = key;
        int index = (hash & 0x7fffffff) % tab.length;
        for(IntHashtableEntry e = tab[index]; e != null; e = e.next)
            if(e.hash == hash && e.key == key)
            {
                Object old = e.value;
                e.value = value;
                return old;
            }

        if(count >= threshold)
        {
            rehash();
            return put(key, value);
        } else
        {
            IntHashtableEntry e = new IntHashtableEntry();
            e.hash = hash;
            e.key = key;
            e.value = value;
            e.next = tab[index];
            tab[index] = e;
            count++;
            return null;
        }
    }

    public Object put(Object okey, Object value)
    {
        if(!(okey instanceof Integer))
        {
            throw new InternalError("key is not an Integer");
        } else
        {
            Integer ikey = (Integer)okey;
            int key = ikey.intValue();
            return put(key, value);
        }
    }

    public synchronized Object remove(int key)
    {
        IntHashtableEntry tab[] = table;
        int hash = key;
        int index = (hash & 0x7fffffff) % tab.length;
        IntHashtableEntry e = tab[index];
        IntHashtableEntry prev = null;
        for(; e != null; e = e.next)
        {
            if(e.hash == hash && e.key == key)
            {
                if(prev != null)
                    prev.next = e.next;
                else
                    tab[index] = e.next;
                count--;
                return e.value;
            }
            prev = e;
        }

        return null;
    }

    public Object remove(Object okey)
    {
        if(!(okey instanceof Integer))
        {
            throw new InternalError("key is not an Integer");
        } else
        {
            Integer ikey = (Integer)okey;
            int key = ikey.intValue();
            return remove(key);
        }
    }

    public synchronized void clear()
    {
        IntHashtableEntry tab[] = table;
        for(int index = tab.length; --index >= 0;)
            tab[index] = null;

        count = 0;
    }

    public synchronized Object clone()
    {
        try
        {
            IntHashtable t = (IntHashtable)super.clone();
            t.table = new IntHashtableEntry[table.length];
            for(int i = table.length; i-- > 0;)
                t.table[i] = table[i] == null ? null : (IntHashtableEntry)table[i].clone();

            return t;
        }
        catch(CloneNotSupportedException clonenotsupportedexception)
        {
            throw new InternalError();
        }
    }

    public synchronized String toString()
    {
        int max = size() - 1;
        StringBuffer buf = new StringBuffer();
        Enumeration k = keys();
        Enumeration e = elements();
        buf.append("{");
        for(int i = 0; i <= max; i++)
        {
            String s1 = k.nextElement().toString();
            String s2 = e.nextElement().toString();
            buf.append(s1 + "=" + s2);
            if(i < max)
                buf.append(", ");
        }

        buf.append("}");
        return buf.toString();
    }

    public boolean containsKey(Object key)
    {
        throw new UnsupportedOperationException("Method containsKey() not yet implemented.");
    }

    public Set entrySet()
    {
        throw new UnsupportedOperationException("Method entrySet() not yet implemented.");
    }

    public boolean containsValue(Object value)
    {
        throw new UnsupportedOperationException("Method containsValue() not yet implemented.");
    }

    public Set keySet()
    {
        throw new UnsupportedOperationException("Method keySet() not yet implemented.");
    }

    public void putAll(Map map)
    {
    }

    public Collection values()
    {
        throw new UnsupportedOperationException("Method values() not yet implemented.");
    }

    public IntHashtable(int initialCapacity, float loadFactor)
    {
        if(initialCapacity <= 0 || (double)loadFactor <= 0.0D)
        {
            throw new IllegalArgumentException();
        } else
        {
            this.loadFactor = loadFactor;
            table = new IntHashtableEntry[initialCapacity];
            threshold = (int)((float)initialCapacity * loadFactor);
            return;
        }
    }

    public IntHashtable(int initialCapacity)
    {
        this(initialCapacity, 0.75F);
    }

    public IntHashtable()
    {
        this(101, 0.75F);
    }

    private IntHashtableEntry table[];
    private int count;
    private int threshold;
    private float loadFactor;
}