Int HashMap from jodd.org : Customized Map « Collections Data Structure « Java






Int HashMap from jodd.org

    

// Copyright (c) 2003-2009, Jodd Team (jodd.org). All Rights Reserved.


import java.io.IOException;
import java.io.Serializable;
import java.util.AbstractCollection;
import java.util.AbstractMap;
import java.util.AbstractSet;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;

/**
 * A Map that accepts int or Integer keys only. The implementation is based on
 * <code>java.util.HashMap</code>. IntHashMap is about 25% faster.
 *
 * @see java.util.HashMap
 */

public class IntHashMap extends AbstractMap implements Cloneable, Serializable {

  /**
   * The hash table data.
   */
  private transient Entry table[];

  /**
   * The total number of mappings in the hash table.
   */
  private transient int count;

  /**
   * The table is rehashed when its size exceeds this threshold. (The value of
   * this field is (int)(capacity * loadFactor).)
   */
  private int threshold;

  /**
   * The load factor for the hashtable.
   */
  private float loadFactor;

  /**
   * The number of times this IntHashMap has been structurally modified
   * Structural modifications are those that change the number of mappings in
   * the IntHashMap or otherwise modify its internal structure (e.g., rehash).
   * This field is used to make iterators on Collection-views of the IntHashMap
   * fail-fast.
   */
  private transient int modCount;

