java.util.HashMap.makeTable java code examples

Common ways to obtain HashMap

private void myMethod () {
 HashMap h =new HashMap()
new HashMap<String, String>()
new HashMap<String, Object>()
Smart code suggestions by Tabnine
}

HashMapEntry<K, V>[] newTable = makeTable(newCapacity);
if (size == 0) {
  return newTable;

/**
 * Constructs a new {@code HashMap} instance with the specified capacity.
 *
 * @param capacity
 *            the initial capacity of this hash map.
 * @throws IllegalArgumentException
 *                when the capacity is less than zero.
 */
public HashMap(int capacity) {
  if (capacity < 0) {
    throw new IllegalArgumentException("Capacity: " + capacity);
  }
  if (capacity == 0) {
    @SuppressWarnings("unchecked")
    HashMapEntry<K, V>[] tab = (HashMapEntry<K, V>[]) EMPTY_TABLE;
    table = tab;
    threshold = -1; // Forces first put() to replace EMPTY_TABLE
    return;
  }
  if (capacity < MINIMUM_CAPACITY) {
    capacity = MINIMUM_CAPACITY;
  } else if (capacity > MAXIMUM_CAPACITY) {
    capacity = MAXIMUM_CAPACITY;
  } else {
    capacity = Collections.roundUpToPowerOfTwo(capacity);
  }
  makeTable(capacity);
}

  private void readObject(ObjectInputStream stream) throws IOException,
      ClassNotFoundException {
    stream.defaultReadObject();
    int capacity = stream.readInt();
    if (capacity < 0) {
      throw new InvalidObjectException("Capacity: " + capacity);
    }
    if (capacity < MINIMUM_CAPACITY) {
      capacity = MINIMUM_CAPACITY;
    } else if (capacity > MAXIMUM_CAPACITY) {
      capacity = MAXIMUM_CAPACITY;
    } else {
      capacity = Collections.roundUpToPowerOfTwo(capacity);
    }
    makeTable(capacity);

    int size = stream.readInt();
    if (size < 0) {
      throw new InvalidObjectException("Size: " + size);
    }

    init(); // Give subclass (LinkedHashMap) a chance to initialize itself
    for (int i = 0; i < size; i++) {
      @SuppressWarnings("unchecked") K key = (K) stream.readObject();
      @SuppressWarnings("unchecked") V val = (V) stream.readObject();
      constructorPut(key, val);
    }
  }
}

/**
 * Returns a shallow copy of this map.
 *
 * @return a shallow copy of this map.
 */
@SuppressWarnings("unchecked")
@Override public Object clone() {
  /*
   * This could be made more efficient. It unnecessarily hashes all of
   * the elements in the map.
   */
  HashMap<K, V> result;
  try {
    result = (HashMap<K, V>) super.clone();
  } catch (CloneNotSupportedException e) {
    throw new AssertionError(e);
  }
  // Restore clone to empty state, retaining our capacity and threshold
  result.makeTable(table.length);
  result.entryForNullKey = null;
  result.size = 0;
  result.keySet = null;
  result.entrySet = null;
  result.values = null;
  result.init(); // Give subclass a chance to initialize itself
  result.constructorPutAll(this); // Calls method overridden in subclass!!
  return result;
}

