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

equal deleted inserted replaced

-:74f2ee2b62ba
+:56bc97d69d93
 * @param  c the collection for which an unmodifiable view is to be
 *         returned.
 * @return an unmodifiable view of the specified collection.
 */
 public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c) {
-return new UnmodifiableCollection<T>(c);
+return new UnmodifiableCollection<>(c);
 }
 /**
 * @serial include
 */
 *
 * @param  s the set for which an unmodifiable view is to be returned.
 * @return an unmodifiable view of the specified set.
 */
 public static <T> Set<T> unmodifiableSet(Set<? extends T> s) {
-return new UnmodifiableSet<T>(s);
+return new UnmodifiableSet<>(s);
 }
 /**
 * @serial include
 */
 * @param s the sorted set for which an unmodifiable view is to be
 *        returned.
 * @return an unmodifiable view of the specified sorted set.
 */
 public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s) {
-return new UnmodifiableSortedSet<T>(s);
+return new UnmodifiableSortedSet<>(s);
 }
 /**
 * @serial include
 */
 UnmodifiableSortedSet(SortedSet<E> s) {super(s); ss = s;}
 public Comparator<? super E> comparator() {return ss.comparator();}
 public SortedSet<E> subSet(E fromElement, E toElement) {
-return new UnmodifiableSortedSet<E>(ss.subSet(fromElement,toElement));
+return new UnmodifiableSortedSet<>(ss.subSet(fromElement,toElement));
 }
 public SortedSet<E> headSet(E toElement) {
-return new UnmodifiableSortedSet<E>(ss.headSet(toElement));
+return new UnmodifiableSortedSet<>(ss.headSet(toElement));
 }
 public SortedSet<E> tailSet(E fromElement) {
-return new UnmodifiableSortedSet<E>(ss.tailSet(fromElement));
+return new UnmodifiableSortedSet<>(ss.tailSet(fromElement));
 }
 public E first()                   {return ss.first();}
 public E last()                    {return ss.last();}
 }
 * @param  list the list for which an unmodifiable view is to be returned.
 * @return an unmodifiable view of the specified list.
 */
 public static <T> List<T> unmodifiableList(List<? extends T> list) {
 return (list instanceof RandomAccess ?
-new UnmodifiableRandomAccessList<T>(list) :
+new UnmodifiableRandomAccessList<>(list) :
-new UnmodifiableList<T>(list));
+new UnmodifiableList<>(list));
 }
 /**
 * @serial include
 */
 }
 };
 }
 public List<E> subList(int fromIndex, int toIndex) {
-return new UnmodifiableList<E>(list.subList(fromIndex, toIndex));
+return new UnmodifiableList<>(list.subList(fromIndex, toIndex));
 }
 /**
 * UnmodifiableRandomAccessList instances are serialized as
 * UnmodifiableList instances to allow them to be deserialized
 * serialized in 1.4.1 and deserialized in 1.4 will become
 * UnmodifiableList instances, as this method was missing in 1.4.
 */
 private Object readResolve() {
 return (list instanceof RandomAccess
-? new UnmodifiableRandomAccessList<E>(list)
+? new UnmodifiableRandomAccessList<>(list)
 : this);
 }
 }
 /**
 UnmodifiableRandomAccessList(List<? extends E> list) {
 super(list);
 }
 public List<E> subList(int fromIndex, int toIndex) {
-return new UnmodifiableRandomAccessList<E>(
+return new UnmodifiableRandomAccessList<>(
 list.subList(fromIndex, toIndex));
 }
 private static final long serialVersionUID = -2542308836966382001L;
 * not have UnmodifiableRandomAccessList).  UnmodifiableList has
 * a readResolve method that inverts this transformation upon
 * deserialization.
 */
 private Object writeReplace() {
-return new UnmodifiableList<E>(list);
+return new UnmodifiableList<>(list);
 }
 }
 /**
 * Returns an unmodifiable view of the specified map.  This method
 *
 * @param  m the map for which an unmodifiable view is to be returned.
 * @return an unmodifiable view of the specified map.
 */
 public static <K,V> Map<K,V> unmodifiableMap(Map<? extends K, ? extends V> m) {
-return new UnmodifiableMap<K,V>(m);
+return new UnmodifiableMap<>(m);
 }
 /**
 * @serial include
 */
 return keySet;
 }
 public Set<Map.Entry<K,V>> entrySet() {
 if (entrySet==null)
-entrySet = new UnmodifiableEntrySet<K,V>(m.entrySet());
+entrySet = new UnmodifiableEntrySet<>(m.entrySet());
 return entrySet;
 }
 public Collection<V> values() {
 if (values==null)
 public boolean hasNext() {
 return i.hasNext();
 }
 public Map.Entry<K,V> next() {
-return new UnmodifiableEntry<K,V>(i.next());
+return new UnmodifiableEntry<>(i.next());
 }
 public void remove() {
 throw new UnsupportedOperationException();
 }
 };
 }
 public Object[] toArray() {
 Object[] a = c.toArray();
 for (int i=0; i<a.length; i++)
-a[i] = new UnmodifiableEntry<K,V>((Map.Entry<K,V>)a[i]);
+a[i] = new UnmodifiableEntry<>((Map.Entry<K,V>)a[i]);
 return a;
 }
 public <T> T[] toArray(T[] a) {
 // We don't pass a to c.toArray, to avoid window of
 // vulnerability wherein an unscrupulous multithreaded client
 // could get his hands on raw (unwrapped) Entries from c.
 Object[] arr = c.toArray(a.length==0 ? a : Arrays.copyOf(a, 0));
 for (int i=0; i<arr.length; i++)
-arr[i] = new UnmodifiableEntry<K,V>((Map.Entry<K,V>)arr[i]);
+arr[i] = new UnmodifiableEntry<>((Map.Entry<K,V>)arr[i]);
 if (arr.length > a.length)
 return (T[])arr;
 System.arraycopy(arr, 0, a, 0, arr.length);
 */
 public boolean contains(Object o) {
 if (!(o instanceof Map.Entry))
 return false;
 return c.contains(
-new UnmodifiableEntry<Object,Object>((Map.Entry<?,?>) o));
+new UnmodifiableEntry<>((Map.Entry<?,?>) o));
 }
 /**
 * The next two methods are overridden to protect against
 * an unscrupulous List whose contains(Object o) method senses
 * @param m the sorted map for which an unmodifiable view is to be
 *        returned.
 * @return an unmodifiable view of the specified sorted map.
 */
 public static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K, ? extends V> m) {
-return new UnmodifiableSortedMap<K,V>(m);
+return new UnmodifiableSortedMap<>(m);
 }
 /**
 * @serial include
 */
 UnmodifiableSortedMap(SortedMap<K, ? extends V> m) {super(m); sm = m;}
 public Comparator<? super K> comparator() {return sm.comparator();}
 public SortedMap<K,V> subMap(K fromKey, K toKey) {
-return new UnmodifiableSortedMap<K,V>(sm.subMap(fromKey, toKey));
+return new UnmodifiableSortedMap<>(sm.subMap(fromKey, toKey));
 }
 public SortedMap<K,V> headMap(K toKey) {
-return new UnmodifiableSortedMap<K,V>(sm.headMap(toKey));
+return new UnmodifiableSortedMap<>(sm.headMap(toKey));
 }
 public SortedMap<K,V> tailMap(K fromKey) {
-return new UnmodifiableSortedMap<K,V>(sm.tailMap(fromKey));
+return new UnmodifiableSortedMap<>(sm.tailMap(fromKey));
 }
 public K firstKey()           {return sm.firstKey();}
 public K lastKey()            {return sm.lastKey();}
 }
 *
 * @param  c the collection to be "wrapped" in a synchronized collection.
 * @return a synchronized view of the specified collection.
 */
 public static <T> Collection<T> synchronizedCollection(Collection<T> c) {
-return new SynchronizedCollection<T>(c);
+return new SynchronizedCollection<>(c);
 }
 static <T> Collection<T> synchronizedCollection(Collection<T> c, Object mutex) {
-return new SynchronizedCollection<T>(c, mutex);
+return new SynchronizedCollection<>(c, mutex);
 }
 /**
 * @serial include
 */
 *
 * @param  s the set to be "wrapped" in a synchronized set.
 * @return a synchronized view of the specified set.
 */
 public static <T> Set<T> synchronizedSet(Set<T> s) {
-return new SynchronizedSet<T>(s);
+return new SynchronizedSet<>(s);
 }
 static <T> Set<T> synchronizedSet(Set<T> s, Object mutex) {
-return new SynchronizedSet<T>(s, mutex);
+return new SynchronizedSet<>(s, mutex);
 }
 /**
 * @serial include
 */
 *
 * @param  s the sorted set to be "wrapped" in a synchronized sorted set.
 * @return a synchronized view of the specified sorted set.
 */
 public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s) {
-return new SynchronizedSortedSet<T>(s);
+return new SynchronizedSortedSet<>(s);
 }
 /**
 * @serial include
 */
 synchronized (mutex) {return ss.comparator();}
 }
 public SortedSet<E> subSet(E fromElement, E toElement) {
 synchronized (mutex) {
-return new SynchronizedSortedSet<E>(
+return new SynchronizedSortedSet<>(
 ss.subSet(fromElement, toElement), mutex);
 }
 }
 public SortedSet<E> headSet(E toElement) {
 synchronized (mutex) {
-return new SynchronizedSortedSet<E>(ss.headSet(toElement), mutex);
+return new SynchronizedSortedSet<>(ss.headSet(toElement), mutex);
 }
 }
 public SortedSet<E> tailSet(E fromElement) {
 synchronized (mutex) {
-return new SynchronizedSortedSet<E>(ss.tailSet(fromElement),mutex);
+return new SynchronizedSortedSet<>(ss.tailSet(fromElement),mutex);
 }
 }
 public E first() {
 synchronized (mutex) {return ss.first();}
 * @param  list the list to be "wrapped" in a synchronized list.
 * @return a synchronized view of the specified list.
 */
 public static <T> List<T> synchronizedList(List<T> list) {
 return (list instanceof RandomAccess ?
-new SynchronizedRandomAccessList<T>(list) :
+new SynchronizedRandomAccessList<>(list) :
-new SynchronizedList<T>(list));
+new SynchronizedList<>(list));
 }
 static <T> List<T> synchronizedList(List<T> list, Object mutex) {
 return (list instanceof RandomAccess ?
-new SynchronizedRandomAccessList<T>(list, mutex) :
+new SynchronizedRandomAccessList<>(list, mutex) :
-new SynchronizedList<T>(list, mutex));
+new SynchronizedList<>(list, mutex));
 }
 /**
 * @serial include
 */
 return list.listIterator(index); // Must be manually synched by user
 }
 public List<E> subList(int fromIndex, int toIndex) {
 synchronized (mutex) {
-return new SynchronizedList<E>(list.subList(fromIndex, toIndex),
+return new SynchronizedList<>(list.subList(fromIndex, toIndex),
 mutex);
 }
 }
 /**
 * serialized in 1.4.1 and deserialized in 1.4 will become
 * SynchronizedList instances, as this method was missing in 1.4.
 */
 private Object readResolve() {
 return (list instanceof RandomAccess
-? new SynchronizedRandomAccessList<E>(list)
+? new SynchronizedRandomAccessList<>(list)
 : this);
 }
 }
 /**
 super(list, mutex);
 }
 public List<E> subList(int fromIndex, int toIndex) {
 synchronized (mutex) {
-return new SynchronizedRandomAccessList<E>(
+return new SynchronizedRandomAccessList<>(
 list.subList(fromIndex, toIndex), mutex);
 }
 }
 private static final long serialVersionUID = 1530674583602358482L;
 * not have SynchronizedRandomAccessList).  SynchronizedList has
 * a readResolve method that inverts this transformation upon
 * deserialization.
 */
 private Object writeReplace() {
-return new SynchronizedList<E>(list);
+return new SynchronizedList<>(list);
 }
 }
 /**
 * Returns a synchronized (thread-safe) map backed by the specified
 *
 * @param  m the map to be "wrapped" in a synchronized map.
 * @return a synchronized view of the specified map.
 */
 public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {
-return new SynchronizedMap<K,V>(m);
+return new SynchronizedMap<>(m);
 }
 /**
 * @serial include
 */
 private transient Collection<V> values = null;
 public Set<K> keySet() {
 synchronized (mutex) {
 if (keySet==null)
-keySet = new SynchronizedSet<K>(m.keySet(), mutex);
+keySet = new SynchronizedSet<>(m.keySet(), mutex);
 return keySet;
 }
 }
 public Set<Map.Entry<K,V>> entrySet() {
 synchronized (mutex) {
 if (entrySet==null)
-entrySet = new SynchronizedSet<Map.Entry<K,V>>(m.entrySet(), mutex);
+entrySet = new SynchronizedSet<>(m.entrySet(), mutex);
 return entrySet;
 }
 }
 public Collection<V> values() {
 synchronized (mutex) {
 if (values==null)
-values = new SynchronizedCollection<V>(m.values(), mutex);
+values = new SynchronizedCollection<>(m.values(), mutex);
 return values;
 }
 }
 public boolean equals(Object o) {
 *
 * @param  m the sorted map to be "wrapped" in a synchronized sorted map.
 * @return a synchronized view of the specified sorted map.
 */
 public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m) {
-return new SynchronizedSortedMap<K,V>(m);
+return new SynchronizedSortedMap<>(m);
 }
 /**
 * @serial include
 synchronized (mutex) {return sm.comparator();}
 }
 public SortedMap<K,V> subMap(K fromKey, K toKey) {
 synchronized (mutex) {
-return new SynchronizedSortedMap<K,V>(
+return new SynchronizedSortedMap<>(
 sm.subMap(fromKey, toKey), mutex);
 }
 }
 public SortedMap<K,V> headMap(K toKey) {
 synchronized (mutex) {
-return new SynchronizedSortedMap<K,V>(sm.headMap(toKey), mutex);
+return new SynchronizedSortedMap<>(sm.headMap(toKey), mutex);
 }
 }
 public SortedMap<K,V> tailMap(K fromKey) {
 synchronized (mutex) {
-return new SynchronizedSortedMap<K,V>(sm.tailMap(fromKey),mutex);
+return new SynchronizedSortedMap<>(sm.tailMap(fromKey),mutex);
 }
 }
 public K firstKey() {
 synchronized (mutex) {return sm.firstKey();}
 * @return a dynamically typesafe view of the specified collection
 * @since 1.5
 */
 public static <E> Collection<E> checkedCollection(Collection<E> c,
 Class<E> type) {
-return new CheckedCollection<E>(c, type);
+return new CheckedCollection<>(c, type);
 }
 @SuppressWarnings("unchecked")
 static <T> T[] zeroLengthArray(Class<T> type) {
 return (T[]) Array.newInstance(type, 0);
 * @param type the type of element that {@code s} is permitted to hold
 * @return a dynamically typesafe view of the specified set
 * @since 1.5
 */
 public static <E> Set<E> checkedSet(Set<E> s, Class<E> type) {
-return new CheckedSet<E>(s, type);
+return new CheckedSet<>(s, type);
 }
 /**
 * @serial include
 */
 * @return a dynamically typesafe view of the specified sorted set
 * @since 1.5
 */
 public static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s,
 Class<E> type) {
-return new CheckedSortedSet<E>(s, type);
+return new CheckedSortedSet<>(s, type);
 }
 /**
 * @serial include
 */
 * @return a dynamically typesafe view of the specified list
 * @since 1.5
 */
 public static <E> List<E> checkedList(List<E> list, Class<E> type) {
 return (list instanceof RandomAccess ?
-new CheckedRandomAccessList<E>(list, type) :
+new CheckedRandomAccessList<>(list, type) :
-new CheckedList<E>(list, type));
+new CheckedList<>(list, type));
 }
 /**
 * @serial include
 */
 }
 };
 }
 public List<E> subList(int fromIndex, int toIndex) {
-return new CheckedList<E>(list.subList(fromIndex, toIndex), type);
+return new CheckedList<>(list.subList(fromIndex, toIndex), type);
 }
 }
 /**
 * @serial include
 CheckedRandomAccessList(List<E> list, Class<E> type) {
 super(list, type);
 }
 public List<E> subList(int fromIndex, int toIndex) {
-return new CheckedRandomAccessList<E>(
+return new CheckedRandomAccessList<>(
 list.subList(fromIndex, toIndex), type);
 }
 }
 /**
 * @since 1.5
 */
 public static <K, V> Map<K, V> checkedMap(Map<K, V> m,
 Class<K> keyType,
 Class<V> valueType) {
-return new CheckedMap<K,V>(m, keyType, valueType);
+return new CheckedMap<>(m, keyType, valueType);
 }
 /**
 * @serial include
 // - good diagnostics in case of type mismatch
 // - all-or-nothing semantics
 // - protection from malicious t
 // - correct behavior if t is a concurrent map
 Object[] entries = t.entrySet().toArray();
-List<Map.Entry<K,V>> checked =
+List<Map.Entry<K,V>> checked = new ArrayList<>(entries.length);
-new ArrayList<Map.Entry<K,V>>(entries.length);
 for (Object o : entries) {
 Map.Entry<?,?> e = (Map.Entry<?,?>) o;
 Object k = e.getKey();
 Object v = e.getValue();
 typeCheck(k, v);
 checked.add(
-new AbstractMap.SimpleImmutableEntry<K,V>((K) k, (V) v));
+new AbstractMap.SimpleImmutableEntry<>((K) k, (V) v));
 }
 for (Map.Entry<K,V> e : checked)
 m.put(e.getKey(), e.getValue());
 }
 private transient Set<Map.Entry<K,V>> entrySet = null;
 public Set<Map.Entry<K,V>> entrySet() {
 if (entrySet==null)
-entrySet = new CheckedEntrySet<K,V>(m.entrySet(), valueType);
+entrySet = new CheckedEntrySet<>(m.entrySet(), valueType);
 return entrySet;
 }
 /**
 * We need this class in addition to CheckedSet as Map.Entry permits
 public boolean remove(Object o) {
 if (!(o instanceof Map.Entry))
 return false;
 return s.remove(new AbstractMap.SimpleImmutableEntry
-<Object, Object>((Map.Entry<?,?>)o));
+<>((Map.Entry<?,?>)o));
 }
 public boolean removeAll(Collection<?> c) {
 return batchRemove(c, false);
 }
 && containsAll(that); // Invokes safe containsAll() above
 }
 static <K,V,T> CheckedEntry<K,V,T> checkedEntry(Map.Entry<K,V> e,
 Class<T> valueType) {
-return new CheckedEntry<K,V,T>(e, valueType);
+return new CheckedEntry<>(e, valueType);
 }
 /**
 * This "wrapper class" serves two purposes: it prevents
 * the client from modifying the backing Map, by short-circuiting
 if (o == this)
 return true;
 if (!(o instanceof Map.Entry))
 return false;
 return e.equals(new AbstractMap.SimpleImmutableEntry
-<Object, Object>((Map.Entry<?,?>)o));
+<>((Map.Entry<?,?>)o));
 }
 }
 }
 }
 * @since 1.5
 */
 public static <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K, V> m,
 Class<K> keyType,
 Class<V> valueType) {
-return new CheckedSortedMap<K,V>(m, keyType, valueType);
+return new CheckedSortedMap<>(m, keyType, valueType);
 }
 /**
 * @serial include
 */
 return (Iterator<T>) EmptyIterator.EMPTY_ITERATOR;
 }
 private static class EmptyIterator<E> implements Iterator<E> {
 static final EmptyIterator<Object> EMPTY_ITERATOR
-= new EmptyIterator<Object>();
+= new EmptyIterator<>();
 public boolean hasNext() { return false; }
 public E next() { throw new NoSuchElementException(); }
 public void remove() { throw new IllegalStateException(); }
 }
 private static class EmptyListIterator<E>
 extends EmptyIterator<E>
 implements ListIterator<E>
 {
 static final EmptyListIterator<Object> EMPTY_ITERATOR
-= new EmptyListIterator<Object>();
+= new EmptyListIterator<>();
 public boolean hasPrevious() { return false; }
 public E previous() { throw new NoSuchElementException(); }
 public int nextIndex()     { return 0; }
 public int previousIndex() { return -1; }
 return (Enumeration<T>) EmptyEnumeration.EMPTY_ENUMERATION;
 }
 private static class EmptyEnumeration<E> implements Enumeration<E> {
 static final EmptyEnumeration<Object> EMPTY_ENUMERATION
-= new EmptyEnumeration<Object>();
+= new EmptyEnumeration<>();
 public boolean hasMoreElements() { return false; }
 public E nextElement() { throw new NoSuchElementException(); }
 }
 * The empty set (immutable).  This set is serializable.
 *
 * @see #emptySet()
 */
 @SuppressWarnings("unchecked")
