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

equal deleted inserted replaced

-:92676a77a667
+:b95438b17098
 *         permit null keys
 */
 public void putAll(Map<? extends K, ? extends V> map) {
 int mapSize = map.size();
 if (size==0 && mapSize!=0 && map instanceof SortedMap) {
-Comparator c = ((SortedMap)map).comparator();
+Comparator<?> c = ((SortedMap<?,?>)map).comparator();
 if (c == comparator || (c != null && c.equals(comparator))) {
 ++modCount;
 try {
 buildFromSorted(mapSize, map.entrySet().iterator(),
 null, null);
 // Offload comparator-based version for sake of performance
 if (comparator != null)
 return getEntryUsingComparator(key);
 if (key == null)
 throw new NullPointerException();
-Comparable<? super K> k = (Comparable<? super K>) key;
+@SuppressWarnings("unchecked")
+Comparable<? super K> k = (Comparable<? super K>) key;
 Entry<K,V> p = root;
 while (p != null) {
 int cmp = k.compareTo(p.key);
 if (cmp < 0)
 p = p.left;
 * for performance. (This is not worth doing for most methods,
 * that are less dependent on comparator performance, but is
 * worthwhile here.)
 */
 final Entry<K,V> getEntryUsingComparator(Object key) {
-K k = (K) key;
+@SuppressWarnings("unchecked")
+K k = (K) key;
 Comparator<? super K> cpr = comparator;
 if (cpr != null) {
 Entry<K,V> p = root;
 while (p != null) {
 int cmp = cpr.compare(k, p.key);
 } while (t != null);
 }
 else {
 if (key == null)
 throw new NullPointerException();
-Comparable<? super K> k = (Comparable<? super K>) key;
+@SuppressWarnings("unchecked")
+Comparable<? super K> k = (Comparable<? super K>) key;
 do {
 parent = t;
 cmp = k.compareTo(t.key);
 if (cmp < 0)
 t = t.left;
 * values themselves are not cloned.)
 *
 * @return a shallow copy of this map
 */
 public Object clone() {
-TreeMap<K,V> clone = null;
+TreeMap<?,?> clone;
 try {
-clone = (TreeMap<K,V>) super.clone();
+clone = (TreeMap<?,?>) super.clone();
 } catch (CloneNotSupportedException e) {
 throw new InternalError(e);
 }
 // Put clone into "virgin" state (except for comparator)
 /**
 * @since 1.6
 */
 public NavigableSet<K> navigableKeySet() {
 KeySet<K> nks = navigableKeySet;
-return (nks != null) ? nks : (navigableKeySet = new KeySet(this));
+return (nks != null) ? nks : (navigableKeySet = new KeySet<>(this));
 }
 /**
 * @since 1.6
 */
 * @since 1.6
 */
 public NavigableMap<K, V> descendingMap() {
 NavigableMap<K, V> km = descendingMap;
 return (km != null) ? km :
-(descendingMap = new DescendingSubMap(this,
+(descendingMap = new DescendingSubMap<>(this,
 true, null, true,
 true, null, true));
 }
 /**
 * @throws ClassCastException       {@inheritDoc}
 * @throws NullPointerException if {@code fromKey} or {@code toKey} is
 * @throws IllegalArgumentException {@inheritDoc}
 * @since 1.6
 */
 public NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
 K toKey,   boolean toInclusive) {
-return new AscendingSubMap(this,
+return new AscendingSubMap<>(this,
 false, fromKey, fromInclusive,
 false, toKey,   toInclusive);
 }
 /**
 * @throws ClassCastException       {@inheritDoc}
 * @throws NullPointerException if {@code toKey} is null
 *         does not permit null keys
 * @throws IllegalArgumentException {@inheritDoc}
 * @since 1.6
 */
 public NavigableMap<K,V> headMap(K toKey, boolean inclusive) {
-return new AscendingSubMap(this,
+return new AscendingSubMap<>(this,
 true,  null,  true,
 false, toKey, inclusive);
 }
 /**
 * @throws ClassCastException       {@inheritDoc}
 * @throws NullPointerException if {@code fromKey} is null
 *         does not permit null keys
 * @throws IllegalArgumentException {@inheritDoc}
 * @since 1.6
 */
 public NavigableMap<K,V> tailMap(K fromKey, boolean inclusive) {
-return new AscendingSubMap(this,
+return new AscendingSubMap<>(this,
 false, fromKey, inclusive,
 true,  null,    true);
 }
 /**
 * @throws ClassCastException       {@inheritDoc}
 * @throws NullPointerException if {@code fromKey} or {@code toKey} is
 }
 public boolean contains(Object o) {
 if (!(o instanceof Map.Entry))
 return false;
-Map.Entry<K,V> entry = (Map.Entry<K,V>) o;
+Map.Entry<?,?> entry = (Map.Entry<?,?>) o;
-V value = entry.getValue();
+Object value = entry.getValue();
 Entry<K,V> p = getEntry(entry.getKey());
 return p != null && valEquals(p.getValue(), value);
 }
 public boolean remove(Object o) {
 if (!(o instanceof Map.Entry))
 return false;
-Map.Entry<K,V> entry = (Map.Entry<K,V>) o;
+Map.Entry<?,?> entry = (Map.Entry<?,?>) o;
-V value = entry.getValue();
+Object value = entry.getValue();
 Entry<K,V> p = getEntry(entry.getKey());
 if (p != null && valEquals(p.getValue(), value)) {
 deleteEntry(p);
 return true;
 }
 Iterator<K> descendingKeyIterator() {
 return new DescendingKeyIterator(getLastEntry());
 }
 static final class KeySet<E> extends AbstractSet<E> implements NavigableSet<E> {
-private final NavigableMap<E, Object> m;
+private final NavigableMap<E, ?> m;
-KeySet(NavigableMap<E,Object> map) { m = map; }
+KeySet(NavigableMap<E,?> map) { m = map; }
 public Iterator<E> iterator() {
 if (m instanceof TreeMap)
-return ((TreeMap<E,Object>)m).keyIterator();
+return ((TreeMap<E,?>)m).keyIterator();
 else
-return (Iterator<E>)(((TreeMap.NavigableSubMap)m).keyIterator());
+return ((TreeMap.NavigableSubMap<E,?>)m).keyIterator();
 }
 public Iterator<E> descendingIterator() {
 if (m instanceof TreeMap)
-return ((TreeMap<E,Object>)m).descendingKeyIterator();
+return ((TreeMap<E,?>)m).descendingKeyIterator();
 else
-return (Iterator<E>)(((TreeMap.NavigableSubMap)m).descendingKeyIterator());
+return ((TreeMap.NavigableSubMap<E,?>)m).descendingKeyIterator();
 }
 public int size() { return m.size(); }
 public boolean isEmpty() { return m.isEmpty(); }
 public boolean contains(Object o) { return m.containsKey(o); }
 public E higher(E e) { return m.higherKey(e); }
 public E first() { return m.firstKey(); }
 public E last() { return m.lastKey(); }
 public Comparator<? super E> comparator() { return m.comparator(); }
 public E pollFirst() {
-Map.Entry<E,Object> e = m.pollFirstEntry();
+Map.Entry<E,?> e = m.pollFirstEntry();
 return (e == null) ? null : e.getKey();
 }
 public E pollLast() {
-Map.Entry<E,Object> e = m.pollLastEntry();
+Map.Entry<E,?> e = m.pollLastEntry();
 return (e == null) ? null : e.getKey();
 }
 public boolean remove(Object o) {
 int oldSize = size();
 m.remove(o);
 }
 public SortedSet<E> tailSet(E fromElement) {
 return tailSet(fromElement, true);
 }
 public NavigableSet<E> descendingSet() {
-return new KeySet(m.descendingMap());
+return new KeySet<>(m.descendingMap());
 }
 }
 /**
 * Base class for TreeMap Iterators
 // Little utilities
 /**
 * Compares two keys using the correct comparison method for this TreeMap.
 */
+@SuppressWarnings("unchecked")
 final int compare(Object k1, Object k2) {
 return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2)
 : comparator.compare((K)k1, (K)k2);
 }
 transient KeySet<K> navigableKeySetView = null;
 public final NavigableSet<K> navigableKeySet() {
 KeySet<K> nksv = navigableKeySetView;
 return (nksv != null) ? nksv :
-(navigableKeySetView = new TreeMap.KeySet(this));
+(navigableKeySetView = new TreeMap.KeySet<>(this));
 }
 public final Set<K> keySet() {
 return navigableKeySet();
 }
 if (fromStart && toEnd)
 return m.size();
 if (size == -1 || sizeModCount != m.modCount) {
 sizeModCount = m.modCount;
 size = 0;
-Iterator i = iterator();
+Iterator<?> i = iterator();
 while (i.hasNext()) {
 size++;
 i.next();
 }
 }
 }
 public boolean contains(Object o) {
 if (!(o instanceof Map.Entry))
 return false;
-Map.Entry<K,V> entry = (Map.Entry<K,V>) o;
+Map.Entry<?,?> entry = (Map.Entry<?,?>) o;
-K key = entry.getKey();
+Object key = entry.getKey();
 if (!inRange(key))
 return false;
-TreeMap.Entry node = m.getEntry(key);
+TreeMap.Entry<?,?> node = m.getEntry(key);
 return node != null &&
 valEquals(node.getValue(), entry.getValue());
 }
 public boolean remove(Object o) {
 if (!(o instanceof Map.Entry))
 return false;
-Map.Entry<K,V> entry = (Map.Entry<K,V>) o;
+Map.Entry<?,?> entry = (Map.Entry<?,?>) o;
-K key = entry.getKey();
+Object key = entry.getKey();
 if (!inRange(key))
 return false;
 TreeMap.Entry<K,V> node = m.getEntry(key);
 if (node!=null && valEquals(node.getValue(),
 entry.getValue())) {
 K toKey,   boolean toInclusive) {
 if (!inRange(fromKey, fromInclusive))
 throw new IllegalArgumentException("fromKey out of range");
 if (!inRange(toKey, toInclusive))
 throw new IllegalArgumentException("toKey out of range");
-return new AscendingSubMap(m,
+return new AscendingSubMap<>(m,
 false, fromKey, fromInclusive,
 false, toKey,   toInclusive);
 }
 public NavigableMap<K,V> headMap(K toKey, boolean inclusive) {
 if (!inRange(toKey, inclusive))
 throw new IllegalArgumentException("toKey out of range");
-return new AscendingSubMap(m,
+return new AscendingSubMap<>(m,
 fromStart, lo,    loInclusive,
 false,     toKey, inclusive);
 }
 public NavigableMap<K,V> tailMap(K fromKey, boolean inclusive) {
 if (!inRange(fromKey, inclusive))
 throw new IllegalArgumentException("fromKey out of range");
-return new AscendingSubMap(m,
+return new AscendingSubMap<>(m,
 false, fromKey, inclusive,
 toEnd, hi,      hiInclusive);
 }
 public NavigableMap<K,V> descendingMap() {
 NavigableMap<K,V> mv = descendingMapView;
 return (mv != null) ? mv :
 (descendingMapView =
-new DescendingSubMap(m,
+new DescendingSubMap<>(m,
 fromStart, lo, loInclusive,
 toEnd,     hi, hiInclusive));
 }
 Iterator<K> keyIterator() {
 return new SubMapKeyIterator(absLowest(), absHighFence());
 }
 K toKey,   boolean toInclusive) {
 if (!inRange(fromKey, fromInclusive))
 throw new IllegalArgumentException("fromKey out of range");
 if (!inRange(toKey, toInclusive))
 throw new IllegalArgumentException("toKey out of range");
-return new DescendingSubMap(m,
+return new DescendingSubMap<>(m,
 false, toKey,   toInclusive,
 false, fromKey, fromInclusive);
 }
 public NavigableMap<K,V> headMap(K toKey, boolean inclusive) {
 if (!inRange(toKey, inclusive))
 throw new IllegalArgumentException("toKey out of range");
-return new DescendingSubMap(m,
+return new DescendingSubMap<>(m,
 false, toKey, inclusive,
 toEnd, hi,    hiInclusive);
 }
 public NavigableMap<K,V> tailMap(K fromKey, boolean inclusive) {
 if (!inRange(fromKey, inclusive))
 throw new IllegalArgumentException("fromKey out of range");
-return new DescendingSubMap(m,
+return new DescendingSubMap<>(m,
 fromStart, lo, loInclusive,
 false, fromKey, inclusive);
 }
 public NavigableMap<K,V> descendingMap() {
 NavigableMap<K,V> mv = descendingMapView;
 return (mv != null) ? mv :
 (descendingMapView =
-new AscendingSubMap(m,
+new AscendingSubMap<>(m,
 fromStart, lo, loInclusive,
 toEnd,     hi, hiInclusive));
 }
 Iterator<K> keyIterator() {
 return new DescendingSubMapKeyIterator(absHighest(), absLowFence());
 }
 implements SortedMap<K,V>, java.io.Serializable {
 private static final long serialVersionUID = -6520786458950516097L;
 private boolean fromStart = false, toEnd = false;
 private K fromKey, toKey;
 private Object readResolve() {
-return new AscendingSubMap(TreeMap.this,
+return new AscendingSubMap<>(TreeMap.this,
 fromStart, fromKey, true,
 toEnd, toKey, false);
 }
 public Set<Map.Entry<K,V>> entrySet() { throw new InternalError(); }
 public K lastKey() { throw new InternalError(); }
 public K firstKey() { throw new InternalError(); }
 public SortedMap<K,V> subMap(K fromKey, K toKey) { throw new InternalError(); }
 *        possibly values read from this stream in serialized form.
 *        Exactly one of it and str should be non-null.
 * @param defaultVal if non-null, this default value is used for
 *        each value in the map.  If null, each value is read from
 *        iterator or stream, as described above.
-* @throws IOException propagated from stream reads. This cannot
+* @throws java.io.IOException propagated from stream reads. This cannot
 *         occur if str is null.
 * @throws ClassNotFoundException propagated from readObject.
 *         This cannot occur if str is null.
 */
-private void buildFromSorted(int size, Iterator it,
+private void buildFromSorted(int size, Iterator<?> it,
 java.io.ObjectInputStream str,
 V defaultVal)
 throws  java.io.IOException, ClassNotFoundException {
 this.size = size;
 root = buildFromSorted(0, 0, size-1, computeRedLevel(size),
 * @param hi the last element index of this subtree.  Initial should be
 *        size-1.
 * @param redLevel the level at which nodes should be red.
 *        Must be equal to computeRedLevel for tree of this size.
 */
+@SuppressWarnings("unchecked")
 private final Entry<K,V> buildFromSorted(int level, int lo, int hi,
 int redLevel,
-Iterator it,
+Iterator<?> it,
 java.io.ObjectInputStream str,
 V defaultVal)
 throws  java.io.IOException, ClassNotFoundException {
 /*
 * Strategy: The root is the middlemost element. To get to it, we
 // extract key and/or value from iterator or stream
 K key;
 V value;
 if (it != null) {
 if (defaultVal==null) {
-Map.Entry<K,V> entry = (Map.Entry<K,V>)it.next();
+Map.Entry<?,?> entry = (Map.Entry<?,?>)it.next();
-key = entry.getKey();
+key = (K)entry.getKey();
-value = entry.getValue();
+value = (V)entry.getValue();
 } else {
 key = (K)it.next();
 value = defaultVal;
 }
 } else { // use stream

changeset 12448	b95438b17098
parent 10419	12c063b39232
child 14342	8435a30053c1