HashMapEntry<K, V>[] newTable = makeTable(newCapacity);
if (size != 0) {
  int newMask = newCapacity - 1;

/**
 * Constructs a new {@code HashMap} instance with the specified capacity.
 *
 * @param capacity
 *            the initial capacity of this hash map.
 * @throws IllegalArgumentException
 *                when the capacity is less than zero.
 */
public HashMap(int capacity) {
  if (capacity < 0) {
    throw new IllegalArgumentException("Capacity: " + capacity);
  }
  if (capacity == 0) {
    @SuppressWarnings("unchecked")
    HashMapEntry<K, V>[] tab = (HashMapEntry<K, V>[]) EMPTY_TABLE;
    table = tab;
    threshold = -1; // Forces first put() to replace EMPTY_TABLE
    return;
  }
  if (capacity < MINIMUM_CAPACITY) {
    capacity = MINIMUM_CAPACITY;
  } else if (capacity > MAXIMUM_CAPACITY) {
    capacity = MAXIMUM_CAPACITY;
  } else {
    capacity = Collections.roundUpToPowerOfTwo(capacity);
  }
  makeTable(capacity);
}

/**
 * Constructs a new {@code HashMap} instance with the specified capacity.
 *
 * @param capacity
 *            the initial capacity of this hash map.
 * @throws IllegalArgumentException
 *                when the capacity is less than zero.
 */
public HashMap(int capacity) {
  if (capacity < 0) {
    throw new IllegalArgumentException("Capacity: " + capacity);
  }
  if (capacity == 0) {
    @SuppressWarnings("unchecked")
    HashMapEntry<K, V>[] tab = (HashMapEntry<K, V>[]) EMPTY_TABLE;
    table = tab;
    threshold = -1; // Forces first put() to replace EMPTY_TABLE
    return;
  }
  if (capacity < MINIMUM_CAPACITY) {
    capacity = MINIMUM_CAPACITY;
  } else if (capacity > MAXIMUM_CAPACITY) {
    capacity = MAXIMUM_CAPACITY;
  } else {
    capacity = Collections.roundUpToPowerOfTwo(capacity);
  }
  makeTable(capacity);
}

/**
 * Constructs a new {@code HashMap} instance with the specified capacity.
 *
 * @param capacity
 *            the initial capacity of this hash map.
 * @throws IllegalArgumentException
 *                when the capacity is less than zero.
 */
public HashMap(int capacity) {
  if (capacity < 0) {
    throw new IllegalArgumentException("Capacity: " + capacity);
  }
  if (capacity == 0) {
    @SuppressWarnings("unchecked")
    HashMapEntry<K, V>[] tab = (HashMapEntry<K, V>[]) EMPTY_TABLE;
    table = tab;
    threshold = -1; // Forces first put() to replace EMPTY_TABLE
    return;
  }
  if (capacity < MINIMUM_CAPACITY) {
    capacity = MINIMUM_CAPACITY;
  } else if (capacity > MAXIMUM_CAPACITY) {
    capacity = MAXIMUM_CAPACITY;
  } else {
    capacity = Collections.roundUpToPowerOfTwo(capacity);
  }
  makeTable(capacity);
}

/**
 * Constructs a new {@code HashMap} instance with the specified capacity.
 *
 * @param capacity
 *            the initial capacity of this hash map.
 * @throws IllegalArgumentException
 *                when the capacity is less than zero.
 */
public HashMap(int capacity) {
  if (capacity < 0) {
    throw new IllegalArgumentException("Capacity: " + capacity);
  }
  if (capacity == 0) {
    @SuppressWarnings("unchecked")
    HashMapEntry<K, V>[] tab = (HashMapEntry<K, V>[]) EMPTY_TABLE;
    table = tab;
    threshold = -1; // Forces first put() to replace EMPTY_TABLE
    return;
  }
  if (capacity < MINIMUM_CAPACITY) {
    capacity = MINIMUM_CAPACITY;
  } else if (capacity > MAXIMUM_CAPACITY) {
    capacity = MAXIMUM_CAPACITY;
  } else {
    capacity = Collections.roundUpToPowerOfTwo(capacity);
  }
  makeTable(capacity);
}

/**
 * Constructs a new {@code HashMap} instance with the specified capacity.
 *
 * @param capacity
 *            the initial capacity of this hash map.
 * @throws IllegalArgumentException
 *                when the capacity is less than zero.
 */
public HashMap(int capacity) {
  if (capacity < 0) {
    throw new IllegalArgumentException("Capacity: " + capacity);
  }
  if (capacity == 0) {
    @SuppressWarnings("unchecked")
    HashMapEntry<K, V>[] tab = (HashMapEntry<K, V>[]) EMPTY_TABLE;
    table = tab;
    threshold = -1; // Forces first put() to replace EMPTY_TABLE
    return;
  }
  if (capacity < MINIMUM_CAPACITY) {
    capacity = MINIMUM_CAPACITY;
  } else if (capacity > MAXIMUM_CAPACITY) {
    capacity = MAXIMUM_CAPACITY;
  } else {
    capacity = Collections.roundUpToPowerOfTwo(capacity);
  }
  makeTable(capacity);
}

  private void readObject(ObjectInputStream stream) throws IOException,
      ClassNotFoundException {
    stream.defaultReadObject();
    int capacity = stream.readInt();
    if (capacity < 0) {
      throw new InvalidObjectException("Capacity: " + capacity);
    }
    if (capacity < MINIMUM_CAPACITY) {
      capacity = MINIMUM_CAPACITY;
    } else if (capacity > MAXIMUM_CAPACITY) {
      capacity = MAXIMUM_CAPACITY;
    } else {
      capacity = Collections.roundUpToPowerOfTwo(capacity);
    }
    makeTable(capacity);

    int size = stream.readInt();
    if (size < 0) {
      throw new InvalidObjectException("Size: " + size);
    }

    init(); // Give subclass (LinkedHashMap) a chance to initialize itself
    for (int i = 0; i < size; i++) {
      @SuppressWarnings("unchecked") K key = (K) stream.readObject();
      @SuppressWarnings("unchecked") V val = (V) stream.readObject();
      constructorPut(key, val);
    }
  }
}

  private void readObject(ObjectInputStream stream) throws IOException,
      ClassNotFoundException {
    stream.defaultReadObject();
    int capacity = stream.readInt();
    if (capacity < 0) {
      throw new InvalidObjectException("Capacity: " + capacity);
    }
    if (capacity < MINIMUM_CAPACITY) {
      capacity = MINIMUM_CAPACITY;
    } else if (capacity > MAXIMUM_CAPACITY) {
      capacity = MAXIMUM_CAPACITY;
    } else {
      capacity = Collections.roundUpToPowerOfTwo(capacity);
    }
    makeTable(capacity);

    int size = stream.readInt();
    if (size < 0) {
      throw new InvalidObjectException("Size: " + size);
    }

    init(); // Give subclass (LinkedHashMap) a chance to initialize itself
    for (int i = 0; i < size; i++) {
      @SuppressWarnings("unchecked") K key = (K) stream.readObject();
      @SuppressWarnings("unchecked") V val = (V) stream.readObject();
      constructorPut(key, val);
    }
  }
}

  private void readObject(ObjectInputStream stream) throws IOException,
      ClassNotFoundException {
    stream.defaultReadObject();
    int capacity = stream.readInt();
    if (capacity < 0) {
      throw new InvalidObjectException("Capacity: " + capacity);
    }
    if (capacity < MINIMUM_CAPACITY) {
      capacity = MINIMUM_CAPACITY;
    } else if (capacity > MAXIMUM_CAPACITY) {
      capacity = MAXIMUM_CAPACITY;
    } else {
      capacity = Collections.roundUpToPowerOfTwo(capacity);
    }
    makeTable(capacity);

    int size = stream.readInt();
    if (size < 0) {
      throw new InvalidObjectException("Size: " + size);
    }

    init(); // Give subclass (LinkedHashMap) a chance to initialize itself
    for (int i = 0; i < size; i++) {
      @SuppressWarnings("unchecked") K key = (K) stream.readObject();
      @SuppressWarnings("unchecked") V val = (V) stream.readObject();
      constructorPut(key, val);
    }
  }
}

  private void readObject(ObjectInputStream stream) throws IOException,
      ClassNotFoundException {
    stream.defaultReadObject();
    int capacity = stream.readInt();
    if (capacity < 0) {
      throw new InvalidObjectException("Capacity: " + capacity);
    }
    if (capacity < MINIMUM_CAPACITY) {
      capacity = MINIMUM_CAPACITY;
    } else if (capacity > MAXIMUM_CAPACITY) {
      capacity = MAXIMUM_CAPACITY;
    } else {
      capacity = Collections.roundUpToPowerOfTwo(capacity);
    }
    makeTable(capacity);

    int size = stream.readInt();
    if (size < 0) {
      throw new InvalidObjectException("Size: " + size);
    }

    init(); // Give subclass (LinkedHashMap) a chance to initialize itself
    for (int i = 0; i < size; i++) {
      @SuppressWarnings("unchecked") K key = (K) stream.readObject();
      @SuppressWarnings("unchecked") V val = (V) stream.readObject();
      constructorPut(key, val);
    }
  }
}

  private void readObject(ObjectInputStream stream) throws IOException,
      ClassNotFoundException {
    stream.defaultReadObject();
    int capacity = stream.readInt();
    if (capacity < 0) {
      throw new InvalidObjectException("Capacity: " + capacity);
    }
    if (capacity < MINIMUM_CAPACITY) {
      capacity = MINIMUM_CAPACITY;
    } else if (capacity > MAXIMUM_CAPACITY) {
      capacity = MAXIMUM_CAPACITY;
    } else {
      capacity = Collections.roundUpToPowerOfTwo(capacity);
    }
    makeTable(capacity);

    int size = stream.readInt();
    if (size < 0) {
      throw new InvalidObjectException("Size: " + size);
    }

    init(); // Give subclass (LinkedHashMap) a chance to initialize itself
    for (int i = 0; i < size; i++) {
      @SuppressWarnings("unchecked") K key = (K) stream.readObject();
      @SuppressWarnings("unchecked") V val = (V) stream.readObject();
      constructorPut(key, val);
    }
  }
}

