| 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; |
| 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 |
| 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 |
| 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; |
| 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; |
| 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; |
| 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; |
| 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 |
|
} |
| 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() { |
| 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]); |
| 2246 |
|
* Dump coll into an array of the required type. This serves |
| 2247 |
|
* three purposes: it insulates us from concurrent changes in |
| 2248 |
|
* the contents of coll, it type-checks all of the elements in |
| 2249 |
< |
* coll, and it provides all-or-nothing semantics(which we |
| 2249 |
> |
* coll, and it provides all-or-nothing semantics (which we |
| 2250 |
|
* wouldn't get if we type-checked each element as we added it). |
| 2251 |
|
*/ |
| 2252 |
|
E[] a = null; |
| 2253 |
|
try { |
| 2254 |
|
a = coll.toArray(zeroLengthElementArray()); |
| 2255 |
< |
} catch(ArrayStoreException e) { |
| 2255 |
> |
} catch (ArrayStoreException e) { |
| 2256 |
|
throw new ClassCastException(); |
| 2257 |
|
} |
| 2258 |
|
|
| 2436 |
|
E[] a = null; |
| 2437 |
|
try { |
| 2438 |
|
a = c.toArray(zeroLengthElementArray()); |
| 2439 |
< |
} catch(ArrayStoreException e) { |
| 2439 |
> |
} catch (ArrayStoreException e) { |
| 2440 |
|
throw new ClassCastException(); |
| 2441 |
|
} |
| 2442 |
|
|
| 2582 |
|
K[] keys = null; |
| 2583 |
|
try { |
| 2584 |
|
keys = t.keySet().toArray(zeroLengthKeyArray()); |
| 2585 |
< |
} catch(ArrayStoreException e) { |
| 2585 |
> |
} catch (ArrayStoreException e) { |
| 2586 |
|
throw new ClassCastException(); |
| 2587 |
|
} |
| 2588 |
|
V[] values = null; |
| 2589 |
|
try { |
| 2590 |
|
values = t.values().toArray(zeroLengthValueArray()); |
| 2591 |
< |
} catch(ArrayStoreException e) { |
| 2591 |
> |
} catch (ArrayStoreException e) { |
| 2592 |
|
throw new ClassCastException(); |
| 2593 |
|
} |
| 2594 |
|
|
| 2700 |
|
// We don't pass a to s.toArray, to avoid window of |
| 2701 |
|
// vulnerability wherein an unscrupulous multithreaded client |
| 2702 |
|
// could get his hands on raw (unwrapped) Entries from s. |
| 2703 |
< |
Object[] arr = s.toArray(a.length==0 ? a : |
| 2704 |
< |
(T[])Array.newInstance(a.getClass().getComponentType(), 0)); |
| 2703 |
> |
Object[] arr = s.toArray(a.length==0 ? a : Arrays.copyOf(a, 0)); |
| 2704 |
|
|
| 2705 |
|
for (int i=0; i<arr.length; i++) |
| 2706 |
|
arr[i] = new CheckedEntry<K,V>((Map.Entry<K,V>)arr[i], |
| 3461 |
|
* @throws UnsupportedOperationException if <tt>c</tt> does not support |
| 3462 |
|
* the <tt>add</tt> operation. |
| 3463 |
|
* @throws NullPointerException if <tt>elements</tt> contains one or more |
| 3464 |
< |
* null values and <tt>c</tt> does not support null elements, or |
| 3464 |
> |
* null values and <tt>c</tt> does not permit null elements, or |
| 3465 |
|
* if <tt>c</tt> or <tt>elements</tt> are <tt>null</tt> |
| 3466 |
< |
* @throws IllegalArgumentException if some aspect of a value in |
| 3466 |
> |
* @throws IllegalArgumentException if some property of a value in |
| 3467 |
|
* <tt>elements</tt> prevents it from being added to <tt>c</tt> |
| 3468 |
|
* @see Collection#addAll(Collection) |
| 3469 |
|
* @since 1.5 |
| 3502 |
|
* @param map the backing map |
| 3503 |
|
* @return the set backed by the map |
| 3504 |
|
* @throws IllegalArgumentException if <tt>map</tt> is not empty |
| 3505 |
+ |
* @since 1.6 |
| 3506 |
|
*/ |
| 3507 |
|
public static <E> Set<E> asSet(Map<E, Boolean> map) { |
| 3508 |
|
return new MapAsSet<E>(map); |
| 3558 |
|
* <tt>remove</tt> is mapped to <tt>pop</tt> and so on. This |
| 3559 |
|
* view can be useful when you would like to use a method |
| 3560 |
|
* requiring a <tt>Queue</tt> but you need Lifo ordering. |
| 3561 |
< |
* @param deque the Deque |
| 3561 |
> |
* @param deque the deque |
| 3562 |
|
* @return the queue |
| 3563 |
|
* @since 1.6 |
| 3564 |
|
*/ |
| 3568 |
|
|
| 3569 |
|
static class AsLIFOQueue<E> extends AbstractQueue<E> |
| 3570 |
|
implements Queue<E>, Serializable { |
| 3571 |
+ |
private static final long serialVersionUID = 1802017725587941708L; |
| 3572 |
|
private final Deque<E> q; |
| 3573 |
|
AsLIFOQueue(Deque<E> q) { this.q = q; } |
| 3574 |
|
public boolean offer(E e) { return q.offerFirst(e); } |
