ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/main/java/util/Collections.java
(Generate patch)

Comparing jsr166/src/main/java/util/Collections.java (file contents):
Revision 1.2 by dl, Wed Mar 23 11:20:27 2005 UTC vs.
Revision 1.20 by jsr166, Wed Jan 11 00:57:12 2006 UTC

# Line 1 | Line 1
1   /*
2   * %W% %E%
3   *
4 < * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
4 > * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
5   * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
6   */
7  
8   package java.util;
9 + import java.util.*; // for javadoc (till 6280605 is fixed)
10   import java.io.Serializable;
11   import java.io.ObjectOutputStream;
12   import java.io.IOException;
# Line 37 | Line 38 | import java.lang.reflect.Array;
38   * example, invoking the <tt>sort</tt> method on an unmodifiable list that is
39   * already sorted may or may not throw <tt>UnsupportedOperationException</tt>.
40   *
41 < * <p>This class is a member of the
41 > * <p>This class is a member of the
42   * <a href="{@docRoot}/../guide/collections/index.html">
43   * Java Collections Framework</a>.
44   *
# Line 63 | Line 64 | public class Collections {
64       * two implementations, one of which is appropriate for RandomAccess
65       * lists, the other for "sequential."  Often, the random access variant
66       * yields better performance on small sequential access lists.  The
67 <     * tuning  parameters below determine the cutoff point for what constitutes
67 >     * tuning parameters below determine the cutoff point for what constitutes
68       * a "small" sequential access list for each algorithm.  The values below
69       * were empirically determined to work well for LinkedList. Hopefully
70       * they should be reasonable for other sequential access List
# Line 97 | Line 98 | public class Collections {
98       * The sorting algorithm is a modified mergesort (in which the merge is
99       * omitted if the highest element in the low sublist is less than the
100       * lowest element in the high sublist).  This algorithm offers guaranteed
101 <     * n log(n) performance.
101 >     * n log(n) performance.
102       *
103       * This implementation dumps the specified list into an array, sorts
104       * the array, and iterates over the list resetting each element
# Line 135 | Line 136 | public class Collections {
136       * The sorting algorithm is a modified mergesort (in which the merge is
137       * omitted if the highest element in the low sublist is less than the
138       * lowest element in the high sublist).  This algorithm offers guaranteed
139 <     * n log(n) performance.
139 >     * n log(n) performance.
140       *
141       * The specified list must be modifiable, but need not be resizable.
142       * This implementation dumps the specified list into an array, sorts
# Line 361 | Line 362 | public class Collections {
362       *
363       * @param  list the list whose elements are to be reversed.
364       * @throws UnsupportedOperationException if the specified list or
365 <     *         its list-iterator does not support the <tt>set</tt> method.
365 >     *         its list-iterator does not support the <tt>set</tt> operation.
366       */
367      public static void reverse(List<?> list) {
368          int size = list.size();
# Line 405 | Line 406 | public class Collections {
406       *
407       * @param  list the list to be shuffled.
408       * @throws UnsupportedOperationException if the specified list or
409 <     *         its list-iterator does not support the <tt>set</tt> method.
409 >     *         its list-iterator does not support the <tt>set</tt> operation.
410       */
411      public static void shuffle(List<?> list) {
412 +        if (r == null) {
413 +            r = new Random();
414 +        }
415          shuffle(list, r);
416      }
417 <    private static Random r = new Random();
417 >    private static Random r;
418  
419      /**
420       * Randomly permute the specified list using the specified source of
# Line 569 | Line 573 | public class Collections {
573          Iterator<? extends T> i = coll.iterator();
574          T candidate = i.next();
575  
576 <        while(i.hasNext()) {
576 >        while (i.hasNext()) {
577              T next = i.next();
578              if (next.compareTo(candidate) < 0)
579                  candidate = next;
# Line 606 | Line 610 | public class Collections {
610          Iterator<? extends T> i = coll.iterator();
611          T candidate = i.next();
612  
613 <        while(i.hasNext()) {
613 >        while (i.hasNext()) {
614              T next = i.next();
615              if (comp.compare(next, candidate) < 0)
616                  candidate = next;
# Line 639 | Line 643 | public class Collections {
643          Iterator<? extends T> i = coll.iterator();
644          T candidate = i.next();
645  
646 <        while(i.hasNext()) {
646 >        while (i.hasNext()) {
647              T next = i.next();
648              if (next.compareTo(candidate) > 0)
649                  candidate = next;
# Line 676 | Line 680 | public class Collections {
680          Iterator<? extends T> i = coll.iterator();
681          T candidate = i.next();
682  
683 <        while(i.hasNext()) {
683 >        while (i.hasNext()) {
684              T next = i.next();
685              if (comp.compare(next, candidate) > 0)
686                  candidate = next;
# Line 712 | Line 716 | public class Collections {
716       *     Collections.rotate(l.subList(1, 4), -1);
717       * </pre>
718       * The resulting list is <tt>[a, c, d, b, e]</tt>.
719 <     *
719 >     *
720       * <p>To move more than one element forward, increase the absolute value
721       * of the rotation distance.  To move elements backward, use a positive
722       * shift distance.
# Line 736 | Line 740 | public class Collections {
740       *        constraints on this value; it may be zero, negative, or
741       *        greater than <tt>list.size()</tt>.
742       * @throws UnsupportedOperationException if the specified list or
743 <     *         its list-iterator does not support the <tt>set</tt> method.
743 >     *         its list-iterator does not support the <tt>set</tt> operation.
744       * @since 1.4
745       */
746      public static void rotate(List<?> list, int distance) {
# Line 772 | Line 776 | public class Collections {
776      private static void rotate2(List<?> list, int distance) {
777          int size = list.size();
778          if (size == 0)
779 <            return;
779 >            return;
780          int mid =  -distance % size;
781          if (mid < 0)
782              mid += size;
# Line 799 | Line 803 | public class Collections {
803       *         <tt>e</tt> such that
804       *         <tt>(oldVal==null ?  e==null : oldVal.equals(e))</tt>.
805       * @throws UnsupportedOperationException if the specified list or
806 <     *         its list-iterator does not support the <tt>set</tt> method.
806 >     *         its list-iterator does not support the <tt>set</tt> operation.
807       * @since  1.4
808       */
809      public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) {
# Line 970 | Line 974 | public class Collections {
974       * that the backing collection is a set or a list.<p>
975       *
976       * The returned collection will be serializable if the specified collection
977 <     * is serializable.
977 >     * is serializable.
978       *
979       * @param  c the collection for which an unmodifiable view is to be
980       *         returned.
# Line 1014 | Line 1018 | public class Collections {
1018              };
1019          }
1020  
1021 <        public boolean add(E o){
1021 >        public boolean add(E e){
1022              throw new UnsupportedOperationException();
1023          }
1024          public boolean remove(Object o) {
# Line 1046 | Line 1050 | public class Collections {
1050       * iterator, result in an <tt>UnsupportedOperationException</tt>.<p>
1051       *
1052       * The returned set will be serializable if the specified set
1053 <     * is serializable.
1053 >     * is serializable.
1054       *
1055       * @param  s the set for which an unmodifiable view is to be returned.
1056       * @return an unmodifiable view of the specified set.
1057       */
1054 –
1058      public static <T> Set<T> unmodifiableSet(Set<? extends T> s) {
1059          return new UnmodifiableSet<T>(s);
1060      }
# Line 1078 | Line 1081 | public class Collections {
1081       * an <tt>UnsupportedOperationException</tt>.<p>
1082       *
1083       * The returned sorted set will be serializable if the specified sorted set
1084 <     * is serializable.
1084 >     * is serializable.
1085       *
1086       * @param s the sorted set for which an unmodifiable view is to be
1087 <     *        returned.
1087 >     *        returned.
1088       * @return an unmodifiable view of the specified sorted set.
1089       */
1090      public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s) {
# Line 1183 | Line 1186 | public class Collections {
1186                  public void remove() {
1187                      throw new UnsupportedOperationException();
1188                  }
1189 <                public void set(E o) {
1189 >                public void set(E e) {
1190                      throw new UnsupportedOperationException();
1191                  }
1192 <                public void add(E o) {
1192 >                public void add(E e) {
1193                      throw new UnsupportedOperationException();
1194                  }
1195              };
# Line 1252 | Line 1255 | public class Collections {
1255       * <tt>UnsupportedOperationException</tt>.<p>
1256       *
1257       * The returned map will be serializable if the specified map
1258 <     * is serializable.
1258 >     * is serializable.
1259       *
1260       * @param  m the map for which an unmodifiable view is to be returned.
1261       * @return an unmodifiable view of the specified map.
# Line 1288 | Line 1291 | public class Collections {
1291          public V remove(Object key) {
1292              throw new UnsupportedOperationException();
1293          }
1294 <        public void putAll(Map<? extends K, ? extends V> t) {
1294 >        public void putAll(Map<? extends K, ? extends V> m) {
1295              throw new UnsupportedOperationException();
1296          }
1297          public void clear() {
# Line 1334 | Line 1337 | public class Collections {
1337              private static final long serialVersionUID = 7854390611657943733L;
1338  
1339              UnmodifiableEntrySet(Set<? extends Map.Entry<? extends K, ? extends V>> s) {
1340 <                super((Set<Map.Entry<K,V>>)(Set)s);
1340 >                super((Set)s);
1341              }
1342              public Iterator<Map.Entry<K,V>> iterator() {
1343                  return new Iterator<Map.Entry<K,V>>() {
# Line 1363 | Line 1366 | public class Collections {
1366                  // We don't pass a to c.toArray, to avoid window of
1367                  // vulnerability wherein an unscrupulous multithreaded client
1368                  // could get his hands on raw (unwrapped) Entries from c.
1369 <                Object[] arr =
1367 <                    c.toArray(
1368 <                        a.length==0 ? a :
1369 <                        (T[])java.lang.reflect.Array.newInstance(a.getClass().getComponentType(), 0));
1369 >                Object[] arr = c.toArray(a.length==0 ? a : Arrays.copyOf(a, 0));
1370  
1371                  for (int i=0; i<arr.length; i++)
1372                      arr[i] = new UnmodifiableEntry<K,V>((Map.Entry<K,V>)arr[i]);
# Line 1456 | Line 1456 | public class Collections {
1456       * an <tt>UnsupportedOperationException</tt>.<p>
1457       *
1458       * The returned sorted map will be serializable if the specified sorted map
1459 <     * is serializable.
1459 >     * is serializable.
1460       *
1461       * @param m the sorted map for which an unmodifiable view is to be
1462 <     *        returned.
1462 >     *        returned.
1463       * @return an unmodifiable view of the specified sorted map.
1464       */
1465      public static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K, ? extends V> m) {
# Line 1523 | Line 1523 | public class Collections {
1523       * that the backing collection is a set or a list.<p>
1524       *
1525       * The returned collection will be serializable if the specified collection
1526 <     * is serializable.
1526 >     * is serializable.
1527       *
1528       * @param  c the collection to be "wrapped" in a synchronized collection.
1529       * @return a synchronized view of the specified collection.
# Line 1577 | Line 1577 | public class Collections {
1577              return c.iterator(); // Must be manually synched by user!
1578          }
1579  
1580 <        public boolean add(E o) {
1581 <            synchronized(mutex) {return c.add(o);}
1580 >        public boolean add(E e) {
1581 >            synchronized(mutex) {return c.add(e);}
1582          }
1583          public boolean remove(Object o) {
1584              synchronized(mutex) {return c.remove(o);}
# Line 1673 | Line 1673 | public class Collections {
1673       * sorted set when iterating over it or any of its <tt>subSet</tt>,
1674       * <tt>headSet</tt>, or <tt>tailSet</tt> views.
1675       * <pre>
1676 <     *  SortedSet s = Collections.synchronizedSortedSet(new HashSortedSet());
1676 >     *  SortedSet s = Collections.synchronizedSortedSet(new TreeSet());
1677       *      ...
1678       *  synchronized(s) {
1679       *      Iterator i = s.iterator(); // Must be in the synchronized block
# Line 1683 | Line 1683 | public class Collections {
1683       * </pre>
1684       * or:
1685       * <pre>
1686 <     *  SortedSet s = Collections.synchronizedSortedSet(new HashSortedSet());
1686 >     *  SortedSet s = Collections.synchronizedSortedSet(new TreeSet());
1687       *  SortedSet s2 = s.headSet(foo);
1688       *      ...
1689       *  synchronized(s) {  // Note: s, not s2!!!
# Line 2007 | Line 2007 | public class Collections {
2007          public Set<Map.Entry<K,V>> entrySet() {
2008              synchronized(mutex) {
2009                  if (entrySet==null)
2010 <                    entrySet = new SynchronizedSet<Map.Entry<K,V>>((Set<Map.Entry<K,V>>)m.entrySet(), mutex);
2010 >                    entrySet = new SynchronizedSet<Map.Entry<K,V>>(m.entrySet(), mutex);
2011                  return entrySet;
2012              }
2013          }
# Line 2045 | Line 2045 | public class Collections {
2045       * collections views of any of its <tt>subMap</tt>, <tt>headMap</tt> or
2046       * <tt>tailMap</tt> views.
2047       * <pre>
2048 <     *  SortedMap m = Collections.synchronizedSortedMap(new HashSortedMap());
2048 >     *  SortedMap m = Collections.synchronizedSortedMap(new TreeMap());
2049       *      ...
2050       *  Set s = m.keySet();  // Needn't be in synchronized block
2051       *      ...
# Line 2057 | Line 2057 | public class Collections {
2057       * </pre>
2058       * or:
2059       * <pre>
2060 <     *  SortedMap m = Collections.synchronizedSortedMap(new HashSortedMap());
2060 >     *  SortedMap m = Collections.synchronizedSortedMap(new TreeMap());
2061       *  SortedMap m2 = m.subMap(foo, bar);
2062       *      ...
2063       *  Set s2 = m2.keySet();  // Needn't be in synchronized block
# Line 2191 | Line 2191 | public class Collections {
2191                                                        Class<E> type) {
2192          return new CheckedCollection<E>(c, type);
2193      }
2194 <
2194 >
2195      /**
2196       * @serial include
2197       */
# Line 2221 | Line 2221 | public class Collections {
2221          public Object[] toArray()           { return c.toArray(); }
2222          public <T> T[] toArray(T[] a)       { return c.toArray(a); }
2223          public String toString()            { return c.toString(); }
2224 –        public Iterator<E> iterator()       { return c.iterator(); }
2224          public boolean remove(Object o)     { return c.remove(o); }
2225          public boolean containsAll(Collection<?> coll) {
2226              return c.containsAll(coll);
# Line 2236 | Line 2235 | public class Collections {
2235              c.clear();
2236          }
2237  
2238 <        public boolean add(E o){
2239 <            typeCheck(o);
2240 <            return c.add(o);
2238 >        public Iterator<E> iterator() {
2239 >            return new Iterator<E>() {
2240 >                private final Iterator<E> it = c.iterator();
2241 >                public boolean hasNext() { return it.hasNext(); }
2242 >                public E next()          { return it.next(); }
2243 >                public void remove()     {        it.remove(); }};
2244 >        }
2245 >
2246 >        public boolean add(E e){
2247 >            typeCheck(e);
2248 >            return c.add(e);
2249          }
2250  
2251          public boolean addAll(Collection<? extends E> coll) {
# Line 2246 | Line 2253 | public class Collections {
2253               * Dump coll into an array of the required type.  This serves
2254               * three purposes: it insulates us from concurrent changes in
2255               * the contents of coll, it type-checks all of the elements in
2256 <             * coll, and it provides all-or-nothing semantics(which we
2256 >             * coll, and it provides all-or-nothing semantics (which we
2257               * wouldn't get if we type-checked each element as we added it).
2258               */
2259              E[] a = null;
2260              try {
2261                  a = coll.toArray(zeroLengthElementArray());
2262 <            } catch(ArrayStoreException e) {
2262 >            } catch (ArrayStoreException e) {
2263                  throw new ClassCastException();
2264              }
2265  
# Line 2265 | Line 2272 | public class Collections {
2272          private E[] zeroLengthElementArray = null; // Lazily initialized
2273  
2274          /*
2275 <         * We don't need locking or volatile, because it's OK if we create
2275 >         * We don't need locking or volatile, because it's OK if we create
2276           * several zeroLengthElementArrays, and they're immutable.
2277           */
2278          E[] zeroLengthElementArray() {
# Line 2300 | Line 2307 | public class Collections {
2307      public static <E> Set<E> checkedSet(Set<E> s, Class<E> type) {
2308          return new CheckedSet<E>(s, type);
2309      }
2310 <
2310 >
2311      /**
2312       * @serial include
2313       */
# Line 2436 | Line 2443 | public class Collections {
2443              E[] a = null;
2444              try {
2445                  a = c.toArray(zeroLengthElementArray());
2446 <            } catch(ArrayStoreException e) {
2446 >            } catch (ArrayStoreException e) {
2447                  throw new ClassCastException();
2448              }
2449  
# Line 2456 | Line 2463 | public class Collections {
2463                  public int previousIndex()   { return i.previousIndex(); }
2464                  public void remove()         { i.remove(); }
2465  
2466 <                public void set(E o) {
2467 <                    typeCheck(o);
2468 <                    i.set(o);
2466 >                public void set(E e) {
2467 >                    typeCheck(e);
2468 >                    i.set(e);
2469                  }
2470  
2471 <                public void add(E o) {
2472 <                    typeCheck(o);
2473 <                    i.add(o);
2471 >                public void add(E e) {
2472 >                    typeCheck(e);
2473 >                    i.add(e);
2474                  }
2475              };
2476          }
# Line 2582 | Line 2589 | public class Collections {
2589              K[] keys = null;
2590              try {
2591                  keys = t.keySet().toArray(zeroLengthKeyArray());
2592 <            } catch(ArrayStoreException e) {
2592 >            } catch (ArrayStoreException e) {
2593                  throw new ClassCastException();
2594              }
2595              V[] values = null;
2596              try {
2597                  values = t.values().toArray(zeroLengthValueArray());
2598 <            } catch(ArrayStoreException e) {
2598 >            } catch (ArrayStoreException e) {
2599                  throw new ClassCastException();
2600              }
2601  
# Line 2604 | Line 2611 | public class Collections {
2611          private V[] zeroLengthValueArray = null;
2612  
2613          /*
2614 <         * We don't need locking or volatile, because it's OK if we create
2614 >         * We don't need locking or volatile, because it's OK if we create
2615           * several zeroLengthValueArrays, and they're immutable.
2616           */
2617          private K[] zeroLengthKeyArray() {
# Line 2658 | Line 2665 | public class Collections {
2665                  s.clear();
2666              }
2667  
2668 <            public boolean add(Map.Entry<K, V> o){
2668 >            public boolean add(Map.Entry<K, V> e){
2669                  throw new UnsupportedOperationException();
2670              }
2671              public boolean addAll(Collection<? extends Map.Entry<K, V>> coll) {
# Line 2700 | Line 2707 | public class Collections {
2707                  // We don't pass a to s.toArray, to avoid window of
2708                  // vulnerability wherein an unscrupulous multithreaded client
2709                  // could get his hands on raw (unwrapped) Entries from s.
2710 <                Object[] arr = s.toArray(a.length==0 ? a :
2704 <                   (T[])Array.newInstance(a.getClass().getComponentType(), 0));
2710 >                Object[] arr = s.toArray(a.length==0 ? a : Arrays.copyOf(a, 0));
2711  
2712                  for (int i=0; i<arr.length; i++)
2713                      arr[i] = new CheckedEntry<K,V>((Map.Entry<K,V>)arr[i],
# Line 3060 | Line 3066 | public class Collections {
3066  
3067          final private E element;
3068  
3069 <        SingletonSet(E o) {element = o;}
3069 >        SingletonSet(E e) {element = e;}
3070  
3071          public Iterator<E> iterator() {
3072              return new Iterator<E>() {
# Line 3168 | Line 3174 | public class Collections {
3174  
3175          public Set<Map.Entry<K,V>> entrySet() {
3176              if (entrySet==null)
3177 <                entrySet = singleton((Map.Entry<K,V>)new ImmutableEntry<K,V>(k, v));
3177 >                entrySet = Collections.<Map.Entry<K,V>>singleton(
3178 >                    new SimpleImmutableEntry<K,V>(k, v));
3179              return entrySet;
3180          }
3181  
# Line 3178 | Line 3185 | public class Collections {
3185              return values;
3186          }
3187  
3181 –        private static class ImmutableEntry<K,V>
3182 –            implements Map.Entry<K,V> {
3183 –            final K k;
3184 –            final V v;
3185 –
3186 –            ImmutableEntry(K key, V value) {
3187 –                k = key;
3188 –                v = value;
3189 –            }
3190 –
3191 –            public K getKey()   {return k;}
3192 –
3193 –            public V getValue() {return v;}
3194 –
3195 –            public V setValue(V value) {
3196 –                throw new UnsupportedOperationException();
3197 –            }
3198 –
3199 –            public boolean equals(Object o) {
3200 –                if (!(o instanceof Map.Entry))
3201 –                    return false;
3202 –                Map.Entry e = (Map.Entry)o;
3203 –                return eq(e.getKey(), k) && eq(e.getValue(), v);
3204 –            }
3205 –
3206 –            public int hashCode() {
3207 –                return ((k==null ? 0 : k.hashCode()) ^
3208 –                        (v==null ? 0 : v.hashCode()));
3209 –            }
3210 –
3211 –            public String toString() {
3212 –                return k+"="+v;
3213 –            }
3214 –        }
3188      }
3189  
3190      /**
# Line 3230 | Line 3203 | public class Collections {
3203       * @see    List#addAll(int, Collection)
3204       */
3205      public static <T> List<T> nCopies(int n, T o) {
3206 +        if (n < 0)
3207 +            throw new IllegalArgumentException("List length = " + n);
3208          return new CopiesList<T>(n, o);
3209      }
3210  
# Line 3242 | Line 3217 | public class Collections {
3217      {
3218          static final long serialVersionUID = 2739099268398711800L;
3219  
3220 <        int n;
3221 <        E element;
3220 >        final int n;
3221 >        final E element;
3222  
3223 <        CopiesList(int n, E o) {
3224 <            if (n < 0)
3250 <                throw new IllegalArgumentException("List length = " + n);
3223 >        CopiesList(int n, E e) {
3224 >            assert n >= 0;
3225              this.n = n;
3226 <            element = o;
3226 >            element = e;
3227          }
3228  
3229          public int size() {
# Line 3260 | Line 3234 | public class Collections {
3234              return n != 0 && eq(obj, element);
3235          }
3236  
3237 +        public int indexOf(Object o) {
3238 +            return contains(o) ? 0 : -1;
3239 +        }
3240 +
3241 +        public int lastIndexOf(Object o) {
3242 +            return contains(o) ? n - 1 : -1;
3243 +        }
3244 +
3245          public E get(int index) {
3246 <            if (index<0 || index>=n)
3246 >            if (index < 0 || index >= n)
3247                  throw new IndexOutOfBoundsException("Index: "+index+
3248                                                      ", Size: "+n);
3249              return element;
3250          }
3251 +
3252 +        public Object[] toArray() {
3253 +            final Object[] a = new Object[n];
3254 +            if (element != null)
3255 +                Arrays.fill(a, 0, n, element);
3256 +            return a;
3257 +        }
3258 +
3259 +        public <T> T[] toArray(T[] a) {
3260 +            final int n = this.n;
3261 +            if (a.length < n) {
3262 +                a = (T[])java.lang.reflect.Array
3263 +                    .newInstance(a.getClass().getComponentType(), n);
3264 +                if (element != null)
3265 +                    Arrays.fill(a, 0, n, element);
3266 +            } else {
3267 +                Arrays.fill(a, 0, n, element);
3268 +                if (a.length > n)
3269 +                    a[n] = null;
3270 +            }
3271 +            return a;
3272 +        }
3273 +
3274 +        public List<E> subList(int fromIndex, int toIndex) {
3275 +            if (fromIndex < 0)
3276 +                throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
3277 +            if (toIndex > n)
3278 +                throw new IndexOutOfBoundsException("toIndex = " + toIndex);
3279 +            if (fromIndex > toIndex)
3280 +                throw new IllegalArgumentException("fromIndex(" + fromIndex +
3281 +                                                   ") > toIndex(" + toIndex + ")");
3282 +            return new CopiesList(toIndex - fromIndex, element);
3283 +        }
3284      }
3285  
3286      /**
# Line 3324 | Line 3339 | public class Collections {
3339      public static <T> Comparator<T> reverseOrder(Comparator<T> cmp) {
3340          if (cmp == null)
3341              return new ReverseComparator();  // Unchecked warning!!
3342 <
3342 >
3343          return new ReverseComparator2<T>(cmp);
3344      }
3345 <
3345 >
3346      /**
3347       * @serial include
3348       */
# Line 3335 | Line 3350 | public class Collections {
3350          Serializable
3351      {
3352          private static final long serialVersionUID = 4374092139857L;
3353 <
3353 >
3354          /**
3355           * The comparator specified in the static factory.  This will never
3356           * be null, as the static factory returns a ReverseComparator
# Line 3344 | Line 3359 | public class Collections {
3359           * @serial
3360           */
3361          private Comparator<T> cmp;
3362 <
3362 >
3363          ReverseComparator2(Comparator<T> cmp) {
3364              assert cmp != null;
3365              this.cmp = cmp;
3366          }
3367 <
3367 >
3368          public int compare(T t1, T t2) {
3369              return cmp.compare(t2, t1);
3370          }
# Line 3469 | Line 3484 | public class Collections {
3484              c1 = c2;
3485              c2 = tmp;
3486          }
3487 <
3487 >
3488          for (Object e : c1)
3489              if (c2.contains(e))
3490                  return false;
# Line 3490 | Line 3505 | public class Collections {
3505       * </pre>
3506       *
3507       * @param c the collection into which <tt>elements</tt> are to be inserted
3508 <     * @param a the elements to insert into <tt>c</tt>
3508 >     * @param elements the elements to insert into <tt>c</tt>
3509       * @return <tt>true</tt> if the collection changed as a result of the call
3510       * @throws UnsupportedOperationException if <tt>c</tt> does not support
3511 <     *         the <tt>add</tt> method
3511 >     *         the <tt>add</tt> operation
3512       * @throws NullPointerException if <tt>elements</tt> contains one or more
3513 <     *         null values and <tt>c</tt> does not support null elements, or
3513 >     *         null values and <tt>c</tt> does not permit null elements, or
3514       *         if <tt>c</tt> or <tt>elements</tt> are <tt>null</tt>
3515 <     * @throws IllegalArgumentException if some aspect of a value in
3515 >     * @throws IllegalArgumentException if some property of a value in
3516       *         <tt>elements</tt> prevents it from being added to <tt>c</tt>
3517       * @see Collection#addAll(Collection)
3518       * @since 1.5
3519       */
3520 <    public static <T> boolean addAll(Collection<? super T> c, T... a) {
3520 >    public static <T> boolean addAll(Collection<? super T> c, T... elements) {
3521          boolean result = false;
3522 <        for (T e : a)
3523 <            result |= c.add(e);
3522 >        for (T element : elements)
3523 >            result |= c.add(element);
3524          return result;
3525      }
3526  
# Line 3529 | Line 3544 | public class Collections {
3544       * to this method, and no reference to the map is retained, as illustrated
3545       * in the following code fragment:
3546       * <pre>
3547 <     *    Set&lt;Object&gt; weakHashSet = Collections.asSet(
3547 >     *    Set&lt;Object&gt; weakHashSet = Collections.newSetFromMap(
3548       *        new WeakHashMap&lt;Object, Boolean&gt;());
3549       * </pre>
3550       *
3551       * @param map the backing map
3552       * @return the set backed by the map
3553       * @throws IllegalArgumentException if <tt>map</tt> is not empty
3554 +     * @since 1.6
3555       */
3556 <    public static <E> Set<E> asSet(Map<E, Boolean> map) {
3557 <        return new MapAsSet<E>(map);
3556 >    public static <E> Set<E> newSetFromMap(Map<E, Boolean> map) {
3557 >        return new SetFromMap<E>(map);
3558      }
3559  
3560 <    private static class MapAsSet<E> extends AbstractSet<E>
3560 >    private static class SetFromMap<E> extends AbstractSet<E>
3561          implements Set<E>, Serializable
3562      {
3563          private final Map<E, Boolean> m;  // The backing map
3564          private transient Set<E> keySet;  // Its keySet
3565  
3566 <        MapAsSet(Map<E, Boolean> map) {
3566 >        SetFromMap(Map<E, Boolean> map) {
3567              if (!map.isEmpty())
3568                  throw new IllegalArgumentException("Map is non-empty");
3569              m = map;
# Line 3591 | Line 3607 | public class Collections {
3607       * <tt>remove</tt> is mapped to <tt>pop</tt> and so on. This
3608       * view can be useful when you would like to use a method
3609       * requiring a <tt>Queue</tt> but you need Lifo ordering.
3610 <     * @param deque the Deque
3610 >     *
3611 >     * @param deque the deque
3612       * @return the queue
3613       * @since  1.6
3614       */
# Line 3599 | Line 3616 | public class Collections {
3616          return new AsLIFOQueue<T>(deque);
3617      }
3618  
3619 <    static class AsLIFOQueue<E> extends AbstractQueue<E>
3619 >    static class AsLIFOQueue<E> extends AbstractQueue<E>
3620          implements Queue<E>, Serializable {
3621 +        private static final long serialVersionUID = 1802017725587941708L;
3622          private final Deque<E> q;
3623          AsLIFOQueue(Deque<E> q)            { this.q = q; }
3624 <        public boolean offer(E o)          { return q.offerFirst(o); }
3624 >        public boolean add(E e)            { q.addFirst(e); return true; }
3625 >        public boolean offer(E e)          { return q.offerFirst(e); }
3626          public E poll()                    { return q.pollFirst(); }
3627          public E remove()                  { return q.removeFirst(); }
3628          public E peek()                    { return q.peekFirst(); }
# Line 3614 | Line 3633 | public class Collections {
3633          public Iterator<E> iterator()      { return q.iterator(); }
3634          public Object[] toArray()          { return q.toArray(); }
3635          public <T> T[] toArray(T[] a)      { return q.toArray(a); }
3617 –        public boolean add(E o)            { return q.offerFirst(o); }
3636          public boolean remove(Object o)    { return q.remove(o); }
3637          public void clear()                { q.clear(); }
3638      }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines