jdk-sandbox: comparison src/java.base/share/classes/java/util/HashMap.java

equal deleted inserted replaced

-:e0637258a133
+:3f5f9bc0bdc2
 this.loadFactor = DEFAULT_LOAD_FACTOR;
 putMapEntries(m, false);
 }
 /**
-* Implements Map.putAll and Map constructor
+* Implements Map.putAll and Map constructor.
 *
 * @param m the map
 * @param evict false when initially constructing this map, else
 * true (relayed to method afterNodeInsertion).
 */
 Node<K,V> e;
 return (e = getNode(hash(key), key)) == null ? null : e.value;
 }
 /**
-* Implements Map.get and related methods
+* Implements Map.get and related methods.
 *
 * @param hash hash for key
 * @param key the key
 * @return the node, or null if none
 */
 public V put(K key, V value) {
 return putVal(hash(key), key, value, false, true);
 }
 /**
-* Implements Map.put and related methods
+* Implements Map.put and related methods.
 *
 * @param hash hash for key
 * @param key the key
 * @param value the value to put
 * @param onlyIfAbsent if true, don't change existing value
 newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
 (int)ft : Integer.MAX_VALUE);
 }
 threshold = newThr;
 @SuppressWarnings({"rawtypes","unchecked"})
 Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
 table = newTab;
 if (oldTab != null) {
 for (int j = 0; j < oldCap; ++j) {
 Node<K,V> e;
 if ((e = oldTab[j]) != null) {
 return (e = removeNode(hash(key), key, null, false, true)) == null ?
 null : e.value;
 }
 /**
-* Implements Map.remove and related methods
+* Implements Map.remove and related methods.
 *
 * @param hash hash for key
 * @param key the key
 * @param value the value to match if matchValue, else ignored
 * @param matchValue if true only remove if value is equal
 *         specified value
 */
 public boolean containsValue(Object value) {
 Node<K,V>[] tab; V v;
 if ((tab = table) != null && size > 0) {
-for (Node<K, V> e : tab) {
+for (Node<K,V> e : tab) {
 for (; e != null; e = e.next) {
 if ((v = e.value) == value ||
 (value != null && value.equals(v)))
 return true;
 }
 Node<K,V>[] tab;
 if (action == null)
 throw new NullPointerException();
 if (size > 0 && (tab = table) != null) {
 int mc = modCount;
-for (Node<K, V> e : tab) {
+for (Node<K,V> e : tab) {
 for (; e != null; e = e.next)
 action.accept(e.key);
 }
 if (modCount != mc)
 throw new ConcurrentModificationException();
 Node<K,V>[] tab;
 if (action == null)
 throw new NullPointerException();
 if (size > 0 && (tab = table) != null) {
 int mc = modCount;
-for (Node<K, V> e : tab) {
+for (Node<K,V> e : tab) {
 for (; e != null; e = e.next)
 action.accept(e.value);
 }
 if (modCount != mc)
 throw new ConcurrentModificationException();
 Node<K,V>[] tab;
 if (action == null)
 throw new NullPointerException();
 if (size > 0 && (tab = table) != null) {
 int mc = modCount;
-for (Node<K, V> e : tab) {
+for (Node<K,V> e : tab) {
 for (; e != null; e = e.next)
 action.accept(e);
 }
 if (modCount != mc)
 throw new ConcurrentModificationException();
 Node<K,V>[] tab;
 if (action == null)
 throw new NullPointerException();
 if (size > 0 && (tab = table) != null) {
 int mc = modCount;
-for (Node<K, V> e : tab) {
+for (Node<K,V> e : tab) {
 for (; e != null; e = e.next)
 action.accept(e.key, e.value);
 }
 if (modCount != mc)
 throw new ConcurrentModificationException();
 Node<K,V>[] tab;
 if (function == null)
 throw new NullPointerException();
 if (size > 0 && (tab = table) != null) {
 int mc = modCount;
-for (Node<K, V> e : tab) {
+for (Node<K,V> e : tab) {
 for (; e != null; e = e.next) {
 e.value = function.apply(e.key, e.value);
 }
 }
 if (modCount != mc)
 (threshold > 0) ? threshold :
 DEFAULT_INITIAL_CAPACITY;
 }
 /**
-* Save the state of the {@code HashMap} instance to a stream (i.e.,
+* Saves this map to a stream (that is, serializes it).
-* serialize it).
+*
-*
+* @param s the stream
+* @throws IOException if an I/O error occurs
 * @serialData The <i>capacity</i> of the HashMap (the length of the
 *             bucket array) is emitted (int), followed by the
 *             <i>size</i> (an int, the number of key-value
 *             mappings), followed by the key (Object) and value (Object)
 *             for each key-value mapping.  The key-value mappings are
 s.writeInt(size);
 internalWriteEntries(s);
 }
 /**
-* Reconstitute the {@code HashMap} instance from a stream (i.e.,
+* Reconstitutes this map from a stream (that is, deserializes it).
-* deserialize it).
+* @param s the stream
+* @throws ClassNotFoundException if the class of a serialized object
+*         could not be found
+* @throws IOException if an I/O error occurs
 */
 private void readObject(java.io.ObjectInputStream s)
 throws IOException, ClassNotFoundException {
 // Read in the threshold (ignored), loadfactor, and any hidden stuff
 s.defaultReadObject();
 tableSizeFor((int)fc));
 float ft = (float)cap * lf;
 threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
 (int)ft : Integer.MAX_VALUE);
 @SuppressWarnings({"rawtypes","unchecked"})
 Node<K,V>[] tab = (Node<K,V>[])new Node[cap];
 table = tab;
 // Read the keys and values, and put the mappings in the HashMap
 for (int i = 0; i < mappings; i++) {
 @SuppressWarnings("unchecked")
 // Called only from writeObject, to ensure compatible ordering.
 void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException {
 Node<K,V>[] tab;
 if (size > 0 && (tab = table) != null) {
-for (Node<K, V> e : tab) {
+for (Node<K,V> e : tab) {
 for (; e != null; e = e.next) {
 s.writeObject(e.key);
 s.writeObject(e.value);
 }
 }
 return d;
 }
 /**
 * Forms tree of the nodes linked from this node.
-* @return root of tree
 */
 final void treeify(Node<K,V>[] tab) {
 TreeNode<K,V> root = null;
 for (TreeNode<K,V> x = this, next; x != null; x = next) {
 next = (TreeNode<K,V>)x.next;
 succ.prev = pred;
 if (first == null)
 return;
 if (root.parent != null)
 root = root.root();
-if (root == null || root.right == null ||
+if (root == null
-(rl = root.left) == null || rl.left == null) {
+|| (movable
+&& (root.right == null
+|| (rl = root.left) == null
+|| rl.left == null))) {
 tab[index] = first.untreeify(map);  // too small
 return;
 }
 TreeNode<K,V> p = this, pl = left, pr = right, replacement;
 if (pl != null && pr != null) {
 }
 }
 static <K,V> TreeNode<K,V> balanceDeletion(TreeNode<K,V> root,
 TreeNode<K,V> x) {
-for (TreeNode<K,V> xp, xpl, xpr;;)  {
+for (TreeNode<K,V> xp, xpl, xpr;;) {
 if (x == null || x == root)
 return root;
 else if ((xp = x.parent) == null) {
 x.red = false;
 return x;

changeset 47304	3f5f9bc0bdc2
parent 47216	71c04702a3d5
child 47423	4fc2a4a29f3d