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