  /**
   * Constructs a new, empty map with the specified initial
   * capacity and the specified load factor.
   *
   * @param initialCapacity
   *                   the initial capacity of the IntHashMap.
   * @param loadFactor the load factor of the IntHashMap
   *
   * @throws IllegalArgumentException
   *                if the initial capacity is less
   *                than zero, or if the load factor is non-positive.
   */
  public IntHashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0) {
      throw new IllegalArgumentException("Illegal Initial Capacity: "+ initialCapacity);
    }
    if (loadFactor <= 0) {
      throw new IllegalArgumentException("Illegal Load factor: "+ loadFactor);
    }
    if (initialCapacity == 0) {
      initialCapacity = 1;
    }
    this.loadFactor = loadFactor;
    table = new Entry[initialCapacity];
    threshold = (int)(initialCapacity * loadFactor);
  }

  /**
   * Constructs a new, empty map with the specified initial capacity
   * and default load factor, which is 0.75.
   *
   * @param initialCapacity
   *               the initial capacity of the IntHashMap.
   *
   * @throws IllegalArgumentException
   *                if the initial capacity is less
   *                than zero.
   */
  public IntHashMap(int initialCapacity) {
    this(initialCapacity, 0.75f);
  }

  /**
   * Constructs a new, empty map with a default capacity and load
   * factor, which is 0.75.
   */
  public IntHashMap() {
    this(101, 0.75f);
  }

  /**
   * Constructs a new map with the same mappings as the given map.  The
   * map is created with a capacity of twice the number of mappings in
   * the given map or 11 (whichever is greater), and a default load factor,
   * which is 0.75.
   */
  public IntHashMap(Map t) {
    this(Math.max(2 * t.size(), 11), 0.75f);
    putAll(t);
  }

  /**
   * Returns the number of key-value mappings in this map.
   *
   * @return the number of key-value mappings in this map.
   */
  @Override
  public int size() {
    return count;
  }

  /**
   * Returns <code>true</code> if this map contains no key-value mappings.
   *
   * @return <code>true</code> if this map contains no key-value mappings.
   */
  @Override
  public boolean isEmpty() {
    return count == 0;
  }

  /**
   * Returns <code>true</code> if this map maps one or more keys to the
   * specified value.
   *
   * @param value  value whose presence in this map is to be tested.
   *
   * @return <code>true</code> if this map maps one or more keys to the
   *         specified value.
   */
  @Override
  public boolean containsValue(Object value) {
    Entry tab[] = table;
    if (value == null) {
      for (int i = tab.length; i-- > 0 ;) {
        for (Entry e = tab[i] ; e != null ; e = e.next) {
          if (e.value == null) {
            return true;
          }
        }
      }
    } else {
      for (int i = tab.length; i-- > 0 ;) {
        for (Entry e = tab[i]; e != null; e = e.next) {
          if (value.equals(e.value)) {
            return true;
          }
        }
      }
    }
    return false;
  }

  /**
   * Returns <code>true</code> if this map contains a mapping for the specified
   * key.
   *
   * @param key    key whose presence in this Map is to be tested.
   *
   * @return <code>true</code> if this map contains a mapping for the specified
   *         key.
   */
  @Override
  public boolean containsKey(Object key) {
    if (key instanceof Number) {
      return containsKey( ((Number)key).intValue() );
    } else {
      return false;
    }
  }

  /**
   * Returns <code>true</code> if this map contains a mapping for the specified
   * key.
   *
   * @param key    key whose presence in this Map is to be tested.
   *
   * @return <code>true</code> if this map contains a mapping for the specified
   *         key.
   */
  public boolean containsKey(int key) {
    Entry tab[] = table;

    int index = (key & 0x7FFFFFFF) % tab.length;
    for (Entry e = tab[index]; e != null; e = e.next) {
      if (e.key == key) {
        return true;
      }
    }

    return false;
  }

  /**
   * Returns the value to which this map maps the specified key. Returns
   * <code>null</code> if the map contains no mapping for this key. A return
   * value of <code>null</code> does not <i>necessarily</i> indicate that the
   * map contains no mapping for the key; it's also possible that the map
   * explicitly maps the key to <code>null</code>. The <code>containsKey</code>
   * operation may be used to distinguish these two cases.
   *
   * @param key    key whose associated value is to be returned.
   *
   * @return the value to which this map maps the specified key.
   */
  @Override
  public Object get(Object key) {
    if (key instanceof Number) {
      return get( ((Number)key).intValue() );
    } else {
      return null;
    }
  }

  /**
   * Returns the value to which this map maps the specified key. Returns
   * <code>null</code> if the map contains no mapping for this key. A return
   * value of <code>null</code> does not <i>necessarily</i> indicate that the
   * map contains no mapping for the key; it's also possible that the map
   * explicitly maps the key to <code>null</code>. The <code>containsKey</code>
   * operation may be used to distinguish these two cases.
   *
   * @param key    key whose associated value is to be returned.
   *
   * @return the value to which this map maps the specified key.
   */
  public Object get(int key) {
    Entry tab[] = table;

    int index = (key & 0x7FFFFFFF) % tab.length;
    for (Entry e = tab[index]; e != null; e = e.next) {
      if (e.key == key) {
        return e.value;
      }
    }

    return null;
  }

  /**
   * Rehashes the contents of this map into a new <code>IntHashMap</code>
   * instance with a larger capacity. This method is called automatically when
   * the number of keys in this map exceeds its capacity and load factor.
   */
  private void rehash() {
    int oldCapacity = table.length;
    Entry oldMap[] = table;

    int newCapacity = (oldCapacity << 1) + 1;
    Entry newMap[] = new Entry[newCapacity];

    modCount++;
    threshold = (int)(newCapacity * loadFactor);
    table = newMap;

    for (int i = oldCapacity ; i-- > 0 ;) {
      for (Entry old = oldMap[i] ; old != null ; ) {
        Entry e = old;
        old = old.next;

        int index = (e.key & 0x7FFFFFFF) % newCapacity;
        e.next = newMap[index];
        newMap[index] = e;
      }
    }
  }

  /**
   * Associates the specified value with the specified key in this map. If the
   * map previously contained a mapping for this key, the old value is
   * replaced.
   *
   * @param key    key with which the specified value is to be associated.
   * @param value  value to be associated with the specified key.
   *
   * @return previous value associated with specified key, or <code>null</code> if
   *         there was no mapping for key. A <code>null</code> return can also indicate
   *         that the IntHashMap previously associated <code>null</code> with the
   *         specified key.
   */
  @Override
  public Object put(Object key, Object value) {
    if (key instanceof Number) {
      return put( ((Number)key).intValue(), value );
    } else {
      throw new UnsupportedOperationException
      ("IntHashMap key must be a number");
    }
  }

  /**
   * Associates the specified value with the specified key in this map. If the
   * map previously contained a mapping for this key, the old value is
   * replaced.
   *
   * @param key    key with which the specified value is to be associated.
   * @param value  value to be associated with the specified key.
   *
   * @return previous value associated with specified key, or <code>null</code> if
   *         there was no mapping for key. A <code>null</code> return can also indicate
   *         that the IntHashMap previously associated <code>null</code> with the
   *         specified key.
   */
  public Object put(int key, Object value) {
    // makes sure the key is not already in the IntHashMap.
    Entry tab[] = table;

    int index = (key & 0x7FFFFFFF) % tab.length;
    for (Entry e = tab[index] ; e != null ; e = e.next) {
      if (e.key == key) {
        Object old = e.value;
        e.value = value;
        return old;
      }
    }

    modCount++;
    if (count >= threshold) {
      // rehash the table if the threshold is exceeded
      rehash();

      tab = table;
      index = (key & 0x7FFFFFFF) % tab.length;
    }

    // creates the new entry.
    tab[index] = new Entry(key, value, tab[index]);
    count++;
    return null;
  }

  /**
   * Removes the mapping for this key from this map if present.
   *
   * @param key    key whose mapping is to be removed from the map.
   *
   * @return previous value associated with specified key, or <code>null</code> if
   *         there was no mapping for key. A <code>null</code> return can also indicate
   *         that the map previously associated <code>null</code> with the specified
   *         key.
   */
  @Override
  public Object remove(Object key) {
    if (key instanceof Number) {
      return remove( ((Number)key).intValue() );
    } else {
      return null;
    }
  }

  /**
   * Removes the mapping for this key from this map if present.
   *
   * @param key    key whose mapping is to be removed from the map.
   *
   * @return previous value associated with specified key, or <code>null</code> if
   *         there was no mapping for key. A <code>null</code> return can also indicate
   *         that the map previously associated <code>null</code> with the specified
   *         key.
   */
  public Object remove(int key) {
    Entry tab[] = table;

    int index = (key & 0x7FFFFFFF) % tab.length;

    for (Entry e = tab[index], prev = null; e != null;
      prev = e, e = e.next) {

      if (e.key == key) {
        modCount++;
        if (prev != null) {
          prev.next = e.next;
        } else {
          tab[index] = e.next;
        }

        count--;
        Object oldValue = e.value;
        e.value = null;
        return oldValue;
      }
    }

    return null;
  }

  /**
   * Copies all of the mappings from the specified map to this one.
   * These mappings replace any mappings that this map had for any of the
   * keys currently in the specified Map.
   *
   * @param t      Mappings to be stored in this map.
   */
  @Override
  public void putAll(Map t) {
    for (Object o : t.entrySet()) {
      Map.Entry e = (Map.Entry) o;
      put(e.getKey(), e.getValue());
    }
  }

  /**
   * Removes all mappings from this map.
   */
  @Override
  public void clear() {
    Entry tab[] = table;
    modCount++;
    for (int index = tab.length; --index >= 0; ) {
      tab[index] = null;
    }
    count = 0;
  }

  /**
   * Returns a shallow copy of this <code>IntHashMap</code> instance: the keys and
   * values themselves are not cloned.
   *
   * @return a shallow copy of this map.
   */
  @Override
  public Object clone() {
    try {
      IntHashMap t = (IntHashMap)super.clone();
      t.table = new Entry[table.length];
      for (int i = table.length ; i-- > 0 ; ) {
        t.table[i] = (table[i] != null)
               ? (Entry)table[i].clone() : null;
      }
      t.keySet = null;
      t.entrySet = null;
      t.values = null;
      t.modCount = 0;
      return t;
    } catch (CloneNotSupportedException e) {
      // this shouldn't happen, since we are Cloneable
      throw new InternalError();
    }
  }

  // views
  private transient Set keySet;
  private transient Set entrySet;
  private transient Collection values;

  /**
   * Returns a set view of the keys contained in this map. The set is backed by
   * the map, so changes to the map are reflected in the set, and vice-versa.
   * The set supports element removal, which removes the corresponding mapping
   * from this map, via the <code>Iterator.remove</code>,
   * <code>Set.remove</code>, <code>removeAll</code>, <code>retainAll</code>,
   * and <code>clear</code> operations. It does not support the
   * <code>add</code> or <code>addAll</code> operations.
   *
   * @return a set view of the keys contained in this map.
   */
  @Override
  public Set keySet() {
    if (keySet == null) {
      keySet = new AbstractSet() {
        @Override
        public Iterator iterator() {
          return new IntHashIterator(KEYS);
        }
        @Override
        public int size() {
          return count;
        }
        @Override
        public boolean contains(Object o) {
          return containsKey(o);
        }
        @Override
        public boolean remove(Object o) {
          return IntHashMap.this.remove(o) != null;
        }
        @Override
        public void clear() {
          IntHashMap.this.clear();
        }
      };
    }
    return keySet;
  }

  /**
   * Returns a collection view of the values contained in this map. The
   * collection is backed by the map, so changes to the map are reflected in
   * the collection, and vice-versa. The collection supports element removal,
   * which removes the corresponding mapping from this map, via the
   * <code>Iterator.remove</code>, <code>Collection.remove</code>,
   * <code>removeAll</code>, <code>retainAll</code>, and <code>clear</code>
   * operations. It does not support the <code>add</code> or
   * <code>addAll</code> operations.
   *
   * @return a collection view of the values contained in this map.
   */
  @Override
  public Collection values() {
    if (values==null) {
      values = new AbstractCollection() {
        @Override
        public Iterator iterator() {
          return new IntHashIterator(VALUES);
        }
        @Override
        public int size() {
          return count;
        }
        @Override
        public boolean contains(Object o) {
          return containsValue(o);
        }
        @Override
        public void clear() {
          IntHashMap.this.clear();
        }
      };
    }
    return values;
  }

  /**
   * Returns a collection view of the mappings contained in this map. Each
   * element in the returned collection is a <code>Map.Entry</code>. The
   * collection is backed by the map, so changes to the map are reflected in
   * the collection, and vice-versa. The collection supports element removal,
   * which removes the corresponding mapping from the map, via the
   * <code>Iterator.remove</code>, <code>Collection.remove</code>,
   * <code>removeAll</code>, <code>retainAll</code>, and <code>clear</code>
   * operations. It does not support the <code>add</code> or
   * <code>addAll</code> operations.
   *
   * @return a collection view of the mappings contained in this map.
   * @see java.util.Map.Entry
   */
  @Override
  public Set entrySet() {
    if (entrySet==null) {
      entrySet = new AbstractSet() {
        @Override
        public Iterator iterator() {
          return new IntHashIterator(ENTRIES);
        }

        @Override
        public boolean contains(Object o) {
          if (!(o instanceof Map.Entry)) {
            return false;
          }
          Map.Entry entry = (Map.Entry)o;
          Object key = entry.getKey();
          Entry tab[] = table;
          int hash = (key==null ? 0 : key.hashCode());
          int index = (hash & 0x7FFFFFFF) % tab.length;

          for (Entry e = tab[index]; e != null; e = e.next) {
            if (e.key == hash && e.equals(entry)) {
              return true;
            }
          }
          return false;
        }

        @Override
        public boolean remove(Object o) {
          if (!(o instanceof Map.Entry)) {
            return false;
          }
          Map.Entry entry = (Map.Entry)o;
          Object key = entry.getKey();
          Entry tab[] = table;
          int hash = (key==null ? 0 : key.hashCode());
          int index = (hash & 0x7FFFFFFF) % tab.length;

          for (Entry e = tab[index], prev = null; e != null;
            prev = e, e = e.next) {
            if (e.key == hash && e.equals(entry)) {
              modCount++;
              if (prev != null) {
                prev.next = e.next;
              } else {
                tab[index] = e.next;
              }

              count--;
              e.value = null;
              return true;
            }
          }
          return false;
        }

        @Override
        public int size() {
          return count;
        }

        @Override
        public void clear() {
          IntHashMap.this.clear();
        }
      };
    }

    return entrySet;
  }

  /**
   * IntHashMap collision list entry.
   */
  private static class Entry implements Map.Entry, Cloneable {
    int key;
    Object value;
    Entry next;
    private Integer objectKey;

    Entry(int key, Object value, Entry next) {
      this.key = key;
      this.value = value;
      this.next = next;
    }

    @Override
    protected Object clone() {
      return new Entry(key, value,
               (next==null ? null : (Entry)next.clone()));
    }

    // Map.Entry Ops

    public Object getKey() {
      return(objectKey != null) ? objectKey :
      (objectKey = new Integer(key));
    }

    public Object getValue() {
      return value;
    }

    public Object setValue(Object value) {
      Object oldValue = this.value;
      this.value = value;
      return oldValue;
    }

    @Override
    public boolean equals(Object o) {
      if (!(o instanceof Map.Entry)) {
        return false;
      }
      Map.Entry e = (Map.Entry)o;

      return(getKey().equals(e.getKey())) &&
      (value==null ? e.getValue()==null : value.equals(e.getValue()));
    }

    @Override
    public int hashCode() {
      return key ^ (value==null ? 0 : value.hashCode());
    }

    @Override
    public String toString() {
      return  Integer.toString(key) + '=' + value;
    }
  }

  // types of Iterators
  private static final int KEYS = 0;
  private static final int VALUES = 1;
  private static final int ENTRIES = 2;

  private class IntHashIterator implements Iterator {
    Entry[] table = IntHashMap.this.table;
    int index = table.length;
    Entry entry;
    Entry lastReturned;
    int type;

    /**
     * The modCount value that the iterator believes that the backing
     * List should have.  If this expectation is violated, the iterator
     * has detected concurrent modification.
     */
    private int expectedModCount = modCount;

    IntHashIterator(int type) {
      this.type = type;
    }

    public boolean hasNext() {
      while (entry == null && index > 0) {
        entry = table[--index];
      }

      return entry != null;
    }

    public Object next() {
      if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
      }

      while (entry == null && index > 0) {
        entry = table[--index];
      }

      if (entry != null) {
        Entry e = lastReturned = entry;
        entry = e.next;
        return type == KEYS ? e.getKey() :
        (type == VALUES ? e.value : e);
      }
      throw new NoSuchElementException();
    }

    public void remove() {
      if (lastReturned == null) {
        throw new IllegalStateException();
      }
      if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
      }

      Entry[] tab = IntHashMap.this.table;
      int ndx = (lastReturned.key & 0x7FFFFFFF) % tab.length;

      for (Entry e = tab[ndx], prev = null; e != null;
        prev = e, e = e.next) {
        if (e == lastReturned) {
          modCount++;
          expectedModCount++;
          if (prev == null) {
            tab[ndx] = e.next;
          } else {
            prev.next = e.next;
          }
          count--;
          lastReturned = null;
          return;
        }
      }
      throw new ConcurrentModificationException();
    }
  }

  /**
   * Save the state of the <code>IntHashMap</code> instance to a stream (i.e.,
   * serialize it).
   * <p>
   * Context The <i>capacity</i> of the IntHashMap (the length of the bucket
   * array) is emitted (int), followed by the <i>size</i> of the IntHashMap
   * (the number of key-value mappings), followed by the key (Object) and value
   * (Object) for each key-value mapping represented by the IntHashMap The
   * key-value mappings are emitted in no particular order.
   *
   * @exception IOException
   */
  private void writeObject(java.io.ObjectOutputStream s) throws IOException {
    // write out the threshold, loadfactor, and any hidden stuff
    s.defaultWriteObject();

    // write out number of buckets
    s.writeInt(table.length);

    // write out size (number of Mappings)
    s.writeInt(count);

    // write out keys and values (alternating)
    for (int index = table.length-1; index >= 0; index--) {
      Entry entry = table[index];

      while (entry != null) {
        s.writeInt(entry.key);
        s.writeObject(entry.value);
        entry = entry.next;
      }
    }
  }

  /**
   * Reconstitutes the <code>IntHashMap</code> instance from a stream (i.e.,
   * deserialize it).
   *
   * @exception IOException
   * @exception ClassNotFoundException
   */
  private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException {
    // read in the threshold, loadfactor, and any hidden stuff
    s.defaultReadObject();

    // read in number of buckets and allocate the bucket array;
    int numBuckets = s.readInt();
    table = new Entry[numBuckets];

    // read in size (number of Mappings)
    int size = s.readInt();

    // read the keys and values, and put the mappings in the IntHashMap
    for (int i=0; i<size; i++) {
      int key = s.readInt();
      Object value = s.readObject();
      put(key, value);
    }
  }

  int capacity() {
    return table.length;
  }

  float loadFactor() {
    return loadFactor;
  }
}

   
    
    
    
  








