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

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 /*
-* Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * @since   1.2
 */
 public class HashMap<K,V> extends AbstractMap<K,V>
 implements Map<K,V>, Cloneable, Serializable {
+@java.io.Serial
 private static final long serialVersionUID = 362498820763181265L;
 /*
 * Implementation notes.
 *
 keySet = ks;
 }
 return ks;
 }
+/**
+* Prepares the array for {@link Collection#toArray(Object[])} implementation.
+* If supplied array is smaller than this map size, a new array is allocated.
+* If supplied array is bigger than this map size, a null is written at size index.
+*
+* @param a an original array passed to {@code toArray()} method
+* @param <T> type of array elements
+* @return an array ready to be filled and returned from {@code toArray()} method.
+*/
+@SuppressWarnings("unchecked")
+final <T> T[] prepareArray(T[] a) {
+int size = this.size;
+if (a.length < size) {
+return (T[]) java.lang.reflect.Array
+.newInstance(a.getClass().getComponentType(), size);
+}
+if (a.length > size) {
+a[size] = null;
+}
+return a;
+}
+/**
+* Fills an array with this map keys and returns it. This method assumes
+* that input array is big enough to fit all the keys. Use
+* {@link #prepareArray(Object[])} to ensure this.
+*
+* @param a an array to fill
+* @param <T> type of array elements
+* @return supplied array
+*/
+<T> T[] keysToArray(T[] a) {
+Object[] r = a;
+Node<K,V>[] tab;
+int idx = 0;
+if (size > 0 && (tab = table) != null) {
+for (Node<K,V> e : tab) {
+for (; e != null; e = e.next) {
+r[idx++] = e.key;
+}
+}
+}
+return a;
+}
+/**
+* Fills an array with this map values and returns it. This method assumes
+* that input array is big enough to fit all the values. Use
+* {@link #prepareArray(Object[])} to ensure this.
+*
+* @param a an array to fill
+* @param <T> type of array elements
+* @return supplied array
+*/
+<T> T[] valuesToArray(T[] a) {
+Object[] r = a;
+Node<K,V>[] tab;
+int idx = 0;
+if (size > 0 && (tab = table) != null) {
+for (Node<K,V> e : tab) {
+for (; e != null; e = e.next) {
+r[idx++] = e.value;
+}
+}
+}
+return a;
+}
 final class KeySet extends AbstractSet<K> {
 public final int size()                 { return size; }
 public final void clear()               { HashMap.this.clear(); }
 public final Iterator<K> iterator()     { return new KeyIterator(); }
 public final boolean contains(Object o) { return containsKey(o); }
 return removeNode(hash(key), key, null, false, true) != null;
 }
 public final Spliterator<K> spliterator() {
 return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0);
 }
+public Object[] toArray() {
+return keysToArray(new Object[size]);
+}
+public <T> T[] toArray(T[] a) {
+return keysToArray(prepareArray(a));
+}
 public final void forEach(Consumer<? super K> action) {
 Node<K,V>[] tab;
 if (action == null)
 throw new NullPointerException();
 if (size > 0 && (tab = table) != null) {
 public final Iterator<V> iterator()     { return new ValueIterator(); }
 public final boolean contains(Object o) { return containsValue(o); }
 public final Spliterator<V> spliterator() {
 return new ValueSpliterator<>(HashMap.this, 0, -1, 0, 0);
 }
+public Object[] toArray() {
+return valuesToArray(new Object[size]);
+}
+public <T> T[] toArray(T[] a) {
+return valuesToArray(prepareArray(a));
+}
 public final void forEach(Consumer<? super V> action) {
 Node<K,V>[] tab;
 if (action == null)
 throw new NullPointerException();
 if (size > 0 && (tab = table) != null) {
 *             <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
 *             emitted in no particular order.
 */
+@java.io.Serial
 private void writeObject(java.io.ObjectOutputStream s)
 throws IOException {
 int buckets = capacity();
 // Write out the threshold, loadfactor, and any hidden stuff
 s.defaultWriteObject();
 * @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
 */
+@java.io.Serial
 private void readObject(java.io.ObjectInputStream s)
 throws IOException, ClassNotFoundException {
 // Read in the threshold (ignored), loadfactor, and any hidden stuff
 s.defaultReadObject();
 reinitialize();

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 53710	49adf961fcb1
child 58679	9c3209ff7550