home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 1999 April / DPPCPRO0499.ISO / April / Notes / 50b2wic.exe / DATA1.CAB / NotesProgramFilesJavaSupport / Notes.jar / Acme / IntHashtable.class (.txt) next >
Encoding:
Java Class File  |  1998-11-16  |  5.0 KB  |  250 lines
  1. package Acme;
  2.  
  3. import java.util.Dictionary;
  4. import java.util.Enumeration;
  5.  
  6. public class IntHashtable extends Dictionary implements Cloneable {
  7.    private IntHashtableEntry[] table;
  8.    private int count;
  9.    private int threshold;
  10.    private float loadFactor;
  11.  
  12.    public IntHashtable(int initialCapacity, float loadFactor) {
  13.       if (initialCapacity > 0 && !((double)loadFactor <= (double)0.0F)) {
  14.          this.loadFactor = loadFactor;
  15.          this.table = new IntHashtableEntry[initialCapacity];
  16.          this.threshold = (int)((float)initialCapacity * loadFactor);
  17.       } else {
  18.          throw new IllegalArgumentException();
  19.       }
  20.    }
  21.  
  22.    public IntHashtable(int initialCapacity) {
  23.       this(initialCapacity, 0.75F);
  24.    }
  25.  
  26.    public IntHashtable() {
  27.       this(101, 0.75F);
  28.    }
  29.  
  30.    public int size() {
  31.       return this.count;
  32.    }
  33.  
  34.    public boolean isEmpty() {
  35.       return this.count == 0;
  36.    }
  37.  
  38.    public synchronized Enumeration keys() {
  39.       return new IntHashtableEnumerator(this.table, true);
  40.    }
  41.  
  42.    public synchronized Enumeration elements() {
  43.       return new IntHashtableEnumerator(this.table, false);
  44.    }
  45.  
  46.    public synchronized boolean contains(Object value) {
  47.       if (value == null) {
  48.          throw new NullPointerException();
  49.       } else {
  50.          IntHashtableEntry[] tab = this.table;
  51.          int i = tab.length;
  52.  
  53.          while(i-- > 0) {
  54.             for(IntHashtableEntry e = tab[i]; e != null; e = e.next) {
  55.                if (e.value.equals(value)) {
  56.                   return true;
  57.                }
  58.             }
  59.          }
  60.  
  61.          return false;
  62.       }
  63.    }
  64.  
  65.    public synchronized boolean containsKey(int key) {
  66.       IntHashtableEntry[] tab = this.table;
  67.       int hash = key;
  68.       int index = (key & Integer.MAX_VALUE) % tab.length;
  69.  
  70.       for(IntHashtableEntry e = tab[index]; e != null; e = e.next) {
  71.          if (e.hash == hash && e.key == key) {
  72.             return true;
  73.          }
  74.       }
  75.  
  76.       return false;
  77.    }
  78.  
  79.    public synchronized Object get(int key) {
  80.       IntHashtableEntry[] tab = this.table;
  81.       int hash = key;
  82.       int index = (key & Integer.MAX_VALUE) % tab.length;
  83.  
  84.       for(IntHashtableEntry e = tab[index]; e != null; e = e.next) {
  85.          if (e.hash == hash && e.key == key) {
  86.             return e.value;
  87.          }
  88.       }
  89.  
  90.       return null;
  91.    }
  92.  
  93.    public Object get(Object okey) {
  94.       if (!(okey instanceof Integer)) {
  95.          throw new InternalError("key is not an Integer");
  96.       } else {
  97.          Integer ikey = (Integer)okey;
  98.          int key = ikey;
  99.          return this.get(key);
  100.       }
  101.    }
  102.  
  103.    protected void rehash() {
  104.       int oldCapacity = this.table.length;
  105.       IntHashtableEntry[] oldTable = this.table;
  106.       int newCapacity = oldCapacity * 2 + 1;
  107.       IntHashtableEntry[] newTable = new IntHashtableEntry[newCapacity];
  108.       this.threshold = (int)((float)newCapacity * this.loadFactor);
  109.       this.table = newTable;
  110.       int i = oldCapacity;
  111.  
  112.       IntHashtableEntry e;
  113.       int index;
  114.       while(i-- > 0) {
  115.          for(IntHashtableEntry old = oldTable[i]; old != null; newTable[index] = e) {
  116.             e = old;
  117.             old = old.next;
  118.             index = (e.hash & Integer.MAX_VALUE) % newCapacity;
  119.             e.next = newTable[index];
  120.          }
  121.       }
  122.  
  123.    }
  124.  
  125.    public synchronized Object put(int key, Object value) {
  126.       if (value == null) {
  127.          throw new NullPointerException();
  128.       } else {
  129.          IntHashtableEntry[] tab = this.table;
  130.          int hash = key;
  131.          int index = (key & Integer.MAX_VALUE) % tab.length;
  132.  
  133.          for(IntHashtableEntry e = tab[index]; e != null; e = e.next) {
  134.             if (e.hash == hash && e.key == key) {
  135.                Object old = e.value;
  136.                e.value = value;
  137.                return old;
  138.             }
  139.          }
  140.  
  141.          if (this.count >= this.threshold) {
  142.             this.rehash();
  143.             return this.put(key, value);
  144.          } else {
  145.             IntHashtableEntry e = new IntHashtableEntry();
  146.             e.hash = hash;
  147.             e.key = key;
  148.             e.value = value;
  149.             e.next = tab[index];
  150.             tab[index] = e;
  151.             ++this.count;
  152.             return null;
  153.          }
  154.       }
  155.    }
  156.  
  157.    public Object put(Object okey, Object value) {
  158.       if (!(okey instanceof Integer)) {
  159.          throw new InternalError("key is not an Integer");
  160.       } else {
  161.          Integer ikey = (Integer)okey;
  162.          int key = ikey;
  163.          return this.put(key, value);
  164.       }
  165.    }
  166.  
  167.    public synchronized Object remove(int key) {
  168.       IntHashtableEntry[] tab = this.table;
  169.       int hash = key;
  170.       int index = (key & Integer.MAX_VALUE) % tab.length;
  171.       IntHashtableEntry e = tab[index];
  172.  
  173.       for(IntHashtableEntry prev = null; e != null; e = e.next) {
  174.          if (e.hash == hash && e.key == key) {
  175.             if (prev != null) {
  176.                prev.next = e.next;
  177.             } else {
  178.                tab[index] = e.next;
  179.             }
  180.  
  181.             --this.count;
  182.             return e.value;
  183.          }
  184.  
  185.          prev = e;
  186.       }
  187.  
  188.       return null;
  189.    }
  190.  
  191.    public Object remove(Object okey) {
  192.       if (!(okey instanceof Integer)) {
  193.          throw new InternalError("key is not an Integer");
  194.       } else {
  195.          Integer ikey = (Integer)okey;
  196.          int key = ikey;
  197.          return this.remove(key);
  198.       }
  199.    }
  200.  
  201.    public synchronized void clear() {
  202.       IntHashtableEntry[] tab = this.table;
  203.       int index = tab.length;
  204.  
  205.       while(true) {
  206.          --index;
  207.          if (index < 0) {
  208.             this.count = 0;
  209.             return;
  210.          }
  211.  
  212.          tab[index] = null;
  213.       }
  214.    }
  215.  
  216.    public synchronized Object clone() {
  217.       try {
  218.          IntHashtable t = (IntHashtable)super.clone();
  219.          t.table = new IntHashtableEntry[this.table.length];
  220.  
  221.          for(int i = this.table.length; i-- > 0; t.table[i] = this.table[i] != null ? (IntHashtableEntry)this.table[i].clone() : null) {
  222.          }
  223.  
  224.          return t;
  225.       } catch (CloneNotSupportedException var3) {
  226.          throw new InternalError();
  227.       }
  228.    }
  229.  
  230.    public synchronized String toString() {
  231.       int max = this.size() - 1;
  232.       StringBuffer buf = new StringBuffer();
  233.       Enumeration k = this.keys();
  234.       Enumeration e = this.elements();
  235.       buf.append("{");
  236.  
  237.       for(int i = 0; i <= max; ++i) {
  238.          String s1 = k.nextElement().toString();
  239.          String s2 = e.nextElement().toString();
  240.          buf.append(s1 + "=" + s2);
  241.          if (i < max) {
  242.             buf.append(", ");
  243.          }
  244.       }
  245.  
  246.       buf.append("}");
  247.       return buf.toString();
  248.    }
  249. }
  250.