Related examples in the same category

1.Ordered Map
2.Case Insensitive Map
3.A Map collection with real-time behavior
4.Cache Map
5.Map implementation Optimized for Strings keys
6.An integer hashmap
7.An IdentityMap that uses reference-equality instead of object-equality
8.Int Object HashMap
9.Concurrent Skip List Map
10.A hash map that uses primitive ints for the key rather than objects.
11.Integer Map
12.Copy On Write Map
13.Expiring Map
14.Array Map
15.Int Object HashMap (from CERN)
16.String Map
17.List Map
18.Map using Locale objects as keys
19.Map with keys iterated in insertion order
20.Most Recently Used Map
21.Multi Map
22.MultiMap is a Java version of the C++ STL class std::multimap
23.Object Int Map
24.Sequenced HashMap
25.Int Int Map
26.Int Object Map
27.Identity HashMap
28.A java.util.Map interface which can only hold a single object
29.A multi valued Map
30.A simple hashmap from keys to integers
31.A memory-efficient hash map.
32.An implementation of the java.util.Map interface which can only hold a single object.
33.Utility methods for operating on memory-efficient maps.
34.CaseBlindHashMap - a HashMap extension, using Strings as key values.
35.A fixed size map implementation.
36.Int HashMap
37.IntMap provides a simple hashmap from keys to integers
38.Complex Key HashMap
39.A Map with multiple values for a key
40.A Map that accepts int or Integer keys only
41.A Map where keys are compared by object identity, rather than equals()
42.Type-safe Map, from char array to String value
43.A hashtable-based Map implementation with soft keys
44.List ordered map
45.Hash map using String values as keys mapped to primitive int values.
46.Lookup table that stores a list of strings
47.HashNMap stores multiple values by a single key value. Values can be retrieved using a direct query or by creating an enumeration over the stored elements.
48.Combines multiple values to form a single composite key. MultiKey can often be used as an alternative to nested maps.