-public static final Set EMPTY_SET = new EmptySet<Object>();
+public static final Set EMPTY_SET = new EmptySet<>();
 /**
 * Returns the empty set (immutable).  This set is serializable.
 * Unlike the like-named field, this method is parameterized.
 *
 * The empty list (immutable).  This list is serializable.
 *
 * @see #emptyList()
 */
 @SuppressWarnings("unchecked")
-public static final List EMPTY_LIST = new EmptyList<Object>();
+public static final List EMPTY_LIST = new EmptyList<>();
 /**
 * Returns the empty list (immutable).  This list is serializable.
 *
 * <p>This example illustrates the type-safe way to obtain an empty list:
 *
 * @see #emptyMap()
 * @since 1.3
 */
 @SuppressWarnings("unchecked")
-public static final Map EMPTY_MAP = new EmptyMap<Object,Object>();
+public static final Map EMPTY_MAP = new EmptyMap<>();
 /**
 * Returns the empty map (immutable).  This map is serializable.
 *
 * <p>This example illustrates the type-safe way to obtain an empty set:
 *
 * @param o the sole object to be stored in the returned set.
 * @return an immutable set containing only the specified object.
 */
 public static <T> Set<T> singleton(T o) {
-return new SingletonSet<T>(o);
+return new SingletonSet<>(o);
 }
 static <E> Iterator<E> singletonIterator(final E e) {
 return new Iterator<E>() {
 private boolean hasNext = true;
 * @param o the sole object to be stored in the returned list.
 * @return an immutable list containing only the specified object.
 * @since 1.3
 */
 public static <T> List<T> singletonList(T o) {
-return new SingletonList<T>(o);
+return new SingletonList<>(o);
 }
 /**
 * @serial include
 */
 * @return an immutable map containing only the specified key-value
 *         mapping.
 * @since 1.3
 */
 public static <K,V> Map<K,V> singletonMap(K key, V value) {
-return new SingletonMap<K,V>(key, value);
+return new SingletonMap<>(key, value);
 }
 /**
 * @serial include
 */
 }
 public Set<Map.Entry<K,V>> entrySet() {
 if (entrySet==null)
 entrySet = Collections.<Map.Entry<K,V>>singleton(
-new SimpleImmutableEntry<K,V>(k, v));
+new SimpleImmutableEntry<>(k, v));
 return entrySet;
 }
 public Collection<V> values() {
 if (values==null)
 * @see    List#addAll(int, Collection)
 */
 public static <T> List<T> nCopies(int n, T o) {
 if (n < 0)
 throw new IllegalArgumentException("List length = " + n);
-return new CopiesList<T>(n, o);
+return new CopiesList<>(n, o);
 }
 /**
 * @serial include
 */
 if (toIndex > n)
 throw new IndexOutOfBoundsException("toIndex = " + toIndex);
 if (fromIndex > toIndex)
 throw new IllegalArgumentException("fromIndex(" + fromIndex +
 ") > toIndex(" + toIndex + ")");
-return new CopiesList<E>(toIndex - fromIndex, element);
+return new CopiesList<>(toIndex - fromIndex, element);
 }
 }
 /**
 * Returns a comparator that imposes the reverse of the <i>natural
 return reverseOrder();
 if (cmp instanceof ReverseComparator2)
 return ((ReverseComparator2<T>)cmp).cmp;
-return new ReverseComparator2<T>(cmp);
+return new ReverseComparator2<>(cmp);
 }
 /**
 * @serial include
 */
 * @since 1.4
 * @see Enumeration
 * @see ArrayList
 */
 public static <T> ArrayList<T> list(Enumeration<T> e) {
-ArrayList<T> l = new ArrayList<T>();
+ArrayList<T> l = new ArrayList<>();
 while (e.hasMoreElements())
 l.add(e.nextElement());
 return l;
 }
 * @return the set backed by the map
 * @throws IllegalArgumentException if <tt>map</tt> is not empty
 * @since 1.6
 */
 public static <E> Set<E> newSetFromMap(Map<E, Boolean> map) {
-return new SetFromMap<E>(map);
+return new SetFromMap<>(map);
 }
 /**
 * @serial include
 */
 * @param deque the deque
 * @return the queue
 * @since  1.6
 */
 public static <T> Queue<T> asLifoQueue(Deque<T> deque) {
-return new AsLIFOQueue<T>(deque);
+return new AsLIFOQueue<>(deque);
 }
 /**
 * @serial include
 */

changeset 7803	56bc97d69d93
parent 7518	0282db800fe1
child 7816	55a18147b4bf