Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.util.collections;
  
  import java.util.Iterator;
  import java.util.Set;
  
 public class IntHashMap<V> {
     
     private transient Entry<V>[] table;
     
     private transient int count;
     
     transient volatile Set<IntegerkeySet = null;
 	transient volatile Collection<V> values = null;
 
     private int threshold;
  
     private final float loadFactor;
  
     public static class Entry<V> {
         final int hash;
         final int key;
         V value;
         Entry<V> next;
  
         protected Entry(int hashint key, V valueEntry<V> next) {
             this. = hash;
             this. = key;
             this. = value;
             this. = next;
         }
 
         public int getKey() {
             return ;
         }
 
         public V getValue() {
             return ;
         }
     }
  
     public IntHashMap() {
         this(20, 0.75f);
     }
  
     public IntHashMap(int initialCapacity) {
         this(initialCapacity, 0.75f);
     }
  
     public IntHashMap(int initialCapacityfloat loadFactor) {
         super();
         if (initialCapacity < 0) {
             throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
         }
         if (loadFactor <= 0) {
             throw new IllegalArgumentException("Illegal Load: " + loadFactor);
         }
         if (initialCapacity == 0) {
             initialCapacity = 1;
         }
  
         this. = loadFactor;
         this. = (int) (initialCapacity * loadFactor);
         @SuppressWarnings("unchecked")
         Entry<V>[] table = new Entry[initialCapacity];
         this. = table;
     }
 
     public int size() {
         return ;
     }
 
     public boolean isEmpty() {
         return  == 0;
     }
  
     public boolean contains(Object value) {
         if (value == null) {
             throw new NullPointerException();
         }
  
         Entry<V> tab[] = ;
         for (int i = tab.lengthi-- > 0;) {
             for (Entry<V> e = tab[i]; e != nulle = e.next) {
                 if (e.value.equals(value)) {
                     return true;
                 }
             }
         }
         return false;
     }
  
     public boolean containsValue(Object value) {
         return contains(value);
     }
  
    public boolean containsKey(int key) {
        Entry<V>[] tab = ;
        int hash = key;
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<V> e = tab[index]; e != nulle = e.next) {
            if (e.hash == hash) {
                return true;
            }
        }
        return false;
    }
 
    public V get(int key) {
        Entry<V>[] tab = ;
        int hash = key;
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<V> e = tab[index]; e != nulle = e.next) {
            if (e.hash == hash) {
                return e.value;
            }
        }
        return null;
    }
 
    protected void rehash() {
        int oldCapacity = .;
        Entry<V>[] oldMap = ;
 
        int newCapacity = oldCapacity * 2 + 1;
        @SuppressWarnings("unchecked")
        Entry<V>[] newMap = new Entry[newCapacity];
 
         = (int) (newCapacity * );
         = newMap;
 
        for (int i = oldCapacityi-- > 0;) {
            for (Entry<V> old = oldMap[i]; old != null;) {
                Entry<V> e = old;
                old = old.next;
 
                int index = (e.hash & 0x7FFFFFFF) % newCapacity;
                e.next = newMap[index];
                newMap[index] = e;
            }
        }
    }
	Entry<V> getEntry(int key)	{
        Entry<V>[] tab = ;
        int hash = key;
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for(Entry<V> e = tab[index]; e != nulle = e.next) {
            if (e.hash == hash) {
                return e;
            }
        }
        return null;
    public V put(int key, V value) {
        // Makes sure the key is not already in the hashtable.
        Entry<V>[] tab = ;
        int hash = key;
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<V> e = tab[index]; e != nulle = e.next) {
            if (e.hash == hash) {
                V old = e.value;
                e.value = value;
                return old;
            }
        }
 
        if ( >= ) {
            // Rehash the table if the threshold is exceeded
            rehash();
 
            tab = ;
            index = (hash & 0x7FFFFFFF) % tab.length;
        }
 
        // Creates the new entry.
        Entry<V> e = new Entry<V>(hashkeyvaluetab[index]);
        tab[index] = e;
        ++;
        return null;
    }
 
    public V remove(int key) {
        Entry<V>[] tab = ;
        int hash = key;
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<V> e = tab[index], prev = nulle != nullprev = ee = e.next) {
            if (e.hash == hash) {
                if (prev != null) {
                    prev.next = e.next;
                } else {
                    tab[index] = e.next;
                }
                --;
                V oldValue = e.value;
                e.value = null;
                return oldValue;
            }
        }
        return null;
    }
 
    public synchronized void clear() {
        Entry<V>[] tab = ;
        for (int index = tab.length; --index >= 0;) {
            tab[index] = null;
        }
         = 0;
    }
    
    private abstract class HashIterator<T> implements Iterator<T> {
		Entry<V> next// next entry to return
		int index// current slot
			Entry<V>[] t = ;
			int i = t.length;
			Entry<V> n = null;
			if( != 0) { // advance to first entry
				while (i > 0 && (n = t[--i]) == null) {
				}
			}
			 = n;
			 = i;
		}
		public boolean hasNext() {
			return  != null;
		}
			Entry<V> e = ;
			if(e == null) {
			}
			Entry<V> n = e.next;
			Entry<V>[] t = ;
			int i = ;
			while(n == null && i > 0) {
				n = t[--i];
			}
			 = i;
			 = n;
			return e;
		}
		public void remove() {
            throw new UnsupportedOperationException();
		}
	}
	private class ValueIterator extends HashIterator<V> {
		public V next() {
			return nextEntry().;
		}
	}
	private class KeyIterator extends HashIterator<Integer> {
		public Integer next() {
			return Integer.valueOf(nextEntry().);
		}
	}
	private class EntryIterator extends HashIterator<Entry<V>> {
		public Entry<V> next() {
			return nextEntry();
		}
	}
		return new KeyIterator();
	}
		return new ValueIterator();
	}
		return new EntryIterator();
	}
	private transient Set<Entry<V>> entrySet = null;
	public Set<IntegerkeySet() {
		Set<Integerks = ;
		return (ks != null ? ks : ( = new KeySet()));
	}
	private class KeySet extends AbstractSet<Integer> {
	    
		public Iterator<Integeriterator() {
			return newKeyIterator();
		}
		public int size() {
			return IntHashMap.this.;
		}
        @Override
		public boolean contains(Object o) {
			if(o instanceof Number) {
				return containsKey(((Number)o).intValue());
			}
			return false;
		}
        @Override
		public boolean remove(Object o) {
            throw new UnsupportedOperationException();
		}
        @Override
		public void clear() {
		}
	}
	public Collection<V> values() {
		Collection<V> vs = ;
		return (vs != null ? vs : ( = new Values()));
	}
	private class Values extends AbstractCollection<V> {
	    
		public Iterator<V> iterator() {
		}
		public int size() {
			return IntHashMap.this.;
		}
        @Override
		public boolean contains(Object o) {
			return containsValue(o);
		}
        @Override
		public void clear()	{
		}
	}
	public Set<Entry<V>> entrySet() {
		Set<Entry<V>> es = ;
		return (es != null ? es : ( = new EntrySet()));
	}
	private class EntrySet extends AbstractSet<Entry<V>> {
	    
		public Iterator<Entry<V>> iterator() {
		}
        @Override
		public boolean contains(Object o) {
			if (!(o instanceof Entry)) {
				return false;
			}
			@SuppressWarnings("unchecked")
            Entry<V> e = (Entry<V>) o;
			Entry<V> candidate = getEntry(e.key);
			return candidate != null && candidate.equals(e);
		}
        @Override
		public boolean remove(Object o)	{
            throw new UnsupportedOperationException();
		}
		public int size() {
			return IntHashMap.this.;
		}
        @Override
		public void clear() {
		}
	}
    public String toString() {
	    Iterator<Entry<V>> i = entrySet().iterator();
	    if (! i.hasNext()) return "{}";
	    StringBuilder sb = new StringBuilder();
	    sb.append('{');
	    for (;;) {
	        Entry<V> e = i.next();
	        V value = e.getValue();
	        sb.append(e.getKey());
	        sb.append('=');
	        sb.append(value == this ? "(this IntHashMap)" : value);
	        if (! i.hasNext()) return sb.append('}').toString();
	        sb.append(", ");
	    }   
    }
New to GrepCode? Check out our FAQ X