/**
 * Returns a shallow copy of this map.
 *
 * @return a shallow copy of this map.
 */
@SuppressWarnings("unchecked")
@Override public Object clone() {
  /*
   * This could be made more efficient. It unnecessarily hashes all of
   * the elements in the map.
   */
  HashMap<K, V> result;
  try {
    result = (HashMap<K, V>) super.clone();
  } catch (CloneNotSupportedException e) {
    throw new AssertionError(e);
  }
  // Restore clone to empty state, retaining our capacity and threshold
  result.makeTable(table.length);
  result.entryForNullKey = null;
  result.size = 0;
  result.keySet = null;
  result.entrySet = null;
  result.values = null;
  result.init(); // Give subclass a chance to initialize itself
  result.constructorPutAll(this); // Calls method overridden in subclass!!
  return result;
}

/**
 * Returns a shallow copy of this map.
 *
 * @return a shallow copy of this map.
 */
@SuppressWarnings("unchecked")
@Override public Object clone() {
  /*
   * This could be made more efficient. It unnecessarily hashes all of
   * the elements in the map.
   */
  HashMap<K, V> result;
  try {
    result = (HashMap<K, V>) super.clone();
  } catch (CloneNotSupportedException e) {
    throw new AssertionError(e);
  }
  // Restore clone to empty state, retaining our capacity and threshold
  result.makeTable(table.length);
  result.entryForNullKey = null;
  result.size = 0;
  result.keySet = null;
  result.entrySet = null;
  result.values = null;
  result.init(); // Give subclass a chance to initialize itself
  result.constructorPutAll(this); // Calls method overridden in subclass!!
  return result;
}

/**
 * Returns a shallow copy of this map.
 *
 * @return a shallow copy of this map.
 */
@SuppressWarnings("unchecked")
@Override public Object clone() {
  /*
   * This could be made more efficient. It unnecessarily hashes all of
   * the elements in the map.
   */
  HashMap<K, V> result;
  try {
    result = (HashMap<K, V>) super.clone();
  } catch (CloneNotSupportedException e) {
    throw new AssertionError(e);
  }
  // Restore clone to empty state, retaining our capacity and threshold
  result.makeTable(table.length);
  result.entryForNullKey = null;
  result.size = 0;
  result.keySet = null;
  result.entrySet = null;
  result.values = null;
  result.init(); // Give subclass a chance to initialize itself
  result.constructorPutAll(this); // Calls method overridden in subclass!!
  return result;
}

/**
 * Returns a shallow copy of this map.
 *
 * @return a shallow copy of this map.
 */
@SuppressWarnings("unchecked")
@Override public Object clone() {
  /*
   * This could be made more efficient. It unnecessarily hashes all of
   * the elements in the map.
   */
  HashMap<K, V> result;
  try {
    result = (HashMap<K, V>) super.clone();
  } catch (CloneNotSupportedException e) {
    throw new AssertionError(e);
  }
  // Restore clone to empty state, retaining our capacity and threshold
  result.makeTable(table.length);
  result.entryForNullKey = null;
  result.size = 0;
  result.keySet = null;
  result.entrySet = null;
  result.values = null;
  result.init(); // Give subclass a chance to initialize itself
  result.constructorPutAll(this); // Calls method overridden in subclass!!
  return result;
}

/**
 * Returns a shallow copy of this map.
 *
 * @return a shallow copy of this map.
 */
@SuppressWarnings("unchecked")
@Override public Object clone() {
  /*
   * This could be made more efficient. It unnecessarily hashes all of
   * the elements in the map.
   */
  HashMap<K, V> result;
  try {
    result = (HashMap<K, V>) super.clone();
  } catch (CloneNotSupportedException e) {
    throw new AssertionError(e);
  }
  // Restore clone to empty state, retaining our capacity and threshold
  result.makeTable(table.length);
  result.entryForNullKey = null;
  result.size = 0;
  result.keySet = null;
  result.entrySet = null;
  result.values = null;
  result.init(); // Give subclass a chance to initialize itself
  result.constructorPutAll(this); // Calls method overridden in subclass!!
  return result;
}

Javadoc

Allocate a table of the given capacity and set the threshold accordingly.

Popular methods of HashMap

<init>
Constructs a new HashMap instance containing the mappings from the specified map.
put
Maps the specified key to the specified value.
get
Returns the value of the mapping with the specified key.
containsKey
Returns whether this map contains the specified key.
keySet
Returns a set of the keys contained in this map. The set is backed by this map so changes to one are
remove
entrySet
Returns a set containing all of the mappings in this map. Each mapping is an instance of Map.Entry.
values
Returns a collection of the values contained in this map. The collection is backed by this map so ch
size
Returns the number of elements in this map.
clear
Removes all mappings from this hash map, leaving it empty.
isEmpty
Returns whether this map is empty.
putAll
Copies all the mappings in the specified map to this map. These mappings will replace all mappings t

Popular in Java

Making http requests using okhttp
getResourceAsStream (ClassLoader)
addToBackStack (FragmentTransaction)
compareTo (BigDecimal)
Menu (java.awt)
BufferedImage (java.awt.image)
The BufferedImage subclass describes an java.awt.Image with an accessible buffer of image data. All
BitSet (java.util)
The BitSet class implements abit array [http://en.wikipedia.org/wiki/Bit_array]. Each element is eit
Enumeration (java.util)
A legacy iteration interface.New code should use Iterator instead. Iterator replaces the enumeration
TimeUnit (java.util.concurrent)
A TimeUnit represents time durations at a given unit of granularity and provides utility methods to
Annotation (javassist.bytecode.annotation)
The annotation structure.An instance of this class is returned bygetAnnotations() in AnnotationsAttr
Sublime Text for Python

How to use makeTablemethodin java.util.HashMap

Best Java code snippets using java.util.HashMap.makeTable (Showing top 20 results out of 315)

How to use
makeTable
method
in
java.util.HashMap