home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &n…he Search for Life DVD 2 / DVD-ROM.iso / install / jre1_3 / lib / rt.jar / java / util / Hashtable.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  6.5 KB  |  398 lines
  1. package java.util;
  2.  
  3. import java.io.IOException;
  4. import java.io.ObjectInputStream;
  5. import java.io.ObjectOutputStream;
  6. import java.io.Serializable;
  7.  
  8. public class Hashtable extends Dictionary implements Map, Cloneable, Serializable {
  9.    private transient Entry[] table;
  10.    private transient int count;
  11.    private int threshold;
  12.    private float loadFactor;
  13.    private transient int modCount;
  14.    private static final long serialVersionUID = 1421746759512286392L;
  15.    private transient Set keySet;
  16.    private transient Set entrySet;
  17.    private transient Collection values;
  18.    private static final int KEYS = 0;
  19.    private static final int VALUES = 1;
  20.    private static final int ENTRIES = 2;
  21.    private static EmptyEnumerator emptyEnumerator = new EmptyEnumerator();
  22.    private static EmptyIterator emptyIterator = new EmptyIterator();
  23.  
  24.    public Hashtable(int var1, float var2) {
  25.       this.modCount = 0;
  26.       this.keySet = null;
  27.       this.entrySet = null;
  28.       this.values = null;
  29.       if (var1 < 0) {
  30.          throw new IllegalArgumentException("Illegal Capacity: " + var1);
  31.       } else if (!(var2 <= 0.0F) && !Float.isNaN(var2)) {
  32.          if (var1 == 0) {
  33.             var1 = 1;
  34.          }
  35.  
  36.          this.loadFactor = var2;
  37.          this.table = new Entry[var1];
  38.          this.threshold = (int)((float)var1 * var2);
  39.       } else {
  40.          throw new IllegalArgumentException("Illegal Load: " + var2);
  41.       }
  42.    }
  43.  
  44.    public Hashtable(int var1) {
  45.       this(var1, 0.75F);
  46.    }
  47.  
  48.    public Hashtable() {
  49.       this(11, 0.75F);
  50.    }
  51.  
  52.    public Hashtable(Map var1) {
  53.       this(Math.max(2 * var1.size(), 11), 0.75F);
  54.       this.putAll(var1);
  55.    }
  56.  
  57.    public int size() {
  58.       return this.count;
  59.    }
  60.  
  61.    public boolean isEmpty() {
  62.       return this.count == 0;
  63.    }
  64.  
  65.    public synchronized Enumeration keys() {
  66.       return this.getEnumeration(0);
  67.    }
  68.  
  69.    public synchronized Enumeration elements() {
  70.       return this.getEnumeration(1);
  71.    }
  72.  
  73.    public synchronized boolean contains(Object var1) {
  74.       if (var1 == null) {
  75.          throw new NullPointerException();
  76.       } else {
  77.          Entry[] var2 = this.table;
  78.          int var3 = var2.length;
  79.  
  80.          while(var3-- > 0) {
  81.             for(Entry var4 = var2[var3]; var4 != null; var4 = var4.next) {
  82.                if (var4.value.equals(var1)) {
  83.                   return true;
  84.                }
  85.             }
  86.          }
  87.  
  88.          return false;
  89.       }
  90.    }
  91.  
  92.    public boolean containsValue(Object var1) {
  93.       return this.contains(var1);
  94.    }
  95.  
  96.    public synchronized boolean containsKey(Object var1) {
  97.       Entry[] var2 = this.table;
  98.       int var3 = var1.hashCode();
  99.       int var4 = (var3 & Integer.MAX_VALUE) % var2.length;
  100.  
  101.       for(Entry var5 = var2[var4]; var5 != null; var5 = var5.next) {
  102.          if (var5.hash == var3 && var5.key.equals(var1)) {
  103.             return true;
  104.          }
  105.       }
  106.  
  107.       return false;
  108.    }
  109.  
  110.    public synchronized Object get(Object var1) {
  111.       Entry[] var2 = this.table;
  112.       int var3 = var1.hashCode();
  113.       int var4 = (var3 & Integer.MAX_VALUE) % var2.length;
  114.  
  115.       for(Entry var5 = var2[var4]; var5 != null; var5 = var5.next) {
  116.          if (var5.hash == var3 && var5.key.equals(var1)) {
  117.             return var5.value;
  118.          }
  119.       }
  120.  
  121.       return null;
  122.    }
  123.  
  124.    protected void rehash() {
  125.       int var1 = this.table.length;
  126.       Entry[] var2 = this.table;
  127.       int var3 = var1 * 2 + 1;
  128.       Entry[] var4 = new Entry[var3];
  129.       ++this.modCount;
  130.       this.threshold = (int)((float)var3 * this.loadFactor);
  131.       this.table = var4;
  132.       int var5 = var1;
  133.  
  134.       Entry var7;
  135.       int var8;
  136.       while(var5-- > 0) {
  137.          for(Entry var6 = var2[var5]; var6 != null; var4[var8] = var7) {
  138.             var7 = var6;
  139.             var6 = var6.next;
  140.             var8 = (var7.hash & Integer.MAX_VALUE) % var3;
  141.             var7.next = var4[var8];
  142.          }
  143.       }
  144.  
  145.    }
  146.  
  147.    public synchronized Object put(Object var1, Object var2) {
  148.       if (var2 == null) {
  149.          throw new NullPointerException();
  150.       } else {
  151.          Entry[] var3 = this.table;
  152.          int var4 = var1.hashCode();
  153.          int var5 = (var4 & Integer.MAX_VALUE) % var3.length;
  154.  
  155.          for(Entry var6 = var3[var5]; var6 != null; var6 = var6.next) {
  156.             if (var6.hash == var4 && var6.key.equals(var1)) {
  157.                Object var7 = var6.value;
  158.                var6.value = var2;
  159.                return var7;
  160.             }
  161.          }
  162.  
  163.          ++this.modCount;
  164.          if (this.count >= this.threshold) {
  165.             this.rehash();
  166.             var3 = this.table;
  167.             var5 = (var4 & Integer.MAX_VALUE) % var3.length;
  168.          }
  169.  
  170.          Entry var8 = new Entry(var4, var1, var2, var3[var5]);
  171.          var3[var5] = var8;
  172.          ++this.count;
  173.          return null;
  174.       }
  175.    }
  176.  
  177.    public synchronized Object remove(Object var1) {
  178.       Entry[] var2 = this.table;
  179.       int var3 = var1.hashCode();
  180.       int var4 = (var3 & Integer.MAX_VALUE) % var2.length;
  181.       Entry var5 = var2[var4];
  182.  
  183.       for(Entry var6 = null; var5 != null; var5 = var5.next) {
  184.          if (var5.hash == var3 && var5.key.equals(var1)) {
  185.             ++this.modCount;
  186.             if (var6 != null) {
  187.                var6.next = var5.next;
  188.             } else {
  189.                var2[var4] = var5.next;
  190.             }
  191.  
  192.             --this.count;
  193.             Object var7 = var5.value;
  194.             var5.value = null;
  195.             return var7;
  196.          }
  197.  
  198.          var6 = var5;
  199.       }
  200.  
  201.       return null;
  202.    }
  203.  
  204.    public synchronized void putAll(Map var1) {
  205.       for(Map.Entry var3 : var1.entrySet()) {
  206.          this.put(var3.getKey(), var3.getValue());
  207.       }
  208.  
  209.    }
  210.  
  211.    public synchronized void clear() {
  212.       Entry[] var1 = this.table;
  213.       ++this.modCount;
  214.       int var2 = var1.length;
  215.  
  216.       while(true) {
  217.          --var2;
  218.          if (var2 < 0) {
  219.             this.count = 0;
  220.             return;
  221.          }
  222.  
  223.          var1[var2] = null;
  224.       }
  225.    }
  226.  
  227.    public synchronized Object clone() {
  228.       try {
  229.          Hashtable var1 = (Hashtable)super.clone();
  230.          var1.table = new Entry[this.table.length];
  231.  
  232.          for(int var2 = this.table.length; var2-- > 0; var1.table[var2] = this.table[var2] != null ? (Entry)this.table[var2].clone() : null) {
  233.          }
  234.  
  235.          var1.keySet = null;
  236.          var1.entrySet = null;
  237.          var1.values = null;
  238.          var1.modCount = 0;
  239.          return var1;
  240.       } catch (CloneNotSupportedException var3) {
  241.          throw new InternalError();
  242.       }
  243.    }
  244.  
  245.    public synchronized String toString() {
  246.       int var1 = this.size() - 1;
  247.       StringBuffer var2 = new StringBuffer();
  248.       Iterator var3 = this.entrySet().iterator();
  249.       var2.append("{");
  250.  
  251.       for(int var4 = 0; var4 <= var1; ++var4) {
  252.          Map.Entry var5 = (Map.Entry)var3.next();
  253.          var2.append(var5.getKey() + "=" + var5.getValue());
  254.          if (var4 < var1) {
  255.             var2.append(", ");
  256.          }
  257.       }
  258.  
  259.       var2.append("}");
  260.       return var2.toString();
  261.    }
  262.  
  263.    private Enumeration getEnumeration(int var1) {
  264.       return (Enumeration)(this.count == 0 ? emptyEnumerator : new Enumerator(this, var1, false));
  265.    }
  266.  
  267.    private Iterator getIterator(int var1) {
  268.       return (Iterator)(this.count == 0 ? emptyIterator : new Enumerator(this, var1, true));
  269.    }
  270.  
  271.    public Set keySet() {
  272.       if (this.keySet == null) {
  273.          this.keySet = Collections.synchronizedSet(new KeySet(this, (1)null), this);
  274.       }
  275.  
  276.       return this.keySet;
  277.    }
  278.  
  279.    public Set entrySet() {
  280.       if (this.entrySet == null) {
  281.          this.entrySet = Collections.synchronizedSet(new EntrySet(this, (1)null), this);
  282.       }
  283.  
  284.       return this.entrySet;
  285.    }
  286.  
  287.    public Collection values() {
  288.       if (this.values == null) {
  289.          this.values = Collections.synchronizedCollection(new ValueCollection(this, (1)null), this);
  290.       }
  291.  
  292.       return this.values;
  293.    }
  294.  
  295.    public synchronized boolean equals(Object var1) {
  296.       if (var1 == this) {
  297.          return true;
  298.       } else if (!(var1 instanceof Map)) {
  299.          return false;
  300.       } else {
  301.          Map var2 = (Map)var1;
  302.          if (var2.size() != this.size()) {
  303.             return false;
  304.          } else {
  305.             for(Map.Entry var4 : this.entrySet()) {
  306.                Object var5 = var4.getKey();
  307.                Object var6 = var4.getValue();
  308.                if (var6 == null) {
  309.                   if (var2.get(var5) != null || !var2.containsKey(var5)) {
  310.                      return false;
  311.                   }
  312.                } else if (!var6.equals(var2.get(var5))) {
  313.                   return false;
  314.                }
  315.             }
  316.  
  317.             return true;
  318.          }
  319.       }
  320.    }
  321.  
  322.    public synchronized int hashCode() {
  323.       int var1 = 0;
  324.  
  325.       for(Iterator var2 = this.entrySet().iterator(); var2.hasNext(); var1 += var2.next().hashCode()) {
  326.       }
  327.  
  328.       return var1;
  329.    }
  330.  
  331.    private synchronized void writeObject(ObjectOutputStream var1) throws IOException {
  332.       var1.defaultWriteObject();
  333.       var1.writeInt(this.table.length);
  334.       var1.writeInt(this.count);
  335.  
  336.       for(int var2 = this.table.length - 1; var2 >= 0; --var2) {
  337.          for(Entry var3 = this.table[var2]; var3 != null; var3 = var3.next) {
  338.             var1.writeObject(var3.key);
  339.             var1.writeObject(var3.value);
  340.          }
  341.       }
  342.  
  343.    }
  344.  
  345.    private synchronized void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
  346.       var1.defaultReadObject();
  347.       int var2 = var1.readInt();
  348.       int var3 = var1.readInt();
  349.       int var4 = (int)((float)var3 * this.loadFactor) + var3 / 20 + 3;
  350.       if (var4 > var3 && (var4 & 1) == 0) {
  351.          --var4;
  352.       }
  353.  
  354.       if (var2 > 0 && var4 > var2) {
  355.          var4 = var2;
  356.       }
  357.  
  358.       this.table = new Entry[var4];
  359.  
  360.       for(this.count = 0; var3 > 0; --var3) {
  361.          Object var5 = var1.readObject();
  362.          Object var6 = var1.readObject();
  363.          this.put(var5, var6);
  364.       }
  365.  
  366.    }
  367.  
  368.    // $FF: synthetic method
  369.    static Iterator access$100(Hashtable var0, int var1) {
  370.       return var0.getIterator(var1);
  371.    }
  372.  
  373.    // $FF: synthetic method
  374.    static int access$200(Hashtable var0) {
  375.       return var0.count;
  376.    }
  377.  
  378.    // $FF: synthetic method
  379.    static Entry[] access$400(Hashtable var0) {
  380.       return var0.table;
  381.    }
  382.  
  383.    // $FF: synthetic method
  384.    static int access$508(Hashtable var0) {
  385.       return var0.modCount++;
  386.    }
  387.  
  388.    // $FF: synthetic method
  389.    static int access$210(Hashtable var0) {
  390.       return var0.count--;
  391.    }
  392.  
  393.    // $FF: synthetic method
  394.    static int access$500(Hashtable var0) {
  395.       return var0.modCount;
  396.    }
  397. }
  398.