/openjdk forked from unofficial-openjdk/openjdk

Permalink
openjdk/jdk/src/share/classes/java/util/Collections.java
Newer
Older
Raw Normal view History
100644 5565 lines (4989 sloc) 212 KB
duke
Initial load
Dec 1, 2007
1
/*
psandoz
8030848: Collections.sort(List l, Comparator) should defer to List.so…
Jan 24, 2014
2
* Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
duke
Initial load
Dec 1, 2007
3
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
*
5
* This code is free software; you can redistribute it and/or modify it
6
* under the terms of the GNU General Public License version 2 only, as
ohair
6943119: Rebrand source copyright notices
May 25, 2010
7
* published by the Free Software Foundation. Oracle designates this
duke
Initial load
Dec 1, 2007
8
* particular file as subject to the "Classpath" exception as provided
ohair
6943119: Rebrand source copyright notices
May 25, 2010
9
* by Oracle in the LICENSE file that accompanied this code.
duke
Initial load
Dec 1, 2007
10
*
11
* This code is distributed in the hope that it will be useful, but WITHOUT
12
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14
* version 2 for more details (a copy is included in the LICENSE file that
15
* accompanied this code).
16
*
17
* You should have received a copy of the GNU General Public License version
18
* 2 along with this work; if not, write to the Free Software Foundation,
19
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20
*
ohair
6943119: Rebrand source copyright notices
May 25, 2010
21
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22
* or visit www.oracle.com if you need additional information or have any
23
* questions.
duke
Initial load
Dec 1, 2007
24
*/
25
26
package java.util;
27
import java.io.Serializable;
28
import java.io.ObjectOutputStream;
29
import java.io.IOException;
30
import java.lang.reflect.Array;
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
31
import java.util.function.BiConsumer;
32
import java.util.function.BiFunction;
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
33
import java.util.function.Consumer;
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
34
import java.util.function.Function;
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
35
import java.util.function.Predicate;
36
import java.util.function.UnaryOperator;
henryjen
8023275: Wrapping collections should override default methods
Aug 27, 2013
37
import java.util.stream.IntStream;
psandoz
8017447: Unmodifiable map entry becomes modifiable if taken from a st…
Jul 10, 2013
38
import java.util.stream.Stream;
39
import java.util.stream.StreamSupport;
duke
Initial load
Dec 1, 2007
40
41
/**
42
* This class consists exclusively of static methods that operate on or return
43
* collections. It contains polymorphic algorithms that operate on
44
* collections, "wrappers", which return a new collection backed by a
45
* specified collection, and a few other odds and ends.
46
*
47
* <p>The methods of this class all throw a <tt>NullPointerException</tt>
48
* if the collections or class objects provided to them are null.
49
*
50
* <p>The documentation for the polymorphic algorithms contained in this class
51
* generally includes a brief description of the <i>implementation</i>. Such
52
* descriptions should be regarded as <i>implementation notes</i>, rather than
53
* parts of the <i>specification</i>. Implementors should feel free to
54
* substitute other algorithms, so long as the specification itself is adhered
55
* to. (For example, the algorithm used by <tt>sort</tt> does not have to be
56
* a mergesort, but it does have to be <i>stable</i>.)
57
*
58
* <p>The "destructive" algorithms contained in this class, that is, the
59
* algorithms that modify the collection on which they operate, are specified
60
* to throw <tt>UnsupportedOperationException</tt> if the collection does not
61
* support the appropriate mutation primitive(s), such as the <tt>set</tt>
62
* method. These algorithms may, but are not required to, throw this
63
* exception if an invocation would have no effect on the collection. For
64
* example, invoking the <tt>sort</tt> method on an unmodifiable list that is
65
* already sorted may or may not throw <tt>UnsupportedOperationException</tt>.
66
*
67
* <p>This class is a member of the
68
* <a href="{@docRoot}/../technotes/guides/collections/index.html">
69
* Java Collections Framework</a>.
70
*
71
* @author Josh Bloch
72
* @author Neal Gafter
73
* @see Collection
74
* @see Set
75
* @see List
76
* @see Map
77
* @since 1.2
78
*/
79
80
public class Collections {
81
// Suppresses default constructor, ensuring non-instantiability.
82
private Collections() {
83
}
84
85
// Algorithms
86
87
/*
88
* Tuning parameters for algorithms - Many of the List algorithms have
89
* two implementations, one of which is appropriate for RandomAccess
90
* lists, the other for "sequential." Often, the random access variant
91
* yields better performance on small sequential access lists. The
92
* tuning parameters below determine the cutoff point for what constitutes
93
* a "small" sequential access list for each algorithm. The values below
94
* were empirically determined to work well for LinkedList. Hopefully
95
* they should be reasonable for other sequential access List
96
* implementations. Those doing performance work on this code would
97
* do well to validate the values of these parameters from time to time.
98
* (The first word of each tuning parameter name is the algorithm to which
99
* it applies.)
100
*/
101
private static final int BINARYSEARCH_THRESHOLD = 5000;
102
private static final int REVERSE_THRESHOLD = 18;
103
private static final int SHUFFLE_THRESHOLD = 5;
104
private static final int FILL_THRESHOLD = 25;
105
private static final int ROTATE_THRESHOLD = 100;
106
private static final int COPY_THRESHOLD = 10;
107
private static final int REPLACEALL_THRESHOLD = 11;
108
private static final int INDEXOFSUBLIST_THRESHOLD = 35;
109
110
/**
111
* Sorts the specified list into ascending order, according to the
jjb
6804124: Replace "modified mergesort" in java.util.Arrays.sort with t…
Jul 29, 2009
112
* {@linkplain Comparable natural ordering} of its elements.
113
* All elements in the list must implement the {@link Comparable}
114
* interface. Furthermore, all elements in the list must be
115
* <i>mutually comparable</i> (that is, {@code e1.compareTo(e2)}
116
* must not throw a {@code ClassCastException} for any elements
117
* {@code e1} and {@code e2} in the list).
duke
Initial load
Dec 1, 2007
118
*
jjb
6804124: Replace "modified mergesort" in java.util.Arrays.sort with t…
Jul 29, 2009
119
* <p>This sort is guaranteed to be <i>stable</i>: equal elements will
120
* not be reordered as a result of the sort.
duke
Initial load
Dec 1, 2007
121
*
jjb
6804124: Replace "modified mergesort" in java.util.Arrays.sort with t…
Jul 29, 2009
122
* <p>The specified list must be modifiable, but need not be resizable.
duke
Initial load
Dec 1, 2007
123
*
psandoz
8030848: Collections.sort(List l, Comparator) should defer to List.so…
Jan 24, 2014
124
* @implNote
125
* This implementation defers to the {@link List#sort(Comparator)}
126
* method using the specified list and a {@code null} comparator.
duke
Initial load
Dec 1, 2007
127
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
128
* @param <T> the class of the objects in the list
duke
Initial load
Dec 1, 2007
129
* @param list the list to be sorted.
130
* @throws ClassCastException if the list contains elements that are not
131
* <i>mutually comparable</i> (for example, strings and integers).
132
* @throws UnsupportedOperationException if the specified list's
jjb
6804124: Replace "modified mergesort" in java.util.Arrays.sort with t…
Jul 29, 2009
133
* list-iterator does not support the {@code set} operation.
134
* @throws IllegalArgumentException (optional) if the implementation
135
* detects that the natural ordering of the list elements is
136
* found to violate the {@link Comparable} contract
psandoz
8030848: Collections.sort(List l, Comparator) should defer to List.so…
Jan 24, 2014
137
* @see List#sort(Comparator)
duke
Initial load
Dec 1, 2007
138
*/
khazra
7157893: Warnings Cleanup in java.util.*
Apr 17, 2012
139
@SuppressWarnings("unchecked")
duke
Initial load
Dec 1, 2007
140
public static <T extends Comparable<? super T>> void sort(List<T> list) {
psandoz
8030848: Collections.sort(List l, Comparator) should defer to List.so…
Jan 24, 2014
141
list.sort(null);
duke
Initial load
Dec 1, 2007
142
}
143
144
/**
145
* Sorts the specified list according to the order induced by the
146
* specified comparator. All elements in the list must be <i>mutually
147
* comparable</i> using the specified comparator (that is,
jjb
6804124: Replace "modified mergesort" in java.util.Arrays.sort with t…
Jul 29, 2009
148
* {@code c.compare(e1, e2)} must not throw a {@code ClassCastException}
149
* for any elements {@code e1} and {@code e2} in the list).
150
*
151
* <p>This sort is guaranteed to be <i>stable</i>: equal elements will
152
* not be reordered as a result of the sort.
153
*
154
* <p>The specified list must be modifiable, but need not be resizable.
155
*
psandoz
8030848: Collections.sort(List l, Comparator) should defer to List.so…
Jan 24, 2014
156
* @implNote
157
* This implementation defers to the {@link List#sort(Comparator)}
158
* method using the specified list and comparator.
duke
Initial load
Dec 1, 2007
159
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
160
* @param <T> the class of the objects in the list
duke
Initial load
Dec 1, 2007
161
* @param list the list to be sorted.
162
* @param c the comparator to determine the order of the list. A
jjb
6804124: Replace "modified mergesort" in java.util.Arrays.sort with t…
Jul 29, 2009
163
* {@code null} value indicates that the elements' <i>natural
duke
Initial load
Dec 1, 2007
164
* ordering</i> should be used.
165
* @throws ClassCastException if the list contains elements that are not
166
* <i>mutually comparable</i> using the specified comparator.
167
* @throws UnsupportedOperationException if the specified list's
jjb
6804124: Replace "modified mergesort" in java.util.Arrays.sort with t…
Jul 29, 2009
168
* list-iterator does not support the {@code set} operation.
169
* @throws IllegalArgumentException (optional) if the comparator is
170
* found to violate the {@link Comparator} contract
psandoz
8030848: Collections.sort(List l, Comparator) should defer to List.so…
Jan 24, 2014
171
* @see List#sort(Comparator)
duke
Initial load
Dec 1, 2007
172
*/
dxu
7193406: Clean-up JDK Build Warnings in java.util, java.io
Aug 31, 2012
173
@SuppressWarnings({"unchecked", "rawtypes"})
duke
Initial load
Dec 1, 2007
174
public static <T> void sort(List<T> list, Comparator<? super T> c) {
psandoz
8030848: Collections.sort(List l, Comparator) should defer to List.so…
Jan 24, 2014
175
list.sort(c);
duke
Initial load
Dec 1, 2007
176
}
177
178
179
/**
180
* Searches the specified list for the specified object using the binary
181
* search algorithm. The list must be sorted into ascending order
182
* according to the {@linkplain Comparable natural ordering} of its
183
* elements (as by the {@link #sort(List)} method) prior to making this
184
* call. If it is not sorted, the results are undefined. If the list
185
* contains multiple elements equal to the specified object, there is no
186
* guarantee which one will be found.
187
*
188
* <p>This method runs in log(n) time for a "random access" list (which
189
* provides near-constant-time positional access). If the specified list
190
* does not implement the {@link RandomAccess} interface and is large,
191
* this method will do an iterator-based binary search that performs
192
* O(n) link traversals and O(log n) element comparisons.
193
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
194
* @param <T> the class of the objects in the list
duke
Initial load
Dec 1, 2007
195
* @param list the list to be searched.
196
* @param key the key to be searched for.
197
* @return the index of the search key, if it is contained in the list;
198
* otherwise, <tt>(-(<i>insertion point</i>) - 1)</tt>. The
199
* <i>insertion point</i> is defined as the point at which the
200
* key would be inserted into the list: the index of the first
201
* element greater than the key, or <tt>list.size()</tt> if all
202
* elements in the list are less than the specified key. Note
203
* that this guarantees that the return value will be &gt;= 0 if
204
* and only if the key is found.
205
* @throws ClassCastException if the list contains elements that are not
206
* <i>mutually comparable</i> (for example, strings and
207
* integers), or the search key is not mutually comparable
208
* with the elements of the list.
209
*/
210
public static <T>
211
int binarySearch(List<? extends Comparable<? super T>> list, T key) {
212
if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
213
return Collections.indexedBinarySearch(list, key);
214
else
215
return Collections.iteratorBinarySearch(list, key);
216
}
217
218
private static <T>
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
219
int indexedBinarySearch(List<? extends Comparable<? super T>> list, T key) {
duke
Initial load
Dec 1, 2007
220
int low = 0;
221
int high = list.size()-1;
222
223
while (low <= high) {
224
int mid = (low + high) >>> 1;
225
Comparable<? super T> midVal = list.get(mid);
226
int cmp = midVal.compareTo(key);
227
228
if (cmp < 0)
229
low = mid + 1;
230
else if (cmp > 0)
231
high = mid - 1;
232
else
233
return mid; // key found
234
}
235
return -(low + 1); // key not found
236
}
237
238
private static <T>
239
int iteratorBinarySearch(List<? extends Comparable<? super T>> list, T key)
240
{
241
int low = 0;
242
int high = list.size()-1;
243
ListIterator<? extends Comparable<? super T>> i = list.listIterator();
244
245
while (low <= high) {
246
int mid = (low + high) >>> 1;
247
Comparable<? super T> midVal = get(i, mid);
248
int cmp = midVal.compareTo(key);
249
250
if (cmp < 0)
251
low = mid + 1;
252
else if (cmp > 0)
253
high = mid - 1;
254
else
255
return mid; // key found
256
}
257
return -(low + 1); // key not found
258
}
259
260
/**
261
* Gets the ith element from the given list by repositioning the specified
262
* list listIterator.
263
*/
264
private static <T> T get(ListIterator<? extends T> i, int index) {
265
T obj = null;
266
int pos = i.nextIndex();
267
if (pos <= index) {
268
do {
269
obj = i.next();
270
} while (pos++ < index);
271
} else {
272
do {
273
obj = i.previous();
274
} while (--pos > index);
275
}
276
return obj;
277
}
278
279
/**
280
* Searches the specified list for the specified object using the binary
281
* search algorithm. The list must be sorted into ascending order
282
* according to the specified comparator (as by the
283
* {@link #sort(List, Comparator) sort(List, Comparator)}
284
* method), prior to making this call. If it is
285
* not sorted, the results are undefined. If the list contains multiple
286
* elements equal to the specified object, there is no guarantee which one
287
* will be found.
288
*
289
* <p>This method runs in log(n) time for a "random access" list (which
290
* provides near-constant-time positional access). If the specified list
291
* does not implement the {@link RandomAccess} interface and is large,
292
* this method will do an iterator-based binary search that performs
293
* O(n) link traversals and O(log n) element comparisons.
294
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
295
* @param <T> the class of the objects in the list
duke
Initial load
Dec 1, 2007
296
* @param list the list to be searched.
297
* @param key the key to be searched for.
298
* @param c the comparator by which the list is ordered.
299
* A <tt>null</tt> value indicates that the elements'
300
* {@linkplain Comparable natural ordering} should be used.
301
* @return the index of the search key, if it is contained in the list;
302
* otherwise, <tt>(-(<i>insertion point</i>) - 1)</tt>. The
303
* <i>insertion point</i> is defined as the point at which the
304
* key would be inserted into the list: the index of the first
305
* element greater than the key, or <tt>list.size()</tt> if all
306
* elements in the list are less than the specified key. Note
307
* that this guarantees that the return value will be &gt;= 0 if
308
* and only if the key is found.
309
* @throws ClassCastException if the list contains elements that are not
310
* <i>mutually comparable</i> using the specified comparator,
311
* or the search key is not mutually comparable with the
312
* elements of the list using this comparator.
313
*/
khazra
7157893: Warnings Cleanup in java.util.*
Apr 17, 2012
314
@SuppressWarnings("unchecked")
duke
Initial load
Dec 1, 2007
315
public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) {
316
if (c==null)
khazra
7157893: Warnings Cleanup in java.util.*
Apr 17, 2012
317
return binarySearch((List<? extends Comparable<? super T>>) list, key);
duke
Initial load
Dec 1, 2007
318
319
if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
320
return Collections.indexedBinarySearch(list, key, c);
321
else
322
return Collections.iteratorBinarySearch(list, key, c);
323
}
324
325
private static <T> int indexedBinarySearch(List<? extends T> l, T key, Comparator<? super T> c) {
326
int low = 0;
327
int high = l.size()-1;
328
329
while (low <= high) {
330
int mid = (low + high) >>> 1;
331
T midVal = l.get(mid);
332
int cmp = c.compare(midVal, key);
333
334
if (cmp < 0)
335
low = mid + 1;
336
else if (cmp > 0)
337
high = mid - 1;
338
else
339
return mid; // key found
340
}
341
return -(low + 1); // key not found
342
}
343
344
private static <T> int iteratorBinarySearch(List<? extends T> l, T key, Comparator<? super T> c) {
345
int low = 0;
346
int high = l.size()-1;
347
ListIterator<? extends T> i = l.listIterator();
348
349
while (low <= high) {
350
int mid = (low + high) >>> 1;
351
T midVal = get(i, mid);
352
int cmp = c.compare(midVal, key);
353
354
if (cmp < 0)
355
low = mid + 1;
356
else if (cmp > 0)
357
high = mid - 1;
358
else
359
return mid; // key found
360
}
361
return -(low + 1); // key not found
362
}
363
364
/**
365
* Reverses the order of the elements in the specified list.<p>
366
*
367
* This method runs in linear time.
368
*
369
* @param list the list whose elements are to be reversed.
370
* @throws UnsupportedOperationException if the specified list or
371
* its list-iterator does not support the <tt>set</tt> operation.
372
*/
dxu
7193406: Clean-up JDK Build Warnings in java.util, java.io
Aug 31, 2012
373
@SuppressWarnings({"rawtypes", "unchecked"})
duke
Initial load
Dec 1, 2007
374
public static void reverse(List<?> list) {
375
int size = list.size();
376
if (size < REVERSE_THRESHOLD || list instanceof RandomAccess) {
377
for (int i=0, mid=size>>1, j=size-1; i<mid; i++, j--)
378
swap(list, i, j);
379
} else {
khazra
7157893: Warnings Cleanup in java.util.*
Apr 17, 2012
380
// instead of using a raw type here, it's possible to capture
381
// the wildcard but it will require a call to a supplementary
382
// private method
duke
Initial load
Dec 1, 2007
383
ListIterator fwd = list.listIterator();
384
ListIterator rev = list.listIterator(size);
385
for (int i=0, mid=list.size()>>1; i<mid; i++) {
386
Object tmp = fwd.next();
387
fwd.set(rev.previous());
388
rev.set(tmp);
389
}
390
}
391
}
392
393
/**
394
* Randomly permutes the specified list using a default source of
395
* randomness. All permutations occur with approximately equal
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
396
* likelihood.
duke
Initial load
Dec 1, 2007
397
*
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
398
* <p>The hedge "approximately" is used in the foregoing description because
duke
Initial load
Dec 1, 2007
399
* default source of randomness is only approximately an unbiased source
400
* of independently chosen bits. If it were a perfect source of randomly
401
* chosen bits, then the algorithm would choose permutations with perfect
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
402
* uniformity.
duke
Initial load
Dec 1, 2007
403
*
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
404
* <p>This implementation traverses the list backwards, from the last
405
* element up to the second, repeatedly swapping a randomly selected element
406
* into the "current position". Elements are randomly selected from the
duke
Initial load
Dec 1, 2007
407
* portion of the list that runs from the first element to the current
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
408
* position, inclusive.
duke
Initial load
Dec 1, 2007
409
*
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
410
* <p>This method runs in linear time. If the specified list does not
duke
Initial load
Dec 1, 2007
411
* implement the {@link RandomAccess} interface and is large, this
412
* implementation dumps the specified list into an array before shuffling
413
* it, and dumps the shuffled array back into the list. This avoids the
414
* quadratic behavior that would result from shuffling a "sequential
415
* access" list in place.
416
*
417
* @param list the list to be shuffled.
418
* @throws UnsupportedOperationException if the specified list or
419
* its list-iterator does not support the <tt>set</tt> operation.
420
*/
421
public static void shuffle(List<?> list) {
martin
6959259: Minor improvements to static Random field caching
Jun 10, 2010
422
Random rnd = r;
423
if (rnd == null)
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
424
r = rnd = new Random(); // harmless race.
martin
6959259: Minor improvements to static Random field caching
Jun 10, 2010
425
shuffle(list, rnd);
duke
Initial load
Dec 1, 2007
426
}
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
427
duke
Initial load
Dec 1, 2007
428
private static Random r;
429
430
/**
431
* Randomly permute the specified list using the specified source of
432
* randomness. All permutations occur with equal likelihood
433
* assuming that the source of randomness is fair.<p>
434
*
435
* This implementation traverses the list backwards, from the last element
436
* up to the second, repeatedly swapping a randomly selected element into
437
* the "current position". Elements are randomly selected from the
438
* portion of the list that runs from the first element to the current
439
* position, inclusive.<p>
440
*
441
* This method runs in linear time. If the specified list does not
442
* implement the {@link RandomAccess} interface and is large, this
443
* implementation dumps the specified list into an array before shuffling
444
* it, and dumps the shuffled array back into the list. This avoids the
445
* quadratic behavior that would result from shuffling a "sequential
446
* access" list in place.
447
*
448
* @param list the list to be shuffled.
449
* @param rnd the source of randomness to use to shuffle the list.
450
* @throws UnsupportedOperationException if the specified list or its
451
* list-iterator does not support the <tt>set</tt> operation.
452
*/
dxu
7193406: Clean-up JDK Build Warnings in java.util, java.io
Aug 31, 2012
453
@SuppressWarnings({"rawtypes", "unchecked"})
duke
Initial load
Dec 1, 2007
454
public static void shuffle(List<?> list, Random rnd) {
455
int size = list.size();
456
if (size < SHUFFLE_THRESHOLD || list instanceof RandomAccess) {
457
for (int i=size; i>1; i--)
458
swap(list, i-1, rnd.nextInt(i));
459
} else {
460
Object arr[] = list.toArray();
461
462
// Shuffle array
463
for (int i=size; i>1; i--)
464
swap(arr, i-1, rnd.nextInt(i));
465
466
// Dump array back into list
khazra
7157893: Warnings Cleanup in java.util.*
Apr 17, 2012
467
// instead of using a raw type here, it's possible to capture
468
// the wildcard but it will require a call to a supplementary
469
// private method
duke
Initial load
Dec 1, 2007
470
ListIterator it = list.listIterator();
471
for (int i=0; i<arr.length; i++) {
472
it.next();
473
it.set(arr[i]);
474
}
475
}
476
}
477
478
/**
479
* Swaps the elements at the specified positions in the specified list.
480
* (If the specified positions are equal, invoking this method leaves
481
* the list unchanged.)
482
*
483
* @param list The list in which to swap elements.
484
* @param i the index of one element to be swapped.
485
* @param j the index of the other element to be swapped.
486
* @throws IndexOutOfBoundsException if either <tt>i</tt> or <tt>j</tt>
487
* is out of range (i &lt; 0 || i &gt;= list.size()
488
* || j &lt; 0 || j &gt;= list.size()).
489
* @since 1.4
490
*/
dxu
7193406: Clean-up JDK Build Warnings in java.util, java.io
Aug 31, 2012
491
@SuppressWarnings({"rawtypes", "unchecked"})
duke
Initial load
Dec 1, 2007
492
public static void swap(List<?> list, int i, int j) {
khazra
7157893: Warnings Cleanup in java.util.*
Apr 17, 2012
493
// instead of using a raw type here, it's possible to capture
494
// the wildcard but it will require a call to a supplementary
495
// private method
duke
Initial load
Dec 1, 2007
496
final List l = list;
497
l.set(i, l.set(j, l.get(i)));
498
}
499
500
/**
501
* Swaps the two specified elements in the specified array.
502
*/
503
private static void swap(Object[] arr, int i, int j) {
504
Object tmp = arr[i];
505
arr[i] = arr[j];
506
arr[j] = tmp;
507
}
508
509
/**
510
* Replaces all of the elements of the specified list with the specified
511
* element. <p>
512
*
513
* This method runs in linear time.
514
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
515
* @param <T> the class of the objects in the list
duke
Initial load
Dec 1, 2007
516
* @param list the list to be filled with the specified element.
517
* @param obj The element with which to fill the specified list.
518
* @throws UnsupportedOperationException if the specified list or its
519
* list-iterator does not support the <tt>set</tt> operation.
520
*/
521
public static <T> void fill(List<? super T> list, T obj) {
522
int size = list.size();
523
524
if (size < FILL_THRESHOLD || list instanceof RandomAccess) {
525
for (int i=0; i<size; i++)
526
list.set(i, obj);
527
} else {
528
ListIterator<? super T> itr = list.listIterator();
529
for (int i=0; i<size; i++) {
530
itr.next();
531
itr.set(obj);
532
}
533
}
534
}
535
536
/**
537
* Copies all of the elements from one list into another. After the
538
* operation, the index of each copied element in the destination list
539
* will be identical to its index in the source list. The destination
540
* list must be at least as long as the source list. If it is longer, the
541
* remaining elements in the destination list are unaffected. <p>
542
*
543
* This method runs in linear time.
544
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
545
* @param <T> the class of the objects in the lists
duke
Initial load
Dec 1, 2007
546
* @param dest The destination list.
547
* @param src The source list.
548
* @throws IndexOutOfBoundsException if the destination list is too small
549
* to contain the entire source List.
550
* @throws UnsupportedOperationException if the destination list's
551
* list-iterator does not support the <tt>set</tt> operation.
552
*/
553
public static <T> void copy(List<? super T> dest, List<? extends T> src) {
554
int srcSize = src.size();
555
if (srcSize > dest.size())
556
throw new IndexOutOfBoundsException("Source does not fit in dest");
557
558
if (srcSize < COPY_THRESHOLD ||
559
(src instanceof RandomAccess && dest instanceof RandomAccess)) {
560
for (int i=0; i<srcSize; i++)
561
dest.set(i, src.get(i));
562
} else {
563
ListIterator<? super T> di=dest.listIterator();
564
ListIterator<? extends T> si=src.listIterator();
565
for (int i=0; i<srcSize; i++) {
566
di.next();
567
di.set(si.next());
568
}
569
}
570
}
571
572
/**
573
* Returns the minimum element of the given collection, according to the
574
* <i>natural ordering</i> of its elements. All elements in the
575
* collection must implement the <tt>Comparable</tt> interface.
576
* Furthermore, all elements in the collection must be <i>mutually
577
* comparable</i> (that is, <tt>e1.compareTo(e2)</tt> must not throw a
578
* <tt>ClassCastException</tt> for any elements <tt>e1</tt> and
579
* <tt>e2</tt> in the collection).<p>
580
*
581
* This method iterates over the entire collection, hence it requires
582
* time proportional to the size of the collection.
583
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
584
* @param <T> the class of the objects in the collection
duke
Initial load
Dec 1, 2007
585
* @param coll the collection whose minimum element is to be determined.
586
* @return the minimum element of the given collection, according
587
* to the <i>natural ordering</i> of its elements.
588
* @throws ClassCastException if the collection contains elements that are
589
* not <i>mutually comparable</i> (for example, strings and
590
* integers).
591
* @throws NoSuchElementException if the collection is empty.
592
* @see Comparable
593
*/
594
public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll) {
595
Iterator<? extends T> i = coll.iterator();
596
T candidate = i.next();
597
598
while (i.hasNext()) {
599
T next = i.next();
600
if (next.compareTo(candidate) < 0)
601
candidate = next;
602
}
603
return candidate;
604
}
605
606
/**
607
* Returns the minimum element of the given collection, according to the
608
* order induced by the specified comparator. All elements in the
609
* collection must be <i>mutually comparable</i> by the specified
610
* comparator (that is, <tt>comp.compare(e1, e2)</tt> must not throw a
611
* <tt>ClassCastException</tt> for any elements <tt>e1</tt> and
612
* <tt>e2</tt> in the collection).<p>
613
*
614
* This method iterates over the entire collection, hence it requires
615
* time proportional to the size of the collection.
616
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
617
* @param <T> the class of the objects in the collection
duke
Initial load
Dec 1, 2007
618
* @param coll the collection whose minimum element is to be determined.
619
* @param comp the comparator with which to determine the minimum element.
620
* A <tt>null</tt> value indicates that the elements' <i>natural
621
* ordering</i> should be used.
622
* @return the minimum element of the given collection, according
623
* to the specified comparator.
624
* @throws ClassCastException if the collection contains elements that are
625
* not <i>mutually comparable</i> using the specified comparator.
626
* @throws NoSuchElementException if the collection is empty.
627
* @see Comparable
628
*/
dxu
7193406: Clean-up JDK Build Warnings in java.util, java.io
Aug 31, 2012
629
@SuppressWarnings({"unchecked", "rawtypes"})
duke
Initial load
Dec 1, 2007
630
public static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp) {
631
if (comp==null)
khazra
7157893: Warnings Cleanup in java.util.*
Apr 17, 2012
632
return (T)min((Collection) coll);
duke
Initial load
Dec 1, 2007
633
634
Iterator<? extends T> i = coll.iterator();
635
T candidate = i.next();
636
637
while (i.hasNext()) {
638
T next = i.next();
639
if (comp.compare(next, candidate) < 0)
640
candidate = next;
641
}
642
return candidate;
643
}
644
645
/**
646
* Returns the maximum element of the given collection, according to the
647
* <i>natural ordering</i> of its elements. All elements in the
648
* collection must implement the <tt>Comparable</tt> interface.
649
* Furthermore, all elements in the collection must be <i>mutually
650
* comparable</i> (that is, <tt>e1.compareTo(e2)</tt> must not throw a
651
* <tt>ClassCastException</tt> for any elements <tt>e1</tt> and
652
* <tt>e2</tt> in the collection).<p>
653
*
654
* This method iterates over the entire collection, hence it requires
655
* time proportional to the size of the collection.
656
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
657
* @param <T> the class of the objects in the collection
duke
Initial load
Dec 1, 2007
658
* @param coll the collection whose maximum element is to be determined.
659
* @return the maximum element of the given collection, according
660
* to the <i>natural ordering</i> of its elements.
661
* @throws ClassCastException if the collection contains elements that are
662
* not <i>mutually comparable</i> (for example, strings and
663
* integers).
664
* @throws NoSuchElementException if the collection is empty.
665
* @see Comparable
666
*/
667
public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) {
668
Iterator<? extends T> i = coll.iterator();
669
T candidate = i.next();
670
671
while (i.hasNext()) {
672
T next = i.next();
673
if (next.compareTo(candidate) > 0)
674
candidate = next;
675
}
676
return candidate;
677
}
678
679
/**
680
* Returns the maximum element of the given collection, according to the
681
* order induced by the specified comparator. All elements in the
682
* collection must be <i>mutually comparable</i> by the specified
683
* comparator (that is, <tt>comp.compare(e1, e2)</tt> must not throw a
684
* <tt>ClassCastException</tt> for any elements <tt>e1</tt> and
685
* <tt>e2</tt> in the collection).<p>
686
*
687
* This method iterates over the entire collection, hence it requires
688
* time proportional to the size of the collection.
689
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
690
* @param <T> the class of the objects in the collection
duke
Initial load
Dec 1, 2007
691
* @param coll the collection whose maximum element is to be determined.
692
* @param comp the comparator with which to determine the maximum element.
693
* A <tt>null</tt> value indicates that the elements' <i>natural
694
* ordering</i> should be used.
695
* @return the maximum element of the given collection, according
696
* to the specified comparator.
697
* @throws ClassCastException if the collection contains elements that are
698
* not <i>mutually comparable</i> using the specified comparator.
699
* @throws NoSuchElementException if the collection is empty.
700
* @see Comparable
701
*/
dxu
7193406: Clean-up JDK Build Warnings in java.util, java.io
Aug 31, 2012
702
@SuppressWarnings({"unchecked", "rawtypes"})
duke
Initial load
Dec 1, 2007
703
public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp) {
704
if (comp==null)
khazra
7157893: Warnings Cleanup in java.util.*
Apr 17, 2012
705
return (T)max((Collection) coll);
duke
Initial load
Dec 1, 2007
706
707
Iterator<? extends T> i = coll.iterator();
708
T candidate = i.next();
709
710
while (i.hasNext()) {
711
T next = i.next();
712
if (comp.compare(next, candidate) > 0)
713
candidate = next;
714
}
715
return candidate;
716
}
717
718
/**
719
* Rotates the elements in the specified list by the specified distance.
720
* After calling this method, the element at index <tt>i</tt> will be
721
* the element previously at index <tt>(i - distance)</tt> mod
722
* <tt>list.size()</tt>, for all values of <tt>i</tt> between <tt>0</tt>
723
* and <tt>list.size()-1</tt>, inclusive. (This method has no effect on
724
* the size of the list.)
725
*
726
* <p>For example, suppose <tt>list</tt> comprises<tt> [t, a, n, k, s]</tt>.
727
* After invoking <tt>Collections.rotate(list, 1)</tt> (or
728
* <tt>Collections.rotate(list, -4)</tt>), <tt>list</tt> will comprise
729
* <tt>[s, t, a, n, k]</tt>.
730
*
731
* <p>Note that this method can usefully be applied to sublists to
732
* move one or more elements within a list while preserving the
733
* order of the remaining elements. For example, the following idiom
734
* moves the element at index <tt>j</tt> forward to position
735
* <tt>k</tt> (which must be greater than or equal to <tt>j</tt>):
736
* <pre>
737
* Collections.rotate(list.subList(j, k+1), -1);
738
* </pre>
739
* To make this concrete, suppose <tt>list</tt> comprises
740
* <tt>[a, b, c, d, e]</tt>. To move the element at index <tt>1</tt>
741
* (<tt>b</tt>) forward two positions, perform the following invocation:
742
* <pre>
743
* Collections.rotate(l.subList(1, 4), -1);
744
* </pre>
745
* The resulting list is <tt>[a, c, d, b, e]</tt>.
746
*
747
* <p>To move more than one element forward, increase the absolute value
748
* of the rotation distance. To move elements backward, use a positive
749
* shift distance.
750
*
751
* <p>If the specified list is small or implements the {@link
752
* RandomAccess} interface, this implementation exchanges the first
753
* element into the location it should go, and then repeatedly exchanges
754
* the displaced element into the location it should go until a displaced
755
* element is swapped into the first element. If necessary, the process
756
* is repeated on the second and successive elements, until the rotation
757
* is complete. If the specified list is large and doesn't implement the
758
* <tt>RandomAccess</tt> interface, this implementation breaks the
759
* list into two sublist views around index <tt>-distance mod size</tt>.
760
* Then the {@link #reverse(List)} method is invoked on each sublist view,
761
* and finally it is invoked on the entire list. For a more complete
762
* description of both algorithms, see Section 2.3 of Jon Bentley's
763
* <i>Programming Pearls</i> (Addison-Wesley, 1986).
764
*
765
* @param list the list to be rotated.
766
* @param distance the distance to rotate the list. There are no
767
* constraints on this value; it may be zero, negative, or
768
* greater than <tt>list.size()</tt>.
769
* @throws UnsupportedOperationException if the specified list or
770
* its list-iterator does not support the <tt>set</tt> operation.
771
* @since 1.4
772
*/
773
public static void rotate(List<?> list, int distance) {
774
if (list instanceof RandomAccess || list.size() < ROTATE_THRESHOLD)
775
rotate1(list, distance);
776
else
777
rotate2(list, distance);
778
}
779
780
private static <T> void rotate1(List<T> list, int distance) {
781
int size = list.size();
782
if (size == 0)
783
return;
784
distance = distance % size;
785
if (distance < 0)
786
distance += size;
787
if (distance == 0)
788
return;
789
790
for (int cycleStart = 0, nMoved = 0; nMoved != size; cycleStart++) {
791
T displaced = list.get(cycleStart);
792
int i = cycleStart;
793
do {
794
i += distance;
795
if (i >= size)
796
i -= size;
797
displaced = list.set(i, displaced);
798
nMoved ++;
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
799
} while (i != cycleStart);
duke
Initial load
Dec 1, 2007
800
}
801
}
802
803
private static void rotate2(List<?> list, int distance) {
804
int size = list.size();
805
if (size == 0)
806
return;
807
int mid = -distance % size;
808
if (mid < 0)
809
mid += size;
810
if (mid == 0)
811
return;
812
813
reverse(list.subList(0, mid));
814
reverse(list.subList(mid, size));
815
reverse(list);
816
}
817
818
/**
819
* Replaces all occurrences of one specified value in a list with another.
820
* More formally, replaces with <tt>newVal</tt> each element <tt>e</tt>
821
* in <tt>list</tt> such that
822
* <tt>(oldVal==null ? e==null : oldVal.equals(e))</tt>.
823
* (This method has no effect on the size of the list.)
824
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
825
* @param <T> the class of the objects in the list
duke
Initial load
Dec 1, 2007
826
* @param list the list in which replacement is to occur.
827
* @param oldVal the old value to be replaced.
828
* @param newVal the new value with which <tt>oldVal</tt> is to be
829
* replaced.
830
* @return <tt>true</tt> if <tt>list</tt> contained one or more elements
831
* <tt>e</tt> such that
832
* <tt>(oldVal==null ? e==null : oldVal.equals(e))</tt>.
833
* @throws UnsupportedOperationException if the specified list or
834
* its list-iterator does not support the <tt>set</tt> operation.
835
* @since 1.4
836
*/
837
public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) {
838
boolean result = false;
839
int size = list.size();
840
if (size < REPLACEALL_THRESHOLD || list instanceof RandomAccess) {
841
if (oldVal==null) {
842
for (int i=0; i<size; i++) {
843
if (list.get(i)==null) {
844
list.set(i, newVal);
845
result = true;
846
}
847
}
848
} else {
849
for (int i=0; i<size; i++) {
850
if (oldVal.equals(list.get(i))) {
851
list.set(i, newVal);
852
result = true;
853
}
854
}
855
}
856
} else {
857
ListIterator<T> itr=list.listIterator();
858
if (oldVal==null) {
859
for (int i=0; i<size; i++) {
860
if (itr.next()==null) {
861
itr.set(newVal);
862
result = true;
863
}
864
}
865
} else {
866
for (int i=0; i<size; i++) {
867
if (oldVal.equals(itr.next())) {
868
itr.set(newVal);
869
result = true;
870
}
871
}
872
}
873
}
874
return result;
875
}
876
877
/**
878
* Returns the starting position of the first occurrence of the specified
879
* target list within the specified source list, or -1 if there is no
880
* such occurrence. More formally, returns the lowest index <tt>i</tt>
alanb
8016217: More javadoc warnings
Jun 10, 2013
881
* such that {@code source.subList(i, i+target.size()).equals(target)},
duke
Initial load
Dec 1, 2007
882
* or -1 if there is no such index. (Returns -1 if
alanb
8016217: More javadoc warnings
Jun 10, 2013
883
* {@code target.size() > source.size()})
duke
Initial load
Dec 1, 2007
884
*
885
* <p>This implementation uses the "brute force" technique of scanning
886
* over the source list, looking for a match with the target at each
887
* location in turn.
888
*
889
* @param source the list in which to search for the first occurrence
890
* of <tt>target</tt>.
891
* @param target the list to search for as a subList of <tt>source</tt>.
892
* @return the starting position of the first occurrence of the specified
893
* target list within the specified source list, or -1 if there
894
* is no such occurrence.
895
* @since 1.4
896
*/
897
public static int indexOfSubList(List<?> source, List<?> target) {
898
int sourceSize = source.size();
899
int targetSize = target.size();
900
int maxCandidate = sourceSize - targetSize;
901
902
if (sourceSize < INDEXOFSUBLIST_THRESHOLD ||
903
(source instanceof RandomAccess&&target instanceof RandomAccess)) {
904
nextCand:
905
for (int candidate = 0; candidate <= maxCandidate; candidate++) {
906
for (int i=0, j=candidate; i<targetSize; i++, j++)
907
if (!eq(target.get(i), source.get(j)))
908
continue nextCand; // Element mismatch, try next cand
909
return candidate; // All elements of candidate matched target
910
}
911
} else { // Iterator version of above algorithm
912
ListIterator<?> si = source.listIterator();
913
nextCand:
914
for (int candidate = 0; candidate <= maxCandidate; candidate++) {
915
ListIterator<?> ti = target.listIterator();
916
for (int i=0; i<targetSize; i++) {
917
if (!eq(ti.next(), si.next())) {
918
// Back up source iterator to next candidate
919
for (int j=0; j<i; j++)
920
si.previous();
921
continue nextCand;
922
}
923
}
924
return candidate;
925
}
926
}
927
return -1; // No candidate matched the target
928
}
929
930
/**
931
* Returns the starting position of the last occurrence of the specified
932
* target list within the specified source list, or -1 if there is no such
933
* occurrence. More formally, returns the highest index <tt>i</tt>
alanb
8016217: More javadoc warnings
Jun 10, 2013
934
* such that {@code source.subList(i, i+target.size()).equals(target)},
duke
Initial load
Dec 1, 2007
935
* or -1 if there is no such index. (Returns -1 if
alanb
8016217: More javadoc warnings
Jun 10, 2013
936
* {@code target.size() > source.size()})
duke
Initial load
Dec 1, 2007
937
*
938
* <p>This implementation uses the "brute force" technique of iterating
939
* over the source list, looking for a match with the target at each
940
* location in turn.
941
*
942
* @param source the list in which to search for the last occurrence
943
* of <tt>target</tt>.
944
* @param target the list to search for as a subList of <tt>source</tt>.
945
* @return the starting position of the last occurrence of the specified
946
* target list within the specified source list, or -1 if there
947
* is no such occurrence.
948
* @since 1.4
949
*/
950
public static int lastIndexOfSubList(List<?> source, List<?> target) {
951
int sourceSize = source.size();
952
int targetSize = target.size();
953
int maxCandidate = sourceSize - targetSize;
954
955
if (sourceSize < INDEXOFSUBLIST_THRESHOLD ||
956
source instanceof RandomAccess) { // Index access version
957
nextCand:
958
for (int candidate = maxCandidate; candidate >= 0; candidate--) {
959
for (int i=0, j=candidate; i<targetSize; i++, j++)
960
if (!eq(target.get(i), source.get(j)))
961
continue nextCand; // Element mismatch, try next cand
962
return candidate; // All elements of candidate matched target
963
}
964
} else { // Iterator version of above algorithm
965
if (maxCandidate < 0)
966
return -1;
967
ListIterator<?> si = source.listIterator(maxCandidate);
968
nextCand:
969
for (int candidate = maxCandidate; candidate >= 0; candidate--) {
970
ListIterator<?> ti = target.listIterator();
971
for (int i=0; i<targetSize; i++) {
972
if (!eq(ti.next(), si.next())) {
973
if (candidate != 0) {
974
// Back up source iterator to next candidate
975
for (int j=0; j<=i+1; j++)
976
si.previous();
977
}
978
continue nextCand;
979
}
980
}
981
return candidate;
982
}
983
}
984
return -1; // No candidate matched the target
985
}
986
987
988
// Unmodifiable Wrappers
989
990
/**
991
* Returns an unmodifiable view of the specified collection. This method
992
* allows modules to provide users with "read-only" access to internal
993
* collections. Query operations on the returned collection "read through"
994
* to the specified collection, and attempts to modify the returned
995
* collection, whether direct or via its iterator, result in an
996
* <tt>UnsupportedOperationException</tt>.<p>
997
*
998
* The returned collection does <i>not</i> pass the hashCode and equals
999
* operations through to the backing collection, but relies on
1000
* <tt>Object</tt>'s <tt>equals</tt> and <tt>hashCode</tt> methods. This
1001
* is necessary to preserve the contracts of these operations in the case
1002
* that the backing collection is a set or a list.<p>
1003
*
1004
* The returned collection will be serializable if the specified collection
1005
* is serializable.
1006
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
1007
* @param <T> the class of the objects in the collection
duke
Initial load
Dec 1, 2007
1008
* @param c the collection for which an unmodifiable view is to be
1009
* returned.
1010
* @return an unmodifiable view of the specified collection.
1011
*/
1012
public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
1013
return new UnmodifiableCollection<>(c);
duke
Initial load
Dec 1, 2007
1014
}
1015
1016
/**
1017
* @serial include
1018
*/
1019
static class UnmodifiableCollection<E> implements Collection<E>, Serializable {
1020
private static final long serialVersionUID = 1820017752578914078L;
1021
1022
final Collection<? extends E> c;
1023
1024
UnmodifiableCollection(Collection<? extends E> c) {
1025
if (c==null)
1026
throw new NullPointerException();
1027
this.c = c;
1028
}
1029
1030
public int size() {return c.size();}
1031
public boolean isEmpty() {return c.isEmpty();}
1032
public boolean contains(Object o) {return c.contains(o);}
1033
public Object[] toArray() {return c.toArray();}
1034
public <T> T[] toArray(T[] a) {return c.toArray(a);}
1035
public String toString() {return c.toString();}
1036
1037
public Iterator<E> iterator() {
1038
return new Iterator<E>() {
1039
private final Iterator<? extends E> i = c.iterator();
1040
1041
public boolean hasNext() {return i.hasNext();}
1042
public E next() {return i.next();}
1043
public void remove() {
1044
throw new UnsupportedOperationException();
1045
}
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
1046
@Override
1047
public void forEachRemaining(Consumer<? super E> action) {
1048
// Use backing collection version
1049
i.forEachRemaining(action);
1050
}
duke
Initial load
Dec 1, 2007
1051
};
1052
}
1053
1054
public boolean add(E e) {
1055
throw new UnsupportedOperationException();
1056
}
1057
public boolean remove(Object o) {
1058
throw new UnsupportedOperationException();
1059
}
1060
1061
public boolean containsAll(Collection<?> coll) {
1062
return c.containsAll(coll);
1063
}
1064
public boolean addAll(Collection<? extends E> coll) {
1065
throw new UnsupportedOperationException();
1066
}
1067
public boolean removeAll(Collection<?> coll) {
1068
throw new UnsupportedOperationException();
1069
}
1070
public boolean retainAll(Collection<?> coll) {
1071
throw new UnsupportedOperationException();
1072
}
1073
public void clear() {
1074
throw new UnsupportedOperationException();
1075
}
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
1076
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
1077
// Override default methods in Collection
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
1078
@Override
1079
public void forEach(Consumer<? super E> action) {
1080
c.forEach(action);
1081
}
1082
@Override
1083
public boolean removeIf(Predicate<? super E> filter) {
1084
throw new UnsupportedOperationException();
1085
}
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
1086
@SuppressWarnings("unchecked")
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
1087
@Override
1088
public Spliterator<E> spliterator() {
1089
return (Spliterator<E>)c.spliterator();
1090
}
henryjen
8023275: Wrapping collections should override default methods
Aug 27, 2013
1091
@SuppressWarnings("unchecked")
1092
@Override
1093
public Stream<E> stream() {
1094
return (Stream<E>)c.stream();
1095
}
1096
@SuppressWarnings("unchecked")
1097
@Override
1098
public Stream<E> parallelStream() {
1099
return (Stream<E>)c.parallelStream();
1100
}
duke
Initial load
Dec 1, 2007
1101
}
1102
1103
/**
1104
* Returns an unmodifiable view of the specified set. This method allows
1105
* modules to provide users with "read-only" access to internal sets.
1106
* Query operations on the returned set "read through" to the specified
1107
* set, and attempts to modify the returned set, whether direct or via its
1108
* iterator, result in an <tt>UnsupportedOperationException</tt>.<p>
1109
*
1110
* The returned set will be serializable if the specified set
1111
* is serializable.
1112
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
1113
* @param <T> the class of the objects in the set
duke
Initial load
Dec 1, 2007
1114
* @param s the set for which an unmodifiable view is to be returned.
1115
* @return an unmodifiable view of the specified set.
1116
*/
1117
public static <T> Set<T> unmodifiableSet(Set<? extends T> s) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
1118
return new UnmodifiableSet<>(s);
duke
Initial load
Dec 1, 2007
1119
}
1120
1121
/**
1122
* @serial include
1123
*/
1124
static class UnmodifiableSet<E> extends UnmodifiableCollection<E>
1125
implements Set<E>, Serializable {
1126
private static final long serialVersionUID = -9215047833775013803L;
1127
1128
UnmodifiableSet(Set<? extends E> s) {super(s);}
1129
public boolean equals(Object o) {return o == this || c.equals(o);}
1130
public int hashCode() {return c.hashCode();}
1131
}
1132
1133
/**
1134
* Returns an unmodifiable view of the specified sorted set. This method
1135
* allows modules to provide users with "read-only" access to internal
1136
* sorted sets. Query operations on the returned sorted set "read
1137
* through" to the specified sorted set. Attempts to modify the returned
1138
* sorted set, whether direct, via its iterator, or via its
1139
* <tt>subSet</tt>, <tt>headSet</tt>, or <tt>tailSet</tt> views, result in
1140
* an <tt>UnsupportedOperationException</tt>.<p>
1141
*
1142
* The returned sorted set will be serializable if the specified sorted set
1143
* is serializable.
1144
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
1145
* @param <T> the class of the objects in the set
duke
Initial load
Dec 1, 2007
1146
* @param s the sorted set for which an unmodifiable view is to be
1147
* returned.
1148
* @return an unmodifiable view of the specified sorted set.
1149
*/
1150
public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
1151
return new UnmodifiableSortedSet<>(s);
duke
Initial load
Dec 1, 2007
1152
}
1153
1154
/**
1155
* @serial include
1156
*/
1157
static class UnmodifiableSortedSet<E>
1158
extends UnmodifiableSet<E>
1159
implements SortedSet<E>, Serializable {
1160
private static final long serialVersionUID = -4929149591599911165L;
1161
private final SortedSet<E> ss;
1162
1163
UnmodifiableSortedSet(SortedSet<E> s) {super(s); ss = s;}
1164
1165
public Comparator<? super E> comparator() {return ss.comparator();}
1166
1167
public SortedSet<E> subSet(E fromElement, E toElement) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
1168
return new UnmodifiableSortedSet<>(ss.subSet(fromElement,toElement));
duke
Initial load
Dec 1, 2007
1169
}
1170
public SortedSet<E> headSet(E toElement) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
1171
return new UnmodifiableSortedSet<>(ss.headSet(toElement));
duke
Initial load
Dec 1, 2007
1172
}
1173
public SortedSet<E> tailSet(E fromElement) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
1174
return new UnmodifiableSortedSet<>(ss.tailSet(fromElement));
duke
Initial load
Dec 1, 2007
1175
}
1176
1177
public E first() {return ss.first();}
1178
public E last() {return ss.last();}
1179
}
1180
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1181
/**
1182
* Returns an unmodifiable view of the specified navigable set. This method
1183
* allows modules to provide users with "read-only" access to internal
1184
* navigable sets. Query operations on the returned navigable set "read
1185
* through" to the specified navigable set. Attempts to modify the returned
1186
* navigable set, whether direct, via its iterator, or via its
1187
* {@code subSet}, {@code headSet}, or {@code tailSet} views, result in
1188
* an {@code UnsupportedOperationException}.<p>
1189
*
1190
* The returned navigable set will be serializable if the specified
1191
* navigable set is serializable.
1192
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
1193
* @param <T> the class of the objects in the set
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1194
* @param s the navigable set for which an unmodifiable view is to be
1195
* returned
1196
* @return an unmodifiable view of the specified navigable set
1197
* @since 1.8
1198
*/
1199
public static <T> NavigableSet<T> unmodifiableNavigableSet(NavigableSet<T> s) {
1200
return new UnmodifiableNavigableSet<>(s);
1201
}
1202
1203
/**
1204
* Wraps a navigable set and disables all of the mutative operations.
1205
*
1206
* @param <E> type of elements
1207
* @serial include
1208
*/
1209
static class UnmodifiableNavigableSet<E>
1210
extends UnmodifiableSortedSet<E>
1211
implements NavigableSet<E>, Serializable {
1212
1213
private static final long serialVersionUID = -6027448201786391929L;
1214
1215
/**
1216
* A singleton empty unmodifiable navigable set used for
1217
* {@link #emptyNavigableSet()}.
1218
*
1219
* @param <E> type of elements, if there were any, and bounds
1220
*/
1221
private static class EmptyNavigableSet<E> extends UnmodifiableNavigableSet<E>
1222
implements Serializable {
1223
private static final long serialVersionUID = -6291252904449939134L;
1224
1225
public EmptyNavigableSet() {
1226
super(new TreeSet<E>());
1227
}
1228
1229
private Object readResolve() { return EMPTY_NAVIGABLE_SET; }
1230
}
1231
1232
@SuppressWarnings("rawtypes")
1233
private static final NavigableSet<?> EMPTY_NAVIGABLE_SET =
1234
new EmptyNavigableSet<>();
1235
1236
/**
1237
* The instance we are protecting.
1238
*/
1239
private final NavigableSet<E> ns;
1240
1241
UnmodifiableNavigableSet(NavigableSet<E> s) {super(s); ns = s;}
1242
1243
public E lower(E e) { return ns.lower(e); }
1244
public E floor(E e) { return ns.floor(e); }
1245
public E ceiling(E e) { return ns.ceiling(e); }
1246
public E higher(E e) { return ns.higher(e); }
1247
public E pollFirst() { throw new UnsupportedOperationException(); }
1248
public E pollLast() { throw new UnsupportedOperationException(); }
1249
public NavigableSet<E> descendingSet()
1250
{ return new UnmodifiableNavigableSet<>(ns.descendingSet()); }
1251
public Iterator<E> descendingIterator()
1252
{ return descendingSet().iterator(); }
1253
1254
public NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) {
1255
return new UnmodifiableNavigableSet<>(
1256
ns.subSet(fromElement, fromInclusive, toElement, toInclusive));
1257
}
1258
1259
public NavigableSet<E> headSet(E toElement, boolean inclusive) {
1260
return new UnmodifiableNavigableSet<>(
1261
ns.headSet(toElement, inclusive));
1262
}
1263
1264
public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
1265
return new UnmodifiableNavigableSet<>(
1266
ns.tailSet(fromElement, inclusive));
1267
}
1268
}
1269
duke
Initial load
Dec 1, 2007
1270
/**
1271
* Returns an unmodifiable view of the specified list. This method allows
1272
* modules to provide users with "read-only" access to internal
1273
* lists. Query operations on the returned list "read through" to the
1274
* specified list, and attempts to modify the returned list, whether
1275
* direct or via its iterator, result in an
1276
* <tt>UnsupportedOperationException</tt>.<p>
1277
*
1278
* The returned list will be serializable if the specified list
1279
* is serializable. Similarly, the returned list will implement
1280
* {@link RandomAccess} if the specified list does.
1281
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
1282
* @param <T> the class of the objects in the list
duke
Initial load
Dec 1, 2007
1283
* @param list the list for which an unmodifiable view is to be returned.
1284
* @return an unmodifiable view of the specified list.
1285
*/
1286
public static <T> List<T> unmodifiableList(List<? extends T> list) {
1287
return (list instanceof RandomAccess ?
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
1288
new UnmodifiableRandomAccessList<>(list) :
1289
new UnmodifiableList<>(list));
duke
Initial load
Dec 1, 2007
1290
}
1291
1292
/**
1293
* @serial include
1294
*/
1295
static class UnmodifiableList<E> extends UnmodifiableCollection<E>
1296
implements List<E> {
1297
private static final long serialVersionUID = -283967356065247728L;
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1298
duke
Initial load
Dec 1, 2007
1299
final List<? extends E> list;
1300
1301
UnmodifiableList(List<? extends E> list) {
1302
super(list);
1303
this.list = list;
1304
}
1305
1306
public boolean equals(Object o) {return o == this || list.equals(o);}
1307
public int hashCode() {return list.hashCode();}
1308
1309
public E get(int index) {return list.get(index);}
1310
public E set(int index, E element) {
1311
throw new UnsupportedOperationException();
1312
}
1313
public void add(int index, E element) {
1314
throw new UnsupportedOperationException();
1315
}
1316
public E remove(int index) {
1317
throw new UnsupportedOperationException();
1318
}
1319
public int indexOf(Object o) {return list.indexOf(o);}
1320
public int lastIndexOf(Object o) {return list.lastIndexOf(o);}
1321
public boolean addAll(int index, Collection<? extends E> c) {
1322
throw new UnsupportedOperationException();
1323
}
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
1324
1325
@Override
1326
public void replaceAll(UnaryOperator<E> operator) {
1327
throw new UnsupportedOperationException();
1328
}
1329
@Override
1330
public void sort(Comparator<? super E> c) {
1331
throw new UnsupportedOperationException();
1332
}
1333
duke
Initial load
Dec 1, 2007
1334
public ListIterator<E> listIterator() {return listIterator(0);}
1335
1336
public ListIterator<E> listIterator(final int index) {
1337
return new ListIterator<E>() {
1338
private final ListIterator<? extends E> i
1339
= list.listIterator(index);
1340
1341
public boolean hasNext() {return i.hasNext();}
1342
public E next() {return i.next();}
1343
public boolean hasPrevious() {return i.hasPrevious();}
1344
public E previous() {return i.previous();}
1345
public int nextIndex() {return i.nextIndex();}
1346
public int previousIndex() {return i.previousIndex();}
1347
1348
public void remove() {
1349
throw new UnsupportedOperationException();
1350
}
1351
public void set(E e) {
1352
throw new UnsupportedOperationException();
1353
}
1354
public void add(E e) {
1355
throw new UnsupportedOperationException();
1356
}
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
1357
1358
@Override
1359
public void forEachRemaining(Consumer<? super E> action) {
1360
i.forEachRemaining(action);
1361
}
duke
Initial load
Dec 1, 2007
1362
};
1363
}
1364
1365
public List<E> subList(int fromIndex, int toIndex) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
1366
return new UnmodifiableList<>(list.subList(fromIndex, toIndex));
duke
Initial load
Dec 1, 2007
1367
}
1368
1369
/**
1370
* UnmodifiableRandomAccessList instances are serialized as
1371
* UnmodifiableList instances to allow them to be deserialized
1372
* in pre-1.4 JREs (which do not have UnmodifiableRandomAccessList).
1373
* This method inverts the transformation. As a beneficial
1374
* side-effect, it also grafts the RandomAccess marker onto
1375
* UnmodifiableList instances that were serialized in pre-1.4 JREs.
1376
*
1377
* Note: Unfortunately, UnmodifiableRandomAccessList instances
1378
* serialized in 1.4.1 and deserialized in 1.4 will become
1379
* UnmodifiableList instances, as this method was missing in 1.4.
1380
*/
1381
private Object readResolve() {
1382
return (list instanceof RandomAccess
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
1383
? new UnmodifiableRandomAccessList<>(list)
duke
Initial load
Dec 1, 2007
1384
: this);
1385
}
1386
}
1387
1388
/**
1389
* @serial include
1390
*/
1391
static class UnmodifiableRandomAccessList<E> extends UnmodifiableList<E>
1392
implements RandomAccess
1393
{
1394
UnmodifiableRandomAccessList(List<? extends E> list) {
1395
super(list);
1396
}
1397
1398
public List<E> subList(int fromIndex, int toIndex) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
1399
return new UnmodifiableRandomAccessList<>(
duke
Initial load
Dec 1, 2007
1400
list.subList(fromIndex, toIndex));
1401
}
1402
1403
private static final long serialVersionUID = -2542308836966382001L;
1404
1405
/**
1406
* Allows instances to be deserialized in pre-1.4 JREs (which do
1407
* not have UnmodifiableRandomAccessList). UnmodifiableList has
1408
* a readResolve method that inverts this transformation upon
1409
* deserialization.
1410
*/
1411
private Object writeReplace() {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
1412
return new UnmodifiableList<>(list);
duke
Initial load
Dec 1, 2007
1413
}
1414
}
1415
1416
/**
1417
* Returns an unmodifiable view of the specified map. This method
1418
* allows modules to provide users with "read-only" access to internal
1419
* maps. Query operations on the returned map "read through"
1420
* to the specified map, and attempts to modify the returned
1421
* map, whether direct or via its collection views, result in an
1422
* <tt>UnsupportedOperationException</tt>.<p>
1423
*
1424
* The returned map will be serializable if the specified map
1425
* is serializable.
1426
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
1427
* @param <K> the class of the map keys
1428
* @param <V> the class of the map values
duke
Initial load
Dec 1, 2007
1429
* @param m the map for which an unmodifiable view is to be returned.
1430
* @return an unmodifiable view of the specified map.
1431
*/
1432
public static <K,V> Map<K,V> unmodifiableMap(Map<? extends K, ? extends V> m) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
1433
return new UnmodifiableMap<>(m);
duke
Initial load
Dec 1, 2007
1434
}
1435
1436
/**
1437
* @serial include
1438
*/
1439
private static class UnmodifiableMap<K,V> implements Map<K,V>, Serializable {
1440
private static final long serialVersionUID = -1034234728574286014L;
1441
1442
private final Map<? extends K, ? extends V> m;
1443
1444
UnmodifiableMap(Map<? extends K, ? extends V> m) {
1445
if (m==null)
1446
throw new NullPointerException();
1447
this.m = m;
1448
}
1449
1450
public int size() {return m.size();}
1451
public boolean isEmpty() {return m.isEmpty();}
1452
public boolean containsKey(Object key) {return m.containsKey(key);}
1453
public boolean containsValue(Object val) {return m.containsValue(val);}
1454
public V get(Object key) {return m.get(key);}
1455
1456
public V put(K key, V value) {
1457
throw new UnsupportedOperationException();
1458
}
1459
public V remove(Object key) {
1460
throw new UnsupportedOperationException();
1461
}
1462
public void putAll(Map<? extends K, ? extends V> m) {
1463
throw new UnsupportedOperationException();
1464
}
1465
public void clear() {
1466
throw new UnsupportedOperationException();
1467
}
1468
mduigou
8035284: Remove redundant initializations to null
Apr 11, 2014
1469
private transient Set<K> keySet;
1470
private transient Set<Map.Entry<K,V>> entrySet;
1471
private transient Collection<V> values;
duke
Initial load
Dec 1, 2007
1472
1473
public Set<K> keySet() {
1474
if (keySet==null)
1475
keySet = unmodifiableSet(m.keySet());
1476
return keySet;
1477
}
1478
1479
public Set<Map.Entry<K,V>> entrySet() {
1480
if (entrySet==null)
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
1481
entrySet = new UnmodifiableEntrySet<>(m.entrySet());
duke
Initial load
Dec 1, 2007
1482
return entrySet;
1483
}
1484
1485
public Collection<V> values() {
1486
if (values==null)
1487
values = unmodifiableCollection(m.values());
1488
return values;
1489
}
1490
1491
public boolean equals(Object o) {return o == this || m.equals(o);}
1492
public int hashCode() {return m.hashCode();}
1493
public String toString() {return m.toString();}
1494
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
1495
// Override default methods in Map
1496
@Override
1497
@SuppressWarnings("unchecked")
1498
public V getOrDefault(Object k, V defaultValue) {
1499
// Safe cast as we don't change the value
1500
return ((Map<K, V>)m).getOrDefault(k, defaultValue);
1501
}
1502
1503
@Override
1504
public void forEach(BiConsumer<? super K, ? super V> action) {
1505
m.forEach(action);
1506
}
1507
1508
@Override
1509
public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
1510
throw new UnsupportedOperationException();
1511
}
1512
1513
@Override
1514
public V putIfAbsent(K key, V value) {
1515
throw new UnsupportedOperationException();
1516
}
1517
1518
@Override
1519
public boolean remove(Object key, Object value) {
1520
throw new UnsupportedOperationException();
1521
}
1522
1523
@Override
1524
public boolean replace(K key, V oldValue, V newValue) {
1525
throw new UnsupportedOperationException();
1526
}
1527
1528
@Override
1529
public V replace(K key, V value) {
1530
throw new UnsupportedOperationException();
1531
}
1532
1533
@Override
1534
public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
1535
throw new UnsupportedOperationException();
1536
}
1537
1538
@Override
1539
public V computeIfPresent(K key,
1540
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
1541
throw new UnsupportedOperationException();
1542
}
1543
1544
@Override
1545
public V compute(K key,
1546
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
1547
throw new UnsupportedOperationException();
1548
}
1549
1550
@Override
1551
public V merge(K key, V value,
1552
BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
1553
throw new UnsupportedOperationException();
1554
}
1555
duke
Initial load
Dec 1, 2007
1556
/**
1557
* We need this class in addition to UnmodifiableSet as
1558
* Map.Entries themselves permit modification of the backing Map
1559
* via their setValue operation. This class is subtle: there are
1560
* many possible attacks that must be thwarted.
1561
*
1562
* @serial include
1563
*/
1564
static class UnmodifiableEntrySet<K,V>
1565
extends UnmodifiableSet<Map.Entry<K,V>> {
1566
private static final long serialVersionUID = 7854390611657943733L;
1567
dxu
7193406: Clean-up JDK Build Warnings in java.util, java.io
Aug 31, 2012
1568
@SuppressWarnings({"unchecked", "rawtypes"})
duke
Initial load
Dec 1, 2007
1569
UnmodifiableEntrySet(Set<? extends Map.Entry<? extends K, ? extends V>> s) {
khazra
7157893: Warnings Cleanup in java.util.*
Apr 17, 2012
1570
// Need to cast to raw in order to work around a limitation in the type system
duke
Initial load
Dec 1, 2007
1571
super((Set)s);
1572
}
psandoz
8017447: Unmodifiable map entry becomes modifiable if taken from a st…
Jul 10, 2013
1573
1574
static <K, V> Consumer<Map.Entry<K, V>> entryConsumer(Consumer<? super Entry<K, V>> action) {
1575
return e -> action.accept(new UnmodifiableEntry<>(e));
1576
}
1577
1578
public void forEach(Consumer<? super Entry<K, V>> action) {
1579
Objects.requireNonNull(action);
1580
c.forEach(entryConsumer(action));
1581
}
1582
1583
static final class UnmodifiableEntrySetSpliterator<K, V>
1584
implements Spliterator<Entry<K,V>> {
1585
final Spliterator<Map.Entry<K, V>> s;
1586
1587
UnmodifiableEntrySetSpliterator(Spliterator<Entry<K, V>> s) {
1588
this.s = s;
1589
}
1590
1591
@Override
1592
public boolean tryAdvance(Consumer<? super Entry<K, V>> action) {
1593
Objects.requireNonNull(action);
1594
return s.tryAdvance(entryConsumer(action));
1595
}
1596
1597
@Override
1598
public void forEachRemaining(Consumer<? super Entry<K, V>> action) {
1599
Objects.requireNonNull(action);
1600
s.forEachRemaining(entryConsumer(action));
1601
}
1602
1603
@Override
1604
public Spliterator<Entry<K, V>> trySplit() {
1605
Spliterator<Entry<K, V>> split = s.trySplit();
1606
return split == null
1607
? null
1608
: new UnmodifiableEntrySetSpliterator<>(split);
1609
}
1610
1611
@Override
1612
public long estimateSize() {
1613
return s.estimateSize();
1614
}
1615
1616
@Override
1617
public long getExactSizeIfKnown() {
1618
return s.getExactSizeIfKnown();
1619
}
1620
1621
@Override
1622
public int characteristics() {
1623
return s.characteristics();
1624
}
1625
1626
@Override
1627
public boolean hasCharacteristics(int characteristics) {
1628
return s.hasCharacteristics(characteristics);
1629
}
1630
1631
@Override
1632
public Comparator<? super Entry<K, V>> getComparator() {
1633
return s.getComparator();
1634
}
1635
}
1636
1637
@SuppressWarnings("unchecked")
1638
public Spliterator<Entry<K,V>> spliterator() {
1639
return new UnmodifiableEntrySetSpliterator<>(
1640
(Spliterator<Map.Entry<K, V>>) c.spliterator());
1641
}
1642
1643
@Override
1644
public Stream<Entry<K,V>> stream() {
psandoz
8019395: Consolidate StreamSupport.{stream,parallelStream} into a sin…
Jul 3, 2013
1645
return StreamSupport.stream(spliterator(), false);
psandoz
8017447: Unmodifiable map entry becomes modifiable if taken from a st…
Jul 10, 2013
1646
}
1647
1648
@Override
1649
public Stream<Entry<K,V>> parallelStream() {
psandoz
8019395: Consolidate StreamSupport.{stream,parallelStream} into a sin…
Jul 3, 2013
1650
return StreamSupport.stream(spliterator(), true);
psandoz
8017447: Unmodifiable map entry becomes modifiable if taken from a st…
Jul 10, 2013
1651
}
1652
duke
Initial load
Dec 1, 2007
1653
public Iterator<Map.Entry<K,V>> iterator() {
1654
return new Iterator<Map.Entry<K,V>>() {
1655
private final Iterator<? extends Map.Entry<? extends K, ? extends V>> i = c.iterator();
1656
1657
public boolean hasNext() {
1658
return i.hasNext();
1659
}
1660
public Map.Entry<K,V> next() {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
1661
return new UnmodifiableEntry<>(i.next());
duke
Initial load
Dec 1, 2007
1662
}
1663
public void remove() {
1664
throw new UnsupportedOperationException();
1665
}
1666
};
1667
}
1668
khazra
7157893: Warnings Cleanup in java.util.*
Apr 17, 2012
1669
@SuppressWarnings("unchecked")
duke
Initial load
Dec 1, 2007
1670
public Object[] toArray() {
1671
Object[] a = c.toArray();
1672
for (int i=0; i<a.length; i++)
khazra
7157893: Warnings Cleanup in java.util.*
Apr 17, 2012
1673
a[i] = new UnmodifiableEntry<>((Map.Entry<? extends K, ? extends V>)a[i]);
duke
Initial load
Dec 1, 2007
1674
return a;
1675
}
1676
khazra
7157893: Warnings Cleanup in java.util.*
Apr 17, 2012
1677
@SuppressWarnings("unchecked")
duke
Initial load
Dec 1, 2007
1678
public <T> T[] toArray(T[] a) {
1679
// We don't pass a to c.toArray, to avoid window of
1680
// vulnerability wherein an unscrupulous multithreaded client
1681
// could get his hands on raw (unwrapped) Entries from c.
1682
Object[] arr = c.toArray(a.length==0 ? a : Arrays.copyOf(a, 0));
1683
1684
for (int i=0; i<arr.length; i++)
khazra
7157893: Warnings Cleanup in java.util.*
Apr 17, 2012
1685
arr[i] = new UnmodifiableEntry<>((Map.Entry<? extends K, ? extends V>)arr[i]);
duke
Initial load
Dec 1, 2007
1686
1687
if (arr.length > a.length)
1688
return (T[])arr;
1689
1690
System.arraycopy(arr, 0, a, 0, arr.length);
1691
if (a.length > arr.length)
1692
a[arr.length] = null;
1693
return a;
1694
}
1695
1696
/**
1697
* This method is overridden to protect the backing set against
1698
* an object with a nefarious equals function that senses
1699
* that the equality-candidate is Map.Entry and calls its
1700
* setValue method.
1701
*/
1702
public boolean contains(Object o) {
1703
if (!(o instanceof Map.Entry))
1704
return false;
1705
return c.contains(
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
1706
new UnmodifiableEntry<>((Map.Entry<?,?>) o));
duke
Initial load
Dec 1, 2007
1707
}
1708
1709
/**
1710
* The next two methods are overridden to protect against
1711
* an unscrupulous List whose contains(Object o) method senses
1712
* when o is a Map.Entry, and calls o.setValue.
1713
*/
1714
public boolean containsAll(Collection<?> coll) {
dl
7005424: Resync java.util.concurrent classes with Dougs CVS - Jan 2011
Jan 12, 2011
1715
for (Object e : coll) {
1716
if (!contains(e)) // Invokes safe contains() above
duke
Initial load
Dec 1, 2007
1717
return false;
dl
7005424: Resync java.util.concurrent classes with Dougs CVS - Jan 2011
Jan 12, 2011
1718
}
duke
Initial load
Dec 1, 2007
1719
return true;
1720
}
1721
public boolean equals(Object o) {
1722
if (o == this)
1723
return true;
1724
1725
if (!(o instanceof Set))
1726
return false;
khazra
7157893: Warnings Cleanup in java.util.*
Apr 17, 2012
1727
Set<?> s = (Set<?>) o;
duke
Initial load
Dec 1, 2007
1728
if (s.size() != c.size())
1729
return false;
1730
return containsAll(s); // Invokes safe containsAll() above
1731
}
1732
1733
/**
1734
* This "wrapper class" serves two purposes: it prevents
1735
* the client from modifying the backing Map, by short-circuiting
1736
* the setValue method, and it protects the backing Map against
1737
* an ill-behaved Map.Entry that attempts to modify another
1738
* Map Entry when asked to perform an equality check.
1739
*/
1740
private static class UnmodifiableEntry<K,V> implements Map.Entry<K,V> {
1741
private Map.Entry<? extends K, ? extends V> e;
1742
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1743
UnmodifiableEntry(Map.Entry<? extends K, ? extends V> e)
1744
{this.e = Objects.requireNonNull(e);}
duke
Initial load
Dec 1, 2007
1745
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
1746
public K getKey() {return e.getKey();}
1747
public V getValue() {return e.getValue();}
duke
Initial load
Dec 1, 2007
1748
public V setValue(V value) {
1749
throw new UnsupportedOperationException();
1750
}
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
1751
public int hashCode() {return e.hashCode();}
duke
Initial load
Dec 1, 2007
1752
public boolean equals(Object o) {
coffeys
7144488: Infinite recursion for some equals tests in Collections
Feb 24, 2012
1753
if (this == o)
1754
return true;
duke
Initial load
Dec 1, 2007
1755
if (!(o instanceof Map.Entry))
1756
return false;
khazra
7157893: Warnings Cleanup in java.util.*
Apr 17, 2012
1757
Map.Entry<?,?> t = (Map.Entry<?,?>)o;
duke
Initial load
Dec 1, 2007
1758
return eq(e.getKey(), t.getKey()) &&
1759
eq(e.getValue(), t.getValue());
1760
}
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
1761
public String toString() {return e.toString();}
duke
Initial load
Dec 1, 2007
1762
}
1763
}
1764
}
1765
1766
/**
1767
* Returns an unmodifiable view of the specified sorted map. This method
1768
* allows modules to provide users with "read-only" access to internal
1769
* sorted maps. Query operations on the returned sorted map "read through"
1770
* to the specified sorted map. Attempts to modify the returned
1771
* sorted map, whether direct, via its collection views, or via its
1772
* <tt>subMap</tt>, <tt>headMap</tt>, or <tt>tailMap</tt> views, result in
1773
* an <tt>UnsupportedOperationException</tt>.<p>
1774
*
1775
* The returned sorted map will be serializable if the specified sorted map
1776
* is serializable.
1777
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
1778
* @param <K> the class of the map keys
1779
* @param <V> the class of the map values
duke
Initial load
Dec 1, 2007
1780
* @param m the sorted map for which an unmodifiable view is to be
1781
* returned.
1782
* @return an unmodifiable view of the specified sorted map.
1783
*/
1784
public static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K, ? extends V> m) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
1785
return new UnmodifiableSortedMap<>(m);
duke
Initial load
Dec 1, 2007
1786
}
1787
1788
/**
1789
* @serial include
1790
*/
1791
static class UnmodifiableSortedMap<K,V>
1792
extends UnmodifiableMap<K,V>
1793
implements SortedMap<K,V>, Serializable {
1794
private static final long serialVersionUID = -8806743815996713206L;
1795
1796
private final SortedMap<K, ? extends V> sm;
1797
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1798
UnmodifiableSortedMap(SortedMap<K, ? extends V> m) {super(m); sm = m; }
1799
public Comparator<? super K> comparator() { return sm.comparator(); }
1800
public SortedMap<K,V> subMap(K fromKey, K toKey)
1801
{ return new UnmodifiableSortedMap<>(sm.subMap(fromKey, toKey)); }
1802
public SortedMap<K,V> headMap(K toKey)
1803
{ return new UnmodifiableSortedMap<>(sm.headMap(toKey)); }
1804
public SortedMap<K,V> tailMap(K fromKey)
1805
{ return new UnmodifiableSortedMap<>(sm.tailMap(fromKey)); }
1806
public K firstKey() { return sm.firstKey(); }
1807
public K lastKey() { return sm.lastKey(); }
1808
}
duke
Initial load
Dec 1, 2007
1809
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1810
/**
1811
* Returns an unmodifiable view of the specified navigable map. This method
1812
* allows modules to provide users with "read-only" access to internal
1813
* navigable maps. Query operations on the returned navigable map "read
1814
* through" to the specified navigable map. Attempts to modify the returned
1815
* navigable map, whether direct, via its collection views, or via its
1816
* {@code subMap}, {@code headMap}, or {@code tailMap} views, result in
1817
* an {@code UnsupportedOperationException}.<p>
1818
*
1819
* The returned navigable map will be serializable if the specified
1820
* navigable map is serializable.
1821
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
1822
* @param <K> the class of the map keys
1823
* @param <V> the class of the map values
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1824
* @param m the navigable map for which an unmodifiable view is to be
1825
* returned
1826
* @return an unmodifiable view of the specified navigable map
1827
* @since 1.8
1828
*/
1829
public static <K,V> NavigableMap<K,V> unmodifiableNavigableMap(NavigableMap<K, ? extends V> m) {
1830
return new UnmodifiableNavigableMap<>(m);
1831
}
duke
Initial load
Dec 1, 2007
1832
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1833
/**
1834
* @serial include
1835
*/
1836
static class UnmodifiableNavigableMap<K,V>
1837
extends UnmodifiableSortedMap<K,V>
1838
implements NavigableMap<K,V>, Serializable {
1839
private static final long serialVersionUID = -4858195264774772197L;
1840
1841
/**
1842
* A class for the {@link EMPTY_NAVIGABLE_MAP} which needs readResolve
1843
* to preserve singleton property.
1844
*
1845
* @param <K> type of keys, if there were any, and of bounds
1846
* @param <V> type of values, if there were any
1847
*/
1848
private static class EmptyNavigableMap<K,V> extends UnmodifiableNavigableMap<K,V>
1849
implements Serializable {
1850
1851
private static final long serialVersionUID = -2239321462712562324L;
1852
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
1853
EmptyNavigableMap() { super(new TreeMap<K,V>()); }
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1854
1855
@Override
1856
public NavigableSet<K> navigableKeySet()
1857
{ return emptyNavigableSet(); }
1858
1859
private Object readResolve() { return EMPTY_NAVIGABLE_MAP; }
duke
Initial load
Dec 1, 2007
1860
}
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1861
1862
/**
1863
* Singleton for {@link emptyNavigableMap()} which is also immutable.
1864
*/
1865
private static final EmptyNavigableMap<?,?> EMPTY_NAVIGABLE_MAP =
1866
new EmptyNavigableMap<>();
1867
1868
/**
1869
* The instance we wrap and protect.
1870
*/
1871
private final NavigableMap<K, ? extends V> nm;
1872
1873
UnmodifiableNavigableMap(NavigableMap<K, ? extends V> m)
1874
{super(m); nm = m;}
1875
1876
public K lowerKey(K key) { return nm.lowerKey(key); }
1877
public K floorKey(K key) { return nm.floorKey(key); }
1878
public K ceilingKey(K key) { return nm.ceilingKey(key); }
1879
public K higherKey(K key) { return nm.higherKey(key); }
1880
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
1881
@SuppressWarnings("unchecked")
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1882
public Entry<K, V> lowerEntry(K key) {
1883
Entry<K,V> lower = (Entry<K, V>) nm.lowerEntry(key);
1884
return (null != lower)
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
1885
? new UnmodifiableEntrySet.UnmodifiableEntry<>(lower)
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1886
: null;
duke
Initial load
Dec 1, 2007
1887
}
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1888
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
1889
@SuppressWarnings("unchecked")
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1890
public Entry<K, V> floorEntry(K key) {
1891
Entry<K,V> floor = (Entry<K, V>) nm.floorEntry(key);
1892
return (null != floor)
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
1893
? new UnmodifiableEntrySet.UnmodifiableEntry<>(floor)
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1894
: null;
duke
Initial load
Dec 1, 2007
1895
}
1896
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
1897
@SuppressWarnings("unchecked")
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1898
public Entry<K, V> ceilingEntry(K key) {
1899
Entry<K,V> ceiling = (Entry<K, V>) nm.ceilingEntry(key);
1900
return (null != ceiling)
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
1901
? new UnmodifiableEntrySet.UnmodifiableEntry<>(ceiling)
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1902
: null;
1903
}
1904
1905
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
1906
@SuppressWarnings("unchecked")
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1907
public Entry<K, V> higherEntry(K key) {
1908
Entry<K,V> higher = (Entry<K, V>) nm.higherEntry(key);
1909
return (null != higher)
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
1910
? new UnmodifiableEntrySet.UnmodifiableEntry<>(higher)
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1911
: null;
1912
}
1913
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
1914
@SuppressWarnings("unchecked")
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1915
public Entry<K, V> firstEntry() {
1916
Entry<K,V> first = (Entry<K, V>) nm.firstEntry();
1917
return (null != first)
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
1918
? new UnmodifiableEntrySet.UnmodifiableEntry<>(first)
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1919
: null;
1920
}
1921
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
1922
@SuppressWarnings("unchecked")
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1923
public Entry<K, V> lastEntry() {
1924
Entry<K,V> last = (Entry<K, V>) nm.lastEntry();
1925
return (null != last)
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
1926
? new UnmodifiableEntrySet.UnmodifiableEntry<>(last)
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1927
: null;
1928
}
1929
1930
public Entry<K, V> pollFirstEntry()
1931
{ throw new UnsupportedOperationException(); }
1932
public Entry<K, V> pollLastEntry()
1933
{ throw new UnsupportedOperationException(); }
1934
public NavigableMap<K, V> descendingMap()
1935
{ return unmodifiableNavigableMap(nm.descendingMap()); }
1936
public NavigableSet<K> navigableKeySet()
1937
{ return unmodifiableNavigableSet(nm.navigableKeySet()); }
1938
public NavigableSet<K> descendingKeySet()
1939
{ return unmodifiableNavigableSet(nm.descendingKeySet()); }
duke
Initial load
Dec 1, 2007
1940
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
1941
public NavigableMap<K, V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
1942
return unmodifiableNavigableMap(
1943
nm.subMap(fromKey, fromInclusive, toKey, toInclusive));
1944
}
1945
1946
public NavigableMap<K, V> headMap(K toKey, boolean inclusive)
1947
{ return unmodifiableNavigableMap(nm.headMap(toKey, inclusive)); }
1948
public NavigableMap<K, V> tailMap(K fromKey, boolean inclusive)
1949
{ return unmodifiableNavigableMap(nm.tailMap(fromKey, inclusive)); }
1950
}
duke
Initial load
Dec 1, 2007
1951
1952
// Synch Wrappers
1953
1954
/**
1955
* Returns a synchronized (thread-safe) collection backed by the specified
1956
* collection. In order to guarantee serial access, it is critical that
1957
* <strong>all</strong> access to the backing collection is accomplished
1958
* through the returned collection.<p>
1959
*
1960
* It is imperative that the user manually synchronize on the returned
henryjen
8023275: Wrapping collections should override default methods
Aug 27, 2013
1961
* collection when traversing it via {@link Iterator}, {@link Spliterator}
1962
* or {@link Stream}:
duke
Initial load
Dec 1, 2007
1963
* <pre>
1964
* Collection c = Collections.synchronizedCollection(myCollection);
1965
* ...
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
1966
* synchronized (c) {
duke
Initial load
Dec 1, 2007
1967
* Iterator i = c.iterator(); // Must be in the synchronized block
1968
* while (i.hasNext())
1969
* foo(i.next());
1970
* }
1971
* </pre>
1972
* Failure to follow this advice may result in non-deterministic behavior.
1973
*
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
1974
* <p>The returned collection does <i>not</i> pass the {@code hashCode}
1975
* and {@code equals} operations through to the backing collection, but
1976
* relies on {@code Object}'s equals and hashCode methods. This is
duke
Initial load
Dec 1, 2007
1977
* necessary to preserve the contracts of these operations in the case
1978
* that the backing collection is a set or a list.<p>
1979
*
1980
* The returned collection will be serializable if the specified collection
1981
* is serializable.
1982
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
1983
* @param <T> the class of the objects in the collection
duke
Initial load
Dec 1, 2007
1984
* @param c the collection to be "wrapped" in a synchronized collection.
1985
* @return a synchronized view of the specified collection.
1986
*/
1987
public static <T> Collection<T> synchronizedCollection(Collection<T> c) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
1988
return new SynchronizedCollection<>(c);
duke
Initial load
Dec 1, 2007
1989
}
1990
1991
static <T> Collection<T> synchronizedCollection(Collection<T> c, Object mutex) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
1992
return new SynchronizedCollection<>(c, mutex);
duke
Initial load
Dec 1, 2007
1993
}
1994
1995
/**
1996
* @serial include
1997
*/
1998
static class SynchronizedCollection<E> implements Collection<E>, Serializable {
1999
private static final long serialVersionUID = 3053995032091335093L;
2000
2001
final Collection<E> c; // Backing Collection
2002
final Object mutex; // Object on which to synchronize
2003
2004
SynchronizedCollection(Collection<E> c) {
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
2005
this.c = Objects.requireNonNull(c);
duke
Initial load
Dec 1, 2007
2006
mutex = this;
2007
}
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
2008
duke
Initial load
Dec 1, 2007
2009
SynchronizedCollection(Collection<E> c, Object mutex) {
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
2010
this.c = Objects.requireNonNull(c);
2011
this.mutex = Objects.requireNonNull(mutex);
duke
Initial load
Dec 1, 2007
2012
}
2013
2014
public int size() {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2015
synchronized (mutex) {return c.size();}
duke
Initial load
Dec 1, 2007
2016
}
2017
public boolean isEmpty() {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2018
synchronized (mutex) {return c.isEmpty();}
duke
Initial load
Dec 1, 2007
2019
}
2020
public boolean contains(Object o) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2021
synchronized (mutex) {return c.contains(o);}
duke
Initial load
Dec 1, 2007
2022
}
2023
public Object[] toArray() {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2024
synchronized (mutex) {return c.toArray();}
duke
Initial load
Dec 1, 2007
2025
}
2026
public <T> T[] toArray(T[] a) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2027
synchronized (mutex) {return c.toArray(a);}
duke
Initial load
Dec 1, 2007
2028
}
2029
2030
public Iterator<E> iterator() {
2031
return c.iterator(); // Must be manually synched by user!
2032
}
2033
2034
public boolean add(E e) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2035
synchronized (mutex) {return c.add(e);}
duke
Initial load
Dec 1, 2007
2036
}
2037
public boolean remove(Object o) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2038
synchronized (mutex) {return c.remove(o);}
duke
Initial load
Dec 1, 2007
2039
}
2040
2041
public boolean containsAll(Collection<?> coll) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2042
synchronized (mutex) {return c.containsAll(coll);}
duke
Initial load
Dec 1, 2007
2043
}
2044
public boolean addAll(Collection<? extends E> coll) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2045
synchronized (mutex) {return c.addAll(coll);}
duke
Initial load
Dec 1, 2007
2046
}
2047
public boolean removeAll(Collection<?> coll) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2048
synchronized (mutex) {return c.removeAll(coll);}
duke
Initial load
Dec 1, 2007
2049
}
2050
public boolean retainAll(Collection<?> coll) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2051
synchronized (mutex) {return c.retainAll(coll);}
duke
Initial load
Dec 1, 2007
2052
}
2053
public void clear() {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2054
synchronized (mutex) {c.clear();}
duke
Initial load
Dec 1, 2007
2055
}
2056
public String toString() {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2057
synchronized (mutex) {return c.toString();}
duke
Initial load
Dec 1, 2007
2058
}
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
2059
// Override default methods in Collection
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
2060
@Override
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
2061
public void forEach(Consumer<? super E> consumer) {
2062
synchronized (mutex) {c.forEach(consumer);}
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
2063
}
2064
@Override
2065
public boolean removeIf(Predicate<? super E> filter) {
2066
synchronized (mutex) {return c.removeIf(filter);}
2067
}
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
2068
@Override
2069
public Spliterator<E> spliterator() {
2070
return c.spliterator(); // Must be manually synched by user!
2071
}
henryjen
8023275: Wrapping collections should override default methods
Aug 27, 2013
2072
@Override
2073
public Stream<E> stream() {
2074
return c.stream(); // Must be manually synched by user!
2075
}
2076
@Override
2077
public Stream<E> parallelStream() {
2078
return c.parallelStream(); // Must be manually synched by user!
2079
}
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
2080
private void writeObject(ObjectOutputStream s) throws IOException {
2081
synchronized (mutex) {s.defaultWriteObject();}
2082
}
duke
Initial load
Dec 1, 2007
2083
}
2084
2085
/**
2086
* Returns a synchronized (thread-safe) set backed by the specified
2087
* set. In order to guarantee serial access, it is critical that
2088
* <strong>all</strong> access to the backing set is accomplished
2089
* through the returned set.<p>
2090
*
2091
* It is imperative that the user manually synchronize on the returned
2092
* set when iterating over it:
2093
* <pre>
2094
* Set s = Collections.synchronizedSet(new HashSet());
2095
* ...
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2096
* synchronized (s) {
duke
Initial load
Dec 1, 2007
2097
* Iterator i = s.iterator(); // Must be in the synchronized block
2098
* while (i.hasNext())
2099
* foo(i.next());
2100
* }
2101
* </pre>
2102
* Failure to follow this advice may result in non-deterministic behavior.
2103
*
2104
* <p>The returned set will be serializable if the specified set is
2105
* serializable.
2106
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
2107
* @param <T> the class of the objects in the set
duke
Initial load
Dec 1, 2007
2108
* @param s the set to be "wrapped" in a synchronized set.
2109
* @return a synchronized view of the specified set.
2110
*/
2111
public static <T> Set<T> synchronizedSet(Set<T> s) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
2112
return new SynchronizedSet<>(s);
duke
Initial load
Dec 1, 2007
2113
}
2114
2115
static <T> Set<T> synchronizedSet(Set<T> s, Object mutex) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
2116
return new SynchronizedSet<>(s, mutex);
duke
Initial load
Dec 1, 2007
2117
}
2118
2119
/**
2120
* @serial include
2121
*/
2122
static class SynchronizedSet<E>
2123
extends SynchronizedCollection<E>
2124
implements Set<E> {
2125
private static final long serialVersionUID = 487447009682186044L;
2126
2127
SynchronizedSet(Set<E> s) {
2128
super(s);
2129
}
2130
SynchronizedSet(Set<E> s, Object mutex) {
2131
super(s, mutex);
2132
}
2133
2134
public boolean equals(Object o) {
coffeys
7144488: Infinite recursion for some equals tests in Collections
Feb 24, 2012
2135
if (this == o)
2136
return true;
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2137
synchronized (mutex) {return c.equals(o);}
duke
Initial load
Dec 1, 2007
2138
}
2139
public int hashCode() {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2140
synchronized (mutex) {return c.hashCode();}
duke
Initial load
Dec 1, 2007
2141
}
2142
}
2143
2144
/**
2145
* Returns a synchronized (thread-safe) sorted set backed by the specified
2146
* sorted set. In order to guarantee serial access, it is critical that
2147
* <strong>all</strong> access to the backing sorted set is accomplished
2148
* through the returned sorted set (or its views).<p>
2149
*
2150
* It is imperative that the user manually synchronize on the returned
2151
* sorted set when iterating over it or any of its <tt>subSet</tt>,
2152
* <tt>headSet</tt>, or <tt>tailSet</tt> views.
2153
* <pre>
2154
* SortedSet s = Collections.synchronizedSortedSet(new TreeSet());
2155
* ...
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2156
* synchronized (s) {
duke
Initial load
Dec 1, 2007
2157
* Iterator i = s.iterator(); // Must be in the synchronized block
2158
* while (i.hasNext())
2159
* foo(i.next());
2160
* }
2161
* </pre>
2162
* or:
2163
* <pre>
2164
* SortedSet s = Collections.synchronizedSortedSet(new TreeSet());
2165
* SortedSet s2 = s.headSet(foo);
2166
* ...
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2167
* synchronized (s) { // Note: s, not s2!!!
duke
Initial load
Dec 1, 2007
2168
* Iterator i = s2.iterator(); // Must be in the synchronized block
2169
* while (i.hasNext())
2170
* foo(i.next());
2171
* }
2172
* </pre>
2173
* Failure to follow this advice may result in non-deterministic behavior.
2174
*
2175
* <p>The returned sorted set will be serializable if the specified
2176
* sorted set is serializable.
2177
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
2178
* @param <T> the class of the objects in the set
duke
Initial load
Dec 1, 2007
2179
* @param s the sorted set to be "wrapped" in a synchronized sorted set.
2180
* @return a synchronized view of the specified sorted set.
2181
*/
2182
public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
2183
return new SynchronizedSortedSet<>(s);
duke
Initial load
Dec 1, 2007
2184
}
2185
2186
/**
2187
* @serial include
2188
*/
2189
static class SynchronizedSortedSet<E>
2190
extends SynchronizedSet<E>
2191
implements SortedSet<E>
2192
{
2193
private static final long serialVersionUID = 8695801310862127406L;
2194
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2195
private final SortedSet<E> ss;
duke
Initial load
Dec 1, 2007
2196
2197
SynchronizedSortedSet(SortedSet<E> s) {
2198
super(s);
2199
ss = s;
2200
}
2201
SynchronizedSortedSet(SortedSet<E> s, Object mutex) {
2202
super(s, mutex);
2203
ss = s;
2204
}
2205
2206
public Comparator<? super E> comparator() {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2207
synchronized (mutex) {return ss.comparator();}
duke
Initial load
Dec 1, 2007
2208
}
2209
2210
public SortedSet<E> subSet(E fromElement, E toElement) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2211
synchronized (mutex) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
2212
return new SynchronizedSortedSet<>(
duke
Initial load
Dec 1, 2007
2213
ss.subSet(fromElement, toElement), mutex);
2214
}
2215
}
2216
public SortedSet<E> headSet(E toElement) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2217
synchronized (mutex) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
2218
return new SynchronizedSortedSet<>(ss.headSet(toElement), mutex);
duke
Initial load
Dec 1, 2007
2219
}
2220
}
2221
public SortedSet<E> tailSet(E fromElement) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2222
synchronized (mutex) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
2223
return new SynchronizedSortedSet<>(ss.tailSet(fromElement),mutex);
duke
Initial load
Dec 1, 2007
2224
}
2225
}
2226
2227
public E first() {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2228
synchronized (mutex) {return ss.first();}
duke
Initial load
Dec 1, 2007
2229
}
2230
public E last() {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2231
synchronized (mutex) {return ss.last();}
duke
Initial load
Dec 1, 2007
2232
}
2233
}
2234
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
2235
/**
2236
* Returns a synchronized (thread-safe) navigable set backed by the
2237
* specified navigable set. In order to guarantee serial access, it is
2238
* critical that <strong>all</strong> access to the backing navigable set is
2239
* accomplished through the returned navigable set (or its views).<p>
2240
*
2241
* It is imperative that the user manually synchronize on the returned
2242
* navigable set when iterating over it or any of its {@code subSet},
2243
* {@code headSet}, or {@code tailSet} views.
2244
* <pre>
2245
* NavigableSet s = Collections.synchronizedNavigableSet(new TreeSet());
2246
* ...
2247
* synchronized (s) {
2248
* Iterator i = s.iterator(); // Must be in the synchronized block
2249
* while (i.hasNext())
2250
* foo(i.next());
2251
* }
2252
* </pre>
2253
* or:
2254
* <pre>
2255
* NavigableSet s = Collections.synchronizedNavigableSet(new TreeSet());
2256
* NavigableSet s2 = s.headSet(foo, true);
2257
* ...
2258
* synchronized (s) { // Note: s, not s2!!!
2259
* Iterator i = s2.iterator(); // Must be in the synchronized block
2260
* while (i.hasNext())
2261
* foo(i.next());
2262
* }
2263
* </pre>
2264
* Failure to follow this advice may result in non-deterministic behavior.
2265
*
2266
* <p>The returned navigable set will be serializable if the specified
2267
* navigable set is serializable.
2268
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
2269
* @param <T> the class of the objects in the set
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
2270
* @param s the navigable set to be "wrapped" in a synchronized navigable
2271
* set
2272
* @return a synchronized view of the specified navigable set
2273
* @since 1.8
2274
*/
2275
public static <T> NavigableSet<T> synchronizedNavigableSet(NavigableSet<T> s) {
2276
return new SynchronizedNavigableSet<>(s);
2277
}
2278
2279
/**
2280
* @serial include
2281
*/
2282
static class SynchronizedNavigableSet<E>
2283
extends SynchronizedSortedSet<E>
2284
implements NavigableSet<E>
2285
{
2286
private static final long serialVersionUID = -5505529816273629798L;
2287
2288
private final NavigableSet<E> ns;
2289
2290
SynchronizedNavigableSet(NavigableSet<E> s) {
2291
super(s);
2292
ns = s;
2293
}
2294
2295
SynchronizedNavigableSet(NavigableSet<E> s, Object mutex) {
2296
super(s, mutex);
2297
ns = s;
2298
}
2299
public E lower(E e) { synchronized (mutex) {return ns.lower(e);} }
2300
public E floor(E e) { synchronized (mutex) {return ns.floor(e);} }
2301
public E ceiling(E e) { synchronized (mutex) {return ns.ceiling(e);} }
2302
public E higher(E e) { synchronized (mutex) {return ns.higher(e);} }
2303
public E pollFirst() { synchronized (mutex) {return ns.pollFirst();} }
2304
public E pollLast() { synchronized (mutex) {return ns.pollLast();} }
2305
2306
public NavigableSet<E> descendingSet() {
2307
synchronized (mutex) {
2308
return new SynchronizedNavigableSet<>(ns.descendingSet(), mutex);
2309
}
2310
}
2311
2312
public Iterator<E> descendingIterator()
2313
{ synchronized (mutex) { return descendingSet().iterator(); } }
2314
2315
public NavigableSet<E> subSet(E fromElement, E toElement) {
2316
synchronized (mutex) {
2317
return new SynchronizedNavigableSet<>(ns.subSet(fromElement, true, toElement, false), mutex);
2318
}
2319
}
2320
public NavigableSet<E> headSet(E toElement) {
2321
synchronized (mutex) {
2322
return new SynchronizedNavigableSet<>(ns.headSet(toElement, false), mutex);
2323
}
2324
}
2325
public NavigableSet<E> tailSet(E fromElement) {
2326
synchronized (mutex) {
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
2327
return new SynchronizedNavigableSet<>(ns.tailSet(fromElement, true), mutex);
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
2328
}
2329
}
2330
2331
public NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) {
2332
synchronized (mutex) {
2333
return new SynchronizedNavigableSet<>(ns.subSet(fromElement, fromInclusive, toElement, toInclusive), mutex);
2334
}
2335
}
2336
2337
public NavigableSet<E> headSet(E toElement, boolean inclusive) {
2338
synchronized (mutex) {
2339
return new SynchronizedNavigableSet<>(ns.headSet(toElement, inclusive), mutex);
2340
}
2341
}
2342
2343
public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
2344
synchronized (mutex) {
mduigou
8048209: Collections.synchronizedNavigableSet().tailSet(Object,boolea…
Jul 24, 2014
2345
return new SynchronizedNavigableSet<>(ns.tailSet(fromElement, inclusive), mutex);
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
2346
}
2347
}
2348
}
2349
duke
Initial load
Dec 1, 2007
2350
/**
2351
* Returns a synchronized (thread-safe) list backed by the specified
2352
* list. In order to guarantee serial access, it is critical that
2353
* <strong>all</strong> access to the backing list is accomplished
2354
* through the returned list.<p>
2355
*
2356
* It is imperative that the user manually synchronize on the returned
2357
* list when iterating over it:
2358
* <pre>
2359
* List list = Collections.synchronizedList(new ArrayList());
2360
* ...
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2361
* synchronized (list) {
duke
Initial load
Dec 1, 2007
2362
* Iterator i = list.iterator(); // Must be in synchronized block
2363
* while (i.hasNext())
2364
* foo(i.next());
2365
* }
2366
* </pre>
2367
* Failure to follow this advice may result in non-deterministic behavior.
2368
*
2369
* <p>The returned list will be serializable if the specified list is
2370
* serializable.
2371
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
2372
* @param <T> the class of the objects in the list
duke
Initial load
Dec 1, 2007
2373
* @param list the list to be "wrapped" in a synchronized list.
2374
* @return a synchronized view of the specified list.
2375
*/
2376
public static <T> List<T> synchronizedList(List<T> list) {
2377
return (list instanceof RandomAccess ?
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
2378
new SynchronizedRandomAccessList<>(list) :
2379
new SynchronizedList<>(list));
duke
Initial load
Dec 1, 2007
2380
}
2381
2382
static <T> List<T> synchronizedList(List<T> list, Object mutex) {
2383
return (list instanceof RandomAccess ?
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
2384
new SynchronizedRandomAccessList<>(list, mutex) :
2385
new SynchronizedList<>(list, mutex));
duke
Initial load
Dec 1, 2007
2386
}
2387
2388
/**
2389
* @serial include
2390
*/
2391
static class SynchronizedList<E>
2392
extends SynchronizedCollection<E>
2393
implements List<E> {
2394
private static final long serialVersionUID = -7754090372962971524L;
2395
2396
final List<E> list;
2397
2398
SynchronizedList(List<E> list) {
2399
super(list);
2400
this.list = list;
2401
}
2402
SynchronizedList(List<E> list, Object mutex) {
2403
super(list, mutex);
2404
this.list = list;
2405
}
2406
2407
public boolean equals(Object o) {
coffeys
7144488: Infinite recursion for some equals tests in Collections
Feb 24, 2012
2408
if (this == o)
2409
return true;
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2410
synchronized (mutex) {return list.equals(o);}
duke
Initial load
Dec 1, 2007
2411
}
2412
public int hashCode() {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2413
synchronized (mutex) {return list.hashCode();}
duke
Initial load
Dec 1, 2007
2414
}
2415
2416
public E get(int index) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2417
synchronized (mutex) {return list.get(index);}
duke
Initial load
Dec 1, 2007
2418
}
2419
public E set(int index, E element) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2420
synchronized (mutex) {return list.set(index, element);}
duke
Initial load
Dec 1, 2007
2421
}
2422
public void add(int index, E element) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2423
synchronized (mutex) {list.add(index, element);}
duke
Initial load
Dec 1, 2007
2424
}
2425
public E remove(int index) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2426
synchronized (mutex) {return list.remove(index);}
duke
Initial load
Dec 1, 2007
2427
}
2428
2429
public int indexOf(Object o) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2430
synchronized (mutex) {return list.indexOf(o);}
duke
Initial load
Dec 1, 2007
2431
}
2432
public int lastIndexOf(Object o) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2433
synchronized (mutex) {return list.lastIndexOf(o);}
duke
Initial load
Dec 1, 2007
2434
}
2435
2436
public boolean addAll(int index, Collection<? extends E> c) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2437
synchronized (mutex) {return list.addAll(index, c);}
duke
Initial load
Dec 1, 2007
2438
}
2439
2440
public ListIterator<E> listIterator() {
2441
return list.listIterator(); // Must be manually synched by user
2442
}
2443
2444
public ListIterator<E> listIterator(int index) {
2445
return list.listIterator(index); // Must be manually synched by user
2446
}
2447
2448
public List<E> subList(int fromIndex, int toIndex) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2449
synchronized (mutex) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
2450
return new SynchronizedList<>(list.subList(fromIndex, toIndex),
duke
Initial load
Dec 1, 2007
2451
mutex);
2452
}
2453
}
2454
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
2455
@Override
2456
public void replaceAll(UnaryOperator<E> operator) {
2457
synchronized (mutex) {list.replaceAll(operator);}
2458
}
2459
@Override
2460
public void sort(Comparator<? super E> c) {
2461
synchronized (mutex) {list.sort(c);}
2462
}
2463
duke
Initial load
Dec 1, 2007
2464
/**
2465
* SynchronizedRandomAccessList instances are serialized as
2466
* SynchronizedList instances to allow them to be deserialized
2467
* in pre-1.4 JREs (which do not have SynchronizedRandomAccessList).
2468
* This method inverts the transformation. As a beneficial
2469
* side-effect, it also grafts the RandomAccess marker onto
2470
* SynchronizedList instances that were serialized in pre-1.4 JREs.
2471
*
2472
* Note: Unfortunately, SynchronizedRandomAccessList instances
2473
* serialized in 1.4.1 and deserialized in 1.4 will become
2474
* SynchronizedList instances, as this method was missing in 1.4.
2475
*/
2476
private Object readResolve() {
2477
return (list instanceof RandomAccess
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
2478
? new SynchronizedRandomAccessList<>(list)
duke
Initial load
Dec 1, 2007
2479
: this);
2480
}
2481
}
2482
2483
/**
2484
* @serial include
2485
*/
2486
static class SynchronizedRandomAccessList<E>
2487
extends SynchronizedList<E>
2488
implements RandomAccess {
2489
2490
SynchronizedRandomAccessList(List<E> list) {
2491
super(list);
2492
}
2493
2494
SynchronizedRandomAccessList(List<E> list, Object mutex) {
2495
super(list, mutex);
2496
}
2497
2498
public List<E> subList(int fromIndex, int toIndex) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2499
synchronized (mutex) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
2500
return new SynchronizedRandomAccessList<>(
duke
Initial load
Dec 1, 2007
2501
list.subList(fromIndex, toIndex), mutex);
2502
}
2503
}
2504
2505
private static final long serialVersionUID = 1530674583602358482L;
2506
2507
/**
2508
* Allows instances to be deserialized in pre-1.4 JREs (which do
2509
* not have SynchronizedRandomAccessList). SynchronizedList has
2510
* a readResolve method that inverts this transformation upon
2511
* deserialization.
2512
*/
2513
private Object writeReplace() {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
2514
return new SynchronizedList<>(list);
duke
Initial load
Dec 1, 2007
2515
}
2516
}
2517
2518
/**
2519
* Returns a synchronized (thread-safe) map backed by the specified
2520
* map. In order to guarantee serial access, it is critical that
2521
* <strong>all</strong> access to the backing map is accomplished
2522
* through the returned map.<p>
2523
*
2524
* It is imperative that the user manually synchronize on the returned
2525
* map when iterating over any of its collection views:
2526
* <pre>
2527
* Map m = Collections.synchronizedMap(new HashMap());
2528
* ...
2529
* Set s = m.keySet(); // Needn't be in synchronized block
2530
* ...
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2531
* synchronized (m) { // Synchronizing on m, not s!
duke
Initial load
Dec 1, 2007
2532
* Iterator i = s.iterator(); // Must be in synchronized block
2533
* while (i.hasNext())
2534
* foo(i.next());
2535
* }
2536
* </pre>
2537
* Failure to follow this advice may result in non-deterministic behavior.
2538
*
2539
* <p>The returned map will be serializable if the specified map is
2540
* serializable.
2541
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
2542
* @param <K> the class of the map keys
2543
* @param <V> the class of the map values
duke
Initial load
Dec 1, 2007
2544
* @param m the map to be "wrapped" in a synchronized map.
2545
* @return a synchronized view of the specified map.
2546
*/
2547
public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
2548
return new SynchronizedMap<>(m);
duke
Initial load
Dec 1, 2007
2549
}
2550
2551
/**
2552
* @serial include
2553
*/
2554
private static class SynchronizedMap<K,V>
2555
implements Map<K,V>, Serializable {
2556
private static final long serialVersionUID = 1978198479659022715L;
2557
2558
private final Map<K,V> m; // Backing Map
2559
final Object mutex; // Object on which to synchronize
2560
2561
SynchronizedMap(Map<K,V> m) {
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
2562
this.m = Objects.requireNonNull(m);
duke
Initial load
Dec 1, 2007
2563
mutex = this;
2564
}
2565
2566
SynchronizedMap(Map<K,V> m, Object mutex) {
2567
this.m = m;
2568
this.mutex = mutex;
2569
}
2570
2571
public int size() {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2572
synchronized (mutex) {return m.size();}
duke
Initial load
Dec 1, 2007
2573
}
2574
public boolean isEmpty() {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2575
synchronized (mutex) {return m.isEmpty();}
duke
Initial load
Dec 1, 2007
2576
}
2577
public boolean containsKey(Object key) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2578
synchronized (mutex) {return m.containsKey(key);}
duke
Initial load
Dec 1, 2007
2579
}
2580
public boolean containsValue(Object value) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2581
synchronized (mutex) {return m.containsValue(value);}
duke
Initial load
Dec 1, 2007
2582
}
2583
public V get(Object key) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2584
synchronized (mutex) {return m.get(key);}
duke
Initial load
Dec 1, 2007
2585
}
2586
2587
public V put(K key, V value) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2588
synchronized (mutex) {return m.put(key, value);}
duke
Initial load
Dec 1, 2007
2589
}
2590
public V remove(Object key) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2591
synchronized (mutex) {return m.remove(key);}
duke
Initial load
Dec 1, 2007
2592
}
2593
public void putAll(Map<? extends K, ? extends V> map) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2594
synchronized (mutex) {m.putAll(map);}
duke
Initial load
Dec 1, 2007
2595
}
2596
public void clear() {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2597
synchronized (mutex) {m.clear();}
duke
Initial load
Dec 1, 2007
2598
}
2599
mduigou
8035284: Remove redundant initializations to null
Apr 11, 2014
2600
private transient Set<K> keySet;
2601
private transient Set<Map.Entry<K,V>> entrySet;
2602
private transient Collection<V> values;
duke
Initial load
Dec 1, 2007
2603
2604
public Set<K> keySet() {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2605
synchronized (mutex) {
duke
Initial load
Dec 1, 2007
2606
if (keySet==null)
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
2607
keySet = new SynchronizedSet<>(m.keySet(), mutex);
duke
Initial load
Dec 1, 2007
2608
return keySet;
2609
}
2610
}
2611
2612
public Set<Map.Entry<K,V>> entrySet() {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2613
synchronized (mutex) {
duke
Initial load
Dec 1, 2007
2614
if (entrySet==null)
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
2615
entrySet = new SynchronizedSet<>(m.entrySet(), mutex);
duke
Initial load
Dec 1, 2007
2616
return entrySet;
2617
}
2618
}
2619
2620
public Collection<V> values() {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2621
synchronized (mutex) {
duke
Initial load
Dec 1, 2007
2622
if (values==null)
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
2623
values = new SynchronizedCollection<>(m.values(), mutex);
duke
Initial load
Dec 1, 2007
2624
return values;
2625
}
2626
}
2627
2628
public boolean equals(Object o) {
coffeys
7144488: Infinite recursion for some equals tests in Collections
Feb 24, 2012
2629
if (this == o)
2630
return true;
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2631
synchronized (mutex) {return m.equals(o);}
duke
Initial load
Dec 1, 2007
2632
}
2633
public int hashCode() {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2634
synchronized (mutex) {return m.hashCode();}
duke
Initial load
Dec 1, 2007
2635
}
2636
public String toString() {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2637
synchronized (mutex) {return m.toString();}
duke
Initial load
Dec 1, 2007
2638
}
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
2639
2640
// Override default methods in Map
2641
@Override
2642
public V getOrDefault(Object k, V defaultValue) {
2643
synchronized (mutex) {return m.getOrDefault(k, defaultValue);}
2644
}
2645
@Override
2646
public void forEach(BiConsumer<? super K, ? super V> action) {
2647
synchronized (mutex) {m.forEach(action);}
2648
}
2649
@Override
2650
public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
2651
synchronized (mutex) {m.replaceAll(function);}
2652
}
2653
@Override
2654
public V putIfAbsent(K key, V value) {
2655
synchronized (mutex) {return m.putIfAbsent(key, value);}
2656
}
2657
@Override
2658
public boolean remove(Object key, Object value) {
2659
synchronized (mutex) {return m.remove(key, value);}
2660
}
2661
@Override
2662
public boolean replace(K key, V oldValue, V newValue) {
2663
synchronized (mutex) {return m.replace(key, oldValue, newValue);}
2664
}
2665
@Override
2666
public V replace(K key, V value) {
2667
synchronized (mutex) {return m.replace(key, value);}
2668
}
2669
@Override
2670
public V computeIfAbsent(K key,
2671
Function<? super K, ? extends V> mappingFunction) {
2672
synchronized (mutex) {return m.computeIfAbsent(key, mappingFunction);}
2673
}
2674
@Override
2675
public V computeIfPresent(K key,
2676
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
2677
synchronized (mutex) {return m.computeIfPresent(key, remappingFunction);}
2678
}
2679
@Override
2680
public V compute(K key,
2681
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
2682
synchronized (mutex) {return m.compute(key, remappingFunction);}
2683
}
2684
@Override
2685
public V merge(K key, V value,
2686
BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
2687
synchronized (mutex) {return m.merge(key, value, remappingFunction);}
2688
}
2689
duke
Initial load
Dec 1, 2007
2690
private void writeObject(ObjectOutputStream s) throws IOException {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2691
synchronized (mutex) {s.defaultWriteObject();}
duke
Initial load
Dec 1, 2007
2692
}
2693
}
2694
2695
/**
2696
* Returns a synchronized (thread-safe) sorted map backed by the specified
2697
* sorted map. In order to guarantee serial access, it is critical that
2698
* <strong>all</strong> access to the backing sorted map is accomplished
2699
* through the returned sorted map (or its views).<p>
2700
*
2701
* It is imperative that the user manually synchronize on the returned
2702
* sorted map when iterating over any of its collection views, or the
2703
* collections views of any of its <tt>subMap</tt>, <tt>headMap</tt> or
2704
* <tt>tailMap</tt> views.
2705
* <pre>
2706
* SortedMap m = Collections.synchronizedSortedMap(new TreeMap());
2707
* ...
2708
* Set s = m.keySet(); // Needn't be in synchronized block
2709
* ...
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2710
* synchronized (m) { // Synchronizing on m, not s!
duke
Initial load
Dec 1, 2007
2711
* Iterator i = s.iterator(); // Must be in synchronized block
2712
* while (i.hasNext())
2713
* foo(i.next());
2714
* }
2715
* </pre>
2716
* or:
2717
* <pre>
2718
* SortedMap m = Collections.synchronizedSortedMap(new TreeMap());
2719
* SortedMap m2 = m.subMap(foo, bar);
2720
* ...
2721
* Set s2 = m2.keySet(); // Needn't be in synchronized block
2722
* ...
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2723
* synchronized (m) { // Synchronizing on m, not m2 or s2!
duke
Initial load
Dec 1, 2007
2724
* Iterator i = s.iterator(); // Must be in synchronized block
2725
* while (i.hasNext())
2726
* foo(i.next());
2727
* }
2728
* </pre>
2729
* Failure to follow this advice may result in non-deterministic behavior.
2730
*
2731
* <p>The returned sorted map will be serializable if the specified
2732
* sorted map is serializable.
2733
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
2734
* @param <K> the class of the map keys
2735
* @param <V> the class of the map values
duke
Initial load
Dec 1, 2007
2736
* @param m the sorted map to be "wrapped" in a synchronized sorted map.
2737
* @return a synchronized view of the specified sorted map.
2738
*/
2739
public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
2740
return new SynchronizedSortedMap<>(m);
duke
Initial load
Dec 1, 2007
2741
}
2742
2743
/**
2744
* @serial include
2745
*/
2746
static class SynchronizedSortedMap<K,V>
2747
extends SynchronizedMap<K,V>
2748
implements SortedMap<K,V>
2749
{
2750
private static final long serialVersionUID = -8798146769416483793L;
2751
2752
private final SortedMap<K,V> sm;
2753
2754
SynchronizedSortedMap(SortedMap<K,V> m) {
2755
super(m);
2756
sm = m;
2757
}
2758
SynchronizedSortedMap(SortedMap<K,V> m, Object mutex) {
2759
super(m, mutex);
2760
sm = m;
2761
}
2762
2763
public Comparator<? super K> comparator() {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2764
synchronized (mutex) {return sm.comparator();}
duke
Initial load
Dec 1, 2007
2765
}
2766
2767
public SortedMap<K,V> subMap(K fromKey, K toKey) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2768
synchronized (mutex) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
2769
return new SynchronizedSortedMap<>(
duke
Initial load
Dec 1, 2007
2770
sm.subMap(fromKey, toKey), mutex);
2771
}
2772
}
2773
public SortedMap<K,V> headMap(K toKey) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2774
synchronized (mutex) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
2775
return new SynchronizedSortedMap<>(sm.headMap(toKey), mutex);
duke
Initial load
Dec 1, 2007
2776
}
2777
}
2778
public SortedMap<K,V> tailMap(K fromKey) {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2779
synchronized (mutex) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
2780
return new SynchronizedSortedMap<>(sm.tailMap(fromKey),mutex);
duke
Initial load
Dec 1, 2007
2781
}
2782
}
2783
2784
public K firstKey() {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2785
synchronized (mutex) {return sm.firstKey();}
duke
Initial load
Dec 1, 2007
2786
}
2787
public K lastKey() {
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
2788
synchronized (mutex) {return sm.lastKey();}
duke
Initial load
Dec 1, 2007
2789
}
2790
}
2791
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
2792
/**
2793
* Returns a synchronized (thread-safe) navigable map backed by the
2794
* specified navigable map. In order to guarantee serial access, it is
2795
* critical that <strong>all</strong> access to the backing navigable map is
2796
* accomplished through the returned navigable map (or its views).<p>
2797
*
2798
* It is imperative that the user manually synchronize on the returned
2799
* navigable map when iterating over any of its collection views, or the
2800
* collections views of any of its {@code subMap}, {@code headMap} or
2801
* {@code tailMap} views.
2802
* <pre>
2803
* NavigableMap m = Collections.synchronizedNavigableMap(new TreeMap());
2804
* ...
2805
* Set s = m.keySet(); // Needn't be in synchronized block
2806
* ...
2807
* synchronized (m) { // Synchronizing on m, not s!
2808
* Iterator i = s.iterator(); // Must be in synchronized block
2809
* while (i.hasNext())
2810
* foo(i.next());
2811
* }
2812
* </pre>
2813
* or:
2814
* <pre>
2815
* NavigableMap m = Collections.synchronizedNavigableMap(new TreeMap());
2816
* NavigableMap m2 = m.subMap(foo, true, bar, false);
2817
* ...
2818
* Set s2 = m2.keySet(); // Needn't be in synchronized block
2819
* ...
2820
* synchronized (m) { // Synchronizing on m, not m2 or s2!
2821
* Iterator i = s.iterator(); // Must be in synchronized block
2822
* while (i.hasNext())
2823
* foo(i.next());
2824
* }
2825
* </pre>
2826
* Failure to follow this advice may result in non-deterministic behavior.
2827
*
2828
* <p>The returned navigable map will be serializable if the specified
2829
* navigable map is serializable.
2830
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
2831
* @param <K> the class of the map keys
2832
* @param <V> the class of the map values
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
2833
* @param m the navigable map to be "wrapped" in a synchronized navigable
2834
* map
2835
* @return a synchronized view of the specified navigable map.
2836
* @since 1.8
2837
*/
2838
public static <K,V> NavigableMap<K,V> synchronizedNavigableMap(NavigableMap<K,V> m) {
2839
return new SynchronizedNavigableMap<>(m);
2840
}
2841
2842
/**
2843
* A synchronized NavigableMap.
2844
*
2845
* @serial include
2846
*/
2847
static class SynchronizedNavigableMap<K,V>
2848
extends SynchronizedSortedMap<K,V>
2849
implements NavigableMap<K,V>
2850
{
2851
private static final long serialVersionUID = 699392247599746807L;
2852
2853
private final NavigableMap<K,V> nm;
2854
2855
SynchronizedNavigableMap(NavigableMap<K,V> m) {
2856
super(m);
2857
nm = m;
2858
}
2859
SynchronizedNavigableMap(NavigableMap<K,V> m, Object mutex) {
2860
super(m, mutex);
2861
nm = m;
2862
}
2863
2864
public Entry<K, V> lowerEntry(K key)
2865
{ synchronized (mutex) { return nm.lowerEntry(key); } }
2866
public K lowerKey(K key)
2867
{ synchronized (mutex) { return nm.lowerKey(key); } }
2868
public Entry<K, V> floorEntry(K key)
2869
{ synchronized (mutex) { return nm.floorEntry(key); } }
2870
public K floorKey(K key)
2871
{ synchronized (mutex) { return nm.floorKey(key); } }
2872
public Entry<K, V> ceilingEntry(K key)
2873
{ synchronized (mutex) { return nm.ceilingEntry(key); } }
2874
public K ceilingKey(K key)
2875
{ synchronized (mutex) { return nm.ceilingKey(key); } }
2876
public Entry<K, V> higherEntry(K key)
2877
{ synchronized (mutex) { return nm.higherEntry(key); } }
2878
public K higherKey(K key)
2879
{ synchronized (mutex) { return nm.higherKey(key); } }
2880
public Entry<K, V> firstEntry()
2881
{ synchronized (mutex) { return nm.firstEntry(); } }
2882
public Entry<K, V> lastEntry()
2883
{ synchronized (mutex) { return nm.lastEntry(); } }
2884
public Entry<K, V> pollFirstEntry()
2885
{ synchronized (mutex) { return nm.pollFirstEntry(); } }
2886
public Entry<K, V> pollLastEntry()
2887
{ synchronized (mutex) { return nm.pollLastEntry(); } }
2888
2889
public NavigableMap<K, V> descendingMap() {
2890
synchronized (mutex) {
2891
return
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
2892
new SynchronizedNavigableMap<>(nm.descendingMap(), mutex);
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
2893
}
2894
}
2895
2896
public NavigableSet<K> keySet() {
2897
return navigableKeySet();
2898
}
2899
2900
public NavigableSet<K> navigableKeySet() {
2901
synchronized (mutex) {
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
2902
return new SynchronizedNavigableSet<>(nm.navigableKeySet(), mutex);
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
2903
}
2904
}
2905
2906
public NavigableSet<K> descendingKeySet() {
2907
synchronized (mutex) {
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
2908
return new SynchronizedNavigableSet<>(nm.descendingKeySet(), mutex);
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
2909
}
2910
}
2911
2912
2913
public SortedMap<K,V> subMap(K fromKey, K toKey) {
2914
synchronized (mutex) {
2915
return new SynchronizedNavigableMap<>(
2916
nm.subMap(fromKey, true, toKey, false), mutex);
2917
}
2918
}
2919
public SortedMap<K,V> headMap(K toKey) {
2920
synchronized (mutex) {
2921
return new SynchronizedNavigableMap<>(nm.headMap(toKey, false), mutex);
2922
}
2923
}
2924
public SortedMap<K,V> tailMap(K fromKey) {
2925
synchronized (mutex) {
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
2926
return new SynchronizedNavigableMap<>(nm.tailMap(fromKey, true),mutex);
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
2927
}
2928
}
2929
2930
public NavigableMap<K, V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
2931
synchronized (mutex) {
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
2932
return new SynchronizedNavigableMap<>(
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
2933
nm.subMap(fromKey, fromInclusive, toKey, toInclusive), mutex);
2934
}
2935
}
2936
2937
public NavigableMap<K, V> headMap(K toKey, boolean inclusive) {
2938
synchronized (mutex) {
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
2939
return new SynchronizedNavigableMap<>(
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
2940
nm.headMap(toKey, inclusive), mutex);
2941
}
2942
}
2943
2944
public NavigableMap<K, V> tailMap(K fromKey, boolean inclusive) {
2945
synchronized (mutex) {
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
2946
return new SynchronizedNavigableMap<>(
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
2947
nm.tailMap(fromKey, inclusive), mutex);
2948
}
2949
}
2950
}
2951
duke
Initial load
Dec 1, 2007
2952
// Dynamically typesafe collection wrappers
2953
2954
/**
2955
* Returns a dynamically typesafe view of the specified collection.
2956
* Any attempt to insert an element of the wrong type will result in an
2957
* immediate {@link ClassCastException}. Assuming a collection
2958
* contains no incorrectly typed elements prior to the time a
2959
* dynamically typesafe view is generated, and that all subsequent
2960
* access to the collection takes place through the view, it is
2961
* <i>guaranteed</i> that the collection cannot contain an incorrectly
2962
* typed element.
2963
*
2964
* <p>The generics mechanism in the language provides compile-time
2965
* (static) type checking, but it is possible to defeat this mechanism
2966
* with unchecked casts. Usually this is not a problem, as the compiler
2967
* issues warnings on all such unchecked operations. There are, however,
2968
* times when static type checking alone is not sufficient. For example,
2969
* suppose a collection is passed to a third-party library and it is
2970
* imperative that the library code not corrupt the collection by
2971
* inserting an element of the wrong type.
2972
*
2973
* <p>Another use of dynamically typesafe views is debugging. Suppose a
2974
* program fails with a {@code ClassCastException}, indicating that an
2975
* incorrectly typed element was put into a parameterized collection.
2976
* Unfortunately, the exception can occur at any time after the erroneous
2977
* element is inserted, so it typically provides little or no information
2978
* as to the real source of the problem. If the problem is reproducible,
2979
* one can quickly determine its source by temporarily modifying the
2980
* program to wrap the collection with a dynamically typesafe view.
2981
* For example, this declaration:
2982
* <pre> {@code
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
2983
* Collection<String> c = new HashSet<>();
duke
Initial load
Dec 1, 2007
2984
* }</pre>
2985
* may be replaced temporarily by this one:
2986
* <pre> {@code
2987
* Collection<String> c = Collections.checkedCollection(
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
2988
* new HashSet<>(), String.class);
duke
Initial load
Dec 1, 2007
2989
* }</pre>
2990
* Running the program again will cause it to fail at the point where
2991
* an incorrectly typed element is inserted into the collection, clearly
2992
* identifying the source of the problem. Once the problem is fixed, the
2993
* modified declaration may be reverted back to the original.
2994
*
2995
* <p>The returned collection does <i>not</i> pass the hashCode and equals
2996
* operations through to the backing collection, but relies on
2997
* {@code Object}'s {@code equals} and {@code hashCode} methods. This
2998
* is necessary to preserve the contracts of these operations in the case
2999
* that the backing collection is a set or a list.
3000
*
3001
* <p>The returned collection will be serializable if the specified
3002
* collection is serializable.
3003
*
3004
* <p>Since {@code null} is considered to be a value of any reference
3005
* type, the returned collection permits insertion of null elements
3006
* whenever the backing collection does.
3007
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
3008
* @param <E> the class of the objects in the collection
duke
Initial load
Dec 1, 2007
3009
* @param c the collection for which a dynamically typesafe view is to be
3010
* returned
3011
* @param type the type of element that {@code c} is permitted to hold
3012
* @return a dynamically typesafe view of the specified collection
3013
* @since 1.5
3014
*/
3015
public static <E> Collection<E> checkedCollection(Collection<E> c,
3016
Class<E> type) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
3017
return new CheckedCollection<>(c, type);
duke
Initial load
Dec 1, 2007
3018
}
3019
3020
@SuppressWarnings("unchecked")
3021
static <T> T[] zeroLengthArray(Class<T> type) {
3022
return (T[]) Array.newInstance(type, 0);
3023
}
3024
3025
/**
3026
* @serial include
3027
*/
3028
static class CheckedCollection<E> implements Collection<E>, Serializable {
3029
private static final long serialVersionUID = 1578914078182001775L;
3030
3031
final Collection<E> c;
3032
final Class<E> type;
3033
mduigou
8047795: Collections.checkedList checking bypassed by List.replaceAll
Jun 25, 2014
3034
@SuppressWarnings("unchecked")
3035
E typeCheck(Object o) {
duke
Initial load
Dec 1, 2007
3036
if (o != null && !type.isInstance(o))
3037
throw new ClassCastException(badElementMsg(o));
mduigou
8047795: Collections.checkedList checking bypassed by List.replaceAll
Jun 25, 2014
3038
return (E) o;
duke
Initial load
Dec 1, 2007
3039
}
3040
3041
private String badElementMsg(Object o) {
3042
return "Attempt to insert " + o.getClass() +
3043
" element into collection with element type " + type;
3044
}
3045
3046
CheckedCollection(Collection<E> c, Class<E> type) {
mduigou
8047795: Collections.checkedList checking bypassed by List.replaceAll
Jun 25, 2014
3047
this.c = Objects.requireNonNull(c, "c");
3048
this.type = Objects.requireNonNull(type, "type");
duke
Initial load
Dec 1, 2007
3049
}
3050
3051
public int size() { return c.size(); }
3052
public boolean isEmpty() { return c.isEmpty(); }
3053
public boolean contains(Object o) { return c.contains(o); }
3054
public Object[] toArray() { return c.toArray(); }
3055
public <T> T[] toArray(T[] a) { return c.toArray(a); }
3056
public String toString() { return c.toString(); }
3057
public boolean remove(Object o) { return c.remove(o); }
3058
public void clear() { c.clear(); }
3059
3060
public boolean containsAll(Collection<?> coll) {
3061
return c.containsAll(coll);
3062
}
3063
public boolean removeAll(Collection<?> coll) {
3064
return c.removeAll(coll);
3065
}
3066
public boolean retainAll(Collection<?> coll) {
3067
return c.retainAll(coll);
3068
}
3069
3070
public Iterator<E> iterator() {
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
3071
// JDK-6363904 - unwrapped iterator could be typecast to
3072
// ListIterator with unsafe set()
duke
Initial load
Dec 1, 2007
3073
final Iterator<E> it = c.iterator();
3074
return new Iterator<E>() {
3075
public boolean hasNext() { return it.hasNext(); }
3076
public E next() { return it.next(); }
3077
public void remove() { it.remove(); }};
3078
}
3079
mduigou
8048207: Collections.checkedQueue.offer() calls add on wrapped queue
Jun 27, 2014
3080
public boolean add(E e) { return c.add(typeCheck(e)); }
duke
Initial load
Dec 1, 2007
3081
mduigou
8035284: Remove redundant initializations to null
Apr 11, 2014
3082
private E[] zeroLengthElementArray; // Lazily initialized
duke
Initial load
Dec 1, 2007
3083
3084
private E[] zeroLengthElementArray() {
3085
return zeroLengthElementArray != null ? zeroLengthElementArray :
3086
(zeroLengthElementArray = zeroLengthArray(type));
3087
}
3088
3089
@SuppressWarnings("unchecked")
3090
Collection<E> checkedCopyOf(Collection<? extends E> coll) {
mduigou
8047795: Collections.checkedList checking bypassed by List.replaceAll
Jun 25, 2014
3091
Object[] a;
duke
Initial load
Dec 1, 2007
3092
try {
3093
E[] z = zeroLengthElementArray();
3094
a = coll.toArray(z);
3095
// Defend against coll violating the toArray contract
3096
if (a.getClass() != z.getClass())
3097
a = Arrays.copyOf(a, a.length, z.getClass());
3098
} catch (ArrayStoreException ignore) {
3099
// To get better and consistent diagnostics,
3100
// we call typeCheck explicitly on each element.
3101
// We call clone() to defend against coll retaining a
3102
// reference to the returned array and storing a bad
3103
// element into it after it has been type checked.
3104
a = coll.toArray().clone();
3105
for (Object o : a)
3106
typeCheck(o);
3107
}
3108
// A slight abuse of the type system, but safe here.
3109
return (Collection<E>) Arrays.asList(a);
3110
}
3111
3112
public boolean addAll(Collection<? extends E> coll) {
3113
// Doing things this way insulates us from concurrent changes
3114
// in the contents of coll and provides all-or-nothing
3115
// semantics (which we wouldn't get if we type-checked each
3116
// element as we added it)
3117
return c.addAll(checkedCopyOf(coll));
3118
}
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
3119
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
3120
// Override default methods in Collection
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
3121
@Override
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
3122
public void forEach(Consumer<? super E> action) {c.forEach(action);}
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
3123
@Override
3124
public boolean removeIf(Predicate<? super E> filter) {
3125
return c.removeIf(filter);
3126
}
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
3127
@Override
3128
public Spliterator<E> spliterator() {return c.spliterator();}
henryjen
8023275: Wrapping collections should override default methods
Aug 27, 2013
3129
@Override
3130
public Stream<E> stream() {return c.stream();}
3131
@Override
3132
public Stream<E> parallelStream() {return c.parallelStream();}
duke
Initial load
Dec 1, 2007
3133
}
3134
mduigou
5029031: Add Collections.checkedQueue()
Oct 19, 2011
3135
/**
3136
* Returns a dynamically typesafe view of the specified queue.
3137
* Any attempt to insert an element of the wrong type will result in
3138
* an immediate {@link ClassCastException}. Assuming a queue contains
3139
* no incorrectly typed elements prior to the time a dynamically typesafe
3140
* view is generated, and that all subsequent access to the queue
3141
* takes place through the view, it is <i>guaranteed</i> that the
3142
* queue cannot contain an incorrectly typed element.
3143
*
3144
* <p>A discussion of the use of dynamically typesafe views may be
3145
* found in the documentation for the {@link #checkedCollection
3146
* checkedCollection} method.
3147
*
3148
* <p>The returned queue will be serializable if the specified queue
3149
* is serializable.
3150
*
3151
* <p>Since {@code null} is considered to be a value of any reference
3152
* type, the returned queue permits insertion of {@code null} elements
3153
* whenever the backing queue does.
3154
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
3155
* @param <E> the class of the objects in the queue
mduigou
5029031: Add Collections.checkedQueue()
Oct 19, 2011
3156
* @param queue the queue for which a dynamically typesafe view is to be
3157
* returned
3158
* @param type the type of element that {@code queue} is permitted to hold
3159
* @return a dynamically typesafe view of the specified queue
3160
* @since 1.8
3161
*/
3162
public static <E> Queue<E> checkedQueue(Queue<E> queue, Class<E> type) {
3163
return new CheckedQueue<>(queue, type);
3164
}
3165
3166
/**
3167
* @serial include
3168
*/
3169
static class CheckedQueue<E>
3170
extends CheckedCollection<E>
3171
implements Queue<E>, Serializable
3172
{
3173
private static final long serialVersionUID = 1433151992604707767L;
3174
final Queue<E> queue;
3175
3176
CheckedQueue(Queue<E> queue, Class<E> elementType) {
3177
super(queue, elementType);
3178
this.queue = queue;
3179
}
3180
3181
public E element() {return queue.element();}
3182
public boolean equals(Object o) {return o == this || c.equals(o);}
3183
public int hashCode() {return c.hashCode();}
3184
public E peek() {return queue.peek();}
3185
public E poll() {return queue.poll();}
3186
public E remove() {return queue.remove();}
mduigou
8048207: Collections.checkedQueue.offer() calls add on wrapped queue
Jun 27, 2014
3187
public boolean offer(E e) {return queue.offer(typeCheck(e));}
mduigou
5029031: Add Collections.checkedQueue()
Oct 19, 2011
3188
}
3189
duke
Initial load
Dec 1, 2007
3190
/**
3191
* Returns a dynamically typesafe view of the specified set.
3192
* Any attempt to insert an element of the wrong type will result in
3193
* an immediate {@link ClassCastException}. Assuming a set contains
3194
* no incorrectly typed elements prior to the time a dynamically typesafe
3195
* view is generated, and that all subsequent access to the set
3196
* takes place through the view, it is <i>guaranteed</i> that the
3197
* set cannot contain an incorrectly typed element.
3198
*
3199
* <p>A discussion of the use of dynamically typesafe views may be
3200
* found in the documentation for the {@link #checkedCollection
3201
* checkedCollection} method.
3202
*
3203
* <p>The returned set will be serializable if the specified set is
3204
* serializable.
3205
*
3206
* <p>Since {@code null} is considered to be a value of any reference
3207
* type, the returned set permits insertion of null elements whenever
3208
* the backing set does.
3209
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
3210
* @param <E> the class of the objects in the set
duke
Initial load
Dec 1, 2007
3211
* @param s the set for which a dynamically typesafe view is to be
3212
* returned
3213
* @param type the type of element that {@code s} is permitted to hold
3214
* @return a dynamically typesafe view of the specified set
3215
* @since 1.5
3216
*/
3217
public static <E> Set<E> checkedSet(Set<E> s, Class<E> type) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
3218
return new CheckedSet<>(s, type);
duke
Initial load
Dec 1, 2007
3219
}
3220
3221
/**
3222
* @serial include
3223
*/
3224
static class CheckedSet<E> extends CheckedCollection<E>
3225
implements Set<E>, Serializable
3226
{
3227
private static final long serialVersionUID = 4694047833775013803L;
3228
3229
CheckedSet(Set<E> s, Class<E> elementType) { super(s, elementType); }
3230
3231
public boolean equals(Object o) { return o == this || c.equals(o); }
3232
public int hashCode() { return c.hashCode(); }
3233
}
3234
3235
/**
3236
* Returns a dynamically typesafe view of the specified sorted set.
3237
* Any attempt to insert an element of the wrong type will result in an
3238
* immediate {@link ClassCastException}. Assuming a sorted set
3239
* contains no incorrectly typed elements prior to the time a
3240
* dynamically typesafe view is generated, and that all subsequent
3241
* access to the sorted set takes place through the view, it is
3242
* <i>guaranteed</i> that the sorted set cannot contain an incorrectly
3243
* typed element.
3244
*
3245
* <p>A discussion of the use of dynamically typesafe views may be
3246
* found in the documentation for the {@link #checkedCollection
3247
* checkedCollection} method.
3248
*
3249
* <p>The returned sorted set will be serializable if the specified sorted
3250
* set is serializable.
3251
*
3252
* <p>Since {@code null} is considered to be a value of any reference
3253
* type, the returned sorted set permits insertion of null elements
3254
* whenever the backing sorted set does.
3255
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
3256
* @param <E> the class of the objects in the set
duke
Initial load
Dec 1, 2007
3257
* @param s the sorted set for which a dynamically typesafe view is to be
3258
* returned
3259
* @param type the type of element that {@code s} is permitted to hold
3260
* @return a dynamically typesafe view of the specified sorted set
3261
* @since 1.5
3262
*/
3263
public static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s,
3264
Class<E> type) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
3265
return new CheckedSortedSet<>(s, type);
duke
Initial load
Dec 1, 2007
3266
}
3267
3268
/**
3269
* @serial include
3270
*/
3271
static class CheckedSortedSet<E> extends CheckedSet<E>
3272
implements SortedSet<E>, Serializable
3273
{
3274
private static final long serialVersionUID = 1599911165492914959L;
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
3275
duke
Initial load
Dec 1, 2007
3276
private final SortedSet<E> ss;
3277
3278
CheckedSortedSet(SortedSet<E> s, Class<E> type) {
3279
super(s, type);
3280
ss = s;
3281
}
3282
3283
public Comparator<? super E> comparator() { return ss.comparator(); }
3284
public E first() { return ss.first(); }
3285
public E last() { return ss.last(); }
3286
3287
public SortedSet<E> subSet(E fromElement, E toElement) {
3288
return checkedSortedSet(ss.subSet(fromElement,toElement), type);
3289
}
3290
public SortedSet<E> headSet(E toElement) {
3291
return checkedSortedSet(ss.headSet(toElement), type);
3292
}
3293
public SortedSet<E> tailSet(E fromElement) {
3294
return checkedSortedSet(ss.tailSet(fromElement), type);
3295
}
3296
}
3297
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
3298
/**
3299
* Returns a dynamically typesafe view of the specified navigable set.
3300
* Any attempt to insert an element of the wrong type will result in an
3301
* immediate {@link ClassCastException}. Assuming a navigable set
3302
* contains no incorrectly typed elements prior to the time a
3303
* dynamically typesafe view is generated, and that all subsequent
3304
* access to the navigable set takes place through the view, it is
3305
* <em>guaranteed</em> that the navigable set cannot contain an incorrectly
3306
* typed element.
3307
*
3308
* <p>A discussion of the use of dynamically typesafe views may be
3309
* found in the documentation for the {@link #checkedCollection
3310
* checkedCollection} method.
3311
*
3312
* <p>The returned navigable set will be serializable if the specified
3313
* navigable set is serializable.
3314
*
3315
* <p>Since {@code null} is considered to be a value of any reference
3316
* type, the returned navigable set permits insertion of null elements
3317
* whenever the backing sorted set does.
3318
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
3319
* @param <E> the class of the objects in the set
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
3320
* @param s the navigable set for which a dynamically typesafe view is to be
3321
* returned
3322
* @param type the type of element that {@code s} is permitted to hold
3323
* @return a dynamically typesafe view of the specified navigable set
3324
* @since 1.8
3325
*/
3326
public static <E> NavigableSet<E> checkedNavigableSet(NavigableSet<E> s,
3327
Class<E> type) {
3328
return new CheckedNavigableSet<>(s, type);
3329
}
3330
3331
/**
3332
* @serial include
3333
*/
3334
static class CheckedNavigableSet<E> extends CheckedSortedSet<E>
3335
implements NavigableSet<E>, Serializable
3336
{
3337
private static final long serialVersionUID = -5429120189805438922L;
3338
3339
private final NavigableSet<E> ns;
3340
3341
CheckedNavigableSet(NavigableSet<E> s, Class<E> type) {
3342
super(s, type);
3343
ns = s;
3344
}
3345
3346
public E lower(E e) { return ns.lower(e); }
3347
public E floor(E e) { return ns.floor(e); }
3348
public E ceiling(E e) { return ns.ceiling(e); }
3349
public E higher(E e) { return ns.higher(e); }
3350
public E pollFirst() { return ns.pollFirst(); }
3351
public E pollLast() {return ns.pollLast(); }
3352
public NavigableSet<E> descendingSet()
3353
{ return checkedNavigableSet(ns.descendingSet(), type); }
3354
public Iterator<E> descendingIterator()
3355
{return checkedNavigableSet(ns.descendingSet(), type).iterator(); }
3356
3357
public NavigableSet<E> subSet(E fromElement, E toElement) {
3358
return checkedNavigableSet(ns.subSet(fromElement, true, toElement, false), type);
3359
}
3360
public NavigableSet<E> headSet(E toElement) {
3361
return checkedNavigableSet(ns.headSet(toElement, false), type);
3362
}
3363
public NavigableSet<E> tailSet(E fromElement) {
3364
return checkedNavigableSet(ns.tailSet(fromElement, true), type);
3365
}
3366
3367
public NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) {
3368
return checkedNavigableSet(ns.subSet(fromElement, fromInclusive, toElement, toInclusive), type);
3369
}
3370
3371
public NavigableSet<E> headSet(E toElement, boolean inclusive) {
3372
return checkedNavigableSet(ns.headSet(toElement, inclusive), type);
3373
}
3374
3375
public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
3376
return checkedNavigableSet(ns.tailSet(fromElement, inclusive), type);
3377
}
3378
}
3379
duke
Initial load
Dec 1, 2007
3380
/**
3381
* Returns a dynamically typesafe view of the specified list.
3382
* Any attempt to insert an element of the wrong type will result in
3383
* an immediate {@link ClassCastException}. Assuming a list contains
3384
* no incorrectly typed elements prior to the time a dynamically typesafe
3385
* view is generated, and that all subsequent access to the list
3386
* takes place through the view, it is <i>guaranteed</i> that the
3387
* list cannot contain an incorrectly typed element.
3388
*
3389
* <p>A discussion of the use of dynamically typesafe views may be
3390
* found in the documentation for the {@link #checkedCollection
3391
* checkedCollection} method.
3392
*
3393
* <p>The returned list will be serializable if the specified list
3394
* is serializable.
3395
*
3396
* <p>Since {@code null} is considered to be a value of any reference
3397
* type, the returned list permits insertion of null elements whenever
3398
* the backing list does.
3399
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
3400
* @param <E> the class of the objects in the list
duke
Initial load
Dec 1, 2007
3401
* @param list the list for which a dynamically typesafe view is to be
3402
* returned
3403
* @param type the type of element that {@code list} is permitted to hold
3404
* @return a dynamically typesafe view of the specified list
3405
* @since 1.5
3406
*/
3407
public static <E> List<E> checkedList(List<E> list, Class<E> type) {
3408
return (list instanceof RandomAccess ?
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
3409
new CheckedRandomAccessList<>(list, type) :
3410
new CheckedList<>(list, type));
duke
Initial load
Dec 1, 2007
3411
}
3412
3413
/**
3414
* @serial include
3415
*/
3416
static class CheckedList<E>
3417
extends CheckedCollection<E>
3418
implements List<E>
3419
{
3420
private static final long serialVersionUID = 65247728283967356L;
3421
final List<E> list;
3422
3423
CheckedList(List<E> list, Class<E> type) {
3424
super(list, type);
3425
this.list = list;
3426
}
3427
3428
public boolean equals(Object o) { return o == this || list.equals(o); }
3429
public int hashCode() { return list.hashCode(); }
3430
public E get(int index) { return list.get(index); }
3431
public E remove(int index) { return list.remove(index); }
3432
public int indexOf(Object o) { return list.indexOf(o); }
3433
public int lastIndexOf(Object o) { return list.lastIndexOf(o); }
3434
3435
public E set(int index, E element) {
mduigou
8048207: Collections.checkedQueue.offer() calls add on wrapped queue
Jun 27, 2014
3436
return list.set(index, typeCheck(element));
duke
Initial load
Dec 1, 2007
3437
}
3438
3439
public void add(int index, E element) {
mduigou
8048207: Collections.checkedQueue.offer() calls add on wrapped queue
Jun 27, 2014
3440
list.add(index, typeCheck(element));
duke
Initial load
Dec 1, 2007
3441
}
3442
3443
public boolean addAll(int index, Collection<? extends E> c) {
3444
return list.addAll(index, checkedCopyOf(c));
3445
}
3446
public ListIterator<E> listIterator() { return listIterator(0); }
3447
3448
public ListIterator<E> listIterator(final int index) {
3449
final ListIterator<E> i = list.listIterator(index);
3450
3451
return new ListIterator<E>() {
3452
public boolean hasNext() { return i.hasNext(); }
3453
public E next() { return i.next(); }
3454
public boolean hasPrevious() { return i.hasPrevious(); }
3455
public E previous() { return i.previous(); }
3456
public int nextIndex() { return i.nextIndex(); }
3457
public int previousIndex() { return i.previousIndex(); }
3458
public void remove() { i.remove(); }
3459
3460
public void set(E e) {
mduigou
8048207: Collections.checkedQueue.offer() calls add on wrapped queue
Jun 27, 2014
3461
i.set(typeCheck(e));
duke
Initial load
Dec 1, 2007
3462
}
3463
3464
public void add(E e) {
mduigou
8048207: Collections.checkedQueue.offer() calls add on wrapped queue
Jun 27, 2014
3465
i.add(typeCheck(e));
duke
Initial load
Dec 1, 2007
3466
}
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
3467
3468
@Override
3469
public void forEachRemaining(Consumer<? super E> action) {
3470
i.forEachRemaining(action);
3471
}
duke
Initial load
Dec 1, 2007
3472
};
3473
}
3474
3475
public List<E> subList(int fromIndex, int toIndex) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
3476
return new CheckedList<>(list.subList(fromIndex, toIndex), type);
duke
Initial load
Dec 1, 2007
3477
}
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
3478
mduigou
8047795: Collections.checkedList checking bypassed by List.replaceAll
Jun 25, 2014
3479
/**
3480
* {@inheritDoc}
3481
*
3482
* @throws ClassCastException if the class of an element returned by the
3483
* operator prevents it from being added to this collection. The
3484
* exception may be thrown after some elements of the list have
3485
* already been replaced.
3486
*/
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
3487
@Override
3488
public void replaceAll(UnaryOperator<E> operator) {
chegar
8053938: Collections.checkedList(empty list).replaceAll((UnaryOperato…
Jul 30, 2014
3489
Objects.requireNonNull(operator);
mduigou
8047795: Collections.checkedList checking bypassed by List.replaceAll
Jun 25, 2014
3490
list.replaceAll(e -> typeCheck(operator.apply(e)));
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
3491
}
mduigou
8047795: Collections.checkedList checking bypassed by List.replaceAll
Jun 25, 2014
3492
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
3493
@Override
3494
public void sort(Comparator<? super E> c) {
3495
list.sort(c);
3496
}
duke
Initial load
Dec 1, 2007
3497
}
3498
3499
/**
3500
* @serial include
3501
*/
3502
static class CheckedRandomAccessList<E> extends CheckedList<E>
3503
implements RandomAccess
3504
{
3505
private static final long serialVersionUID = 1638200125423088369L;
3506
3507
CheckedRandomAccessList(List<E> list, Class<E> type) {
3508
super(list, type);
3509
}
3510
3511
public List<E> subList(int fromIndex, int toIndex) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
3512
return new CheckedRandomAccessList<>(
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
3513
list.subList(fromIndex, toIndex), type);
duke
Initial load
Dec 1, 2007
3514
}
3515
}
3516
3517
/**
3518
* Returns a dynamically typesafe view of the specified map.
3519
* Any attempt to insert a mapping whose key or value have the wrong
3520
* type will result in an immediate {@link ClassCastException}.
3521
* Similarly, any attempt to modify the value currently associated with
3522
* a key will result in an immediate {@link ClassCastException},
3523
* whether the modification is attempted directly through the map
3524
* itself, or through a {@link Map.Entry} instance obtained from the
3525
* map's {@link Map#entrySet() entry set} view.
3526
*
3527
* <p>Assuming a map contains no incorrectly typed keys or values
3528
* prior to the time a dynamically typesafe view is generated, and
3529
* that all subsequent access to the map takes place through the view
3530
* (or one of its collection views), it is <i>guaranteed</i> that the
3531
* map cannot contain an incorrectly typed key or value.
3532
*
3533
* <p>A discussion of the use of dynamically typesafe views may be
3534
* found in the documentation for the {@link #checkedCollection
3535
* checkedCollection} method.
3536
*
3537
* <p>The returned map will be serializable if the specified map is
3538
* serializable.
3539
*
3540
* <p>Since {@code null} is considered to be a value of any reference
3541
* type, the returned map permits insertion of null keys or values
3542
* whenever the backing map does.
3543
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
3544
* @param <K> the class of the map keys
3545
* @param <V> the class of the map values
duke
Initial load
Dec 1, 2007
3546
* @param m the map for which a dynamically typesafe view is to be
3547
* returned
3548
* @param keyType the type of key that {@code m} is permitted to hold
3549
* @param valueType the type of value that {@code m} is permitted to hold
3550
* @return a dynamically typesafe view of the specified map
3551
* @since 1.5
3552
*/
3553
public static <K, V> Map<K, V> checkedMap(Map<K, V> m,
3554
Class<K> keyType,
3555
Class<V> valueType) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
3556
return new CheckedMap<>(m, keyType, valueType);
duke
Initial load
Dec 1, 2007
3557
}
3558
3559
3560
/**
3561
* @serial include
3562
*/
3563
private static class CheckedMap<K,V>
3564
implements Map<K,V>, Serializable
3565
{
3566
private static final long serialVersionUID = 5742860141034234728L;
3567
3568
private final Map<K, V> m;
3569
final Class<K> keyType;
3570
final Class<V> valueType;
3571
3572
private void typeCheck(Object key, Object value) {
3573
if (key != null && !keyType.isInstance(key))
3574
throw new ClassCastException(badKeyMsg(key));
3575
3576
if (value != null && !valueType.isInstance(value))
3577
throw new ClassCastException(badValueMsg(value));
3578
}
3579
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
3580
private BiFunction<? super K, ? super V, ? extends V> typeCheck(
3581
BiFunction<? super K, ? super V, ? extends V> func) {
3582
Objects.requireNonNull(func);
3583
return (k, v) -> {
3584
V newValue = func.apply(k, v);
3585
typeCheck(k, newValue);
3586
return newValue;
3587
};
3588
}
3589
duke
Initial load
Dec 1, 2007
3590
private String badKeyMsg(Object key) {
3591
return "Attempt to insert " + key.getClass() +
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
3592
" key into map with key type " + keyType;
duke
Initial load
Dec 1, 2007
3593
}
3594
3595
private String badValueMsg(Object value) {
3596
return "Attempt to insert " + value.getClass() +
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
3597
" value into map with value type " + valueType;
duke
Initial load
Dec 1, 2007
3598
}
3599
3600
CheckedMap(Map<K, V> m, Class<K> keyType, Class<V> valueType) {
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
3601
this.m = Objects.requireNonNull(m);
3602
this.keyType = Objects.requireNonNull(keyType);
3603
this.valueType = Objects.requireNonNull(valueType);
duke
Initial load
Dec 1, 2007
3604
}
3605
3606
public int size() { return m.size(); }
3607
public boolean isEmpty() { return m.isEmpty(); }
3608
public boolean containsKey(Object key) { return m.containsKey(key); }
3609
public boolean containsValue(Object v) { return m.containsValue(v); }
3610
public V get(Object key) { return m.get(key); }
3611
public V remove(Object key) { return m.remove(key); }
3612
public void clear() { m.clear(); }
3613
public Set<K> keySet() { return m.keySet(); }
3614
public Collection<V> values() { return m.values(); }
3615
public boolean equals(Object o) { return o == this || m.equals(o); }
3616
public int hashCode() { return m.hashCode(); }
3617
public String toString() { return m.toString(); }
3618
3619
public V put(K key, V value) {
3620
typeCheck(key, value);
3621
return m.put(key, value);
3622
}
3623
3624
@SuppressWarnings("unchecked")
3625
public void putAll(Map<? extends K, ? extends V> t) {
3626
// Satisfy the following goals:
3627
// - good diagnostics in case of type mismatch
3628
// - all-or-nothing semantics
3629
// - protection from malicious t
3630
// - correct behavior if t is a concurrent map
3631
Object[] entries = t.entrySet().toArray();
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
3632
List<Map.Entry<K,V>> checked = new ArrayList<>(entries.length);
duke
Initial load
Dec 1, 2007
3633
for (Object o : entries) {
3634
Map.Entry<?,?> e = (Map.Entry<?,?>) o;
3635
Object k = e.getKey();
3636
Object v = e.getValue();
3637
typeCheck(k, v);
3638
checked.add(
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
3639
new AbstractMap.SimpleImmutableEntry<>((K)k, (V)v));
duke
Initial load
Dec 1, 2007
3640
}
3641
for (Map.Entry<K,V> e : checked)
3642
m.put(e.getKey(), e.getValue());
3643
}
3644
mduigou
8035284: Remove redundant initializations to null
Apr 11, 2014
3645
private transient Set<Map.Entry<K,V>> entrySet;
duke
Initial load
Dec 1, 2007
3646
3647
public Set<Map.Entry<K,V>> entrySet() {
3648
if (entrySet==null)
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
3649
entrySet = new CheckedEntrySet<>(m.entrySet(), valueType);
duke
Initial load
Dec 1, 2007
3650
return entrySet;
3651
}
3652
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
3653
// Override default methods in Map
3654
@Override
3655
public void forEach(BiConsumer<? super K, ? super V> action) {
3656
m.forEach(action);
3657
}
3658
3659
@Override
3660
public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
3661
m.replaceAll(typeCheck(function));
3662
}
3663
3664
@Override
3665
public V putIfAbsent(K key, V value) {
3666
typeCheck(key, value);
3667
return m.putIfAbsent(key, value);
3668
}
3669
3670
@Override
3671
public boolean remove(Object key, Object value) {
3672
return m.remove(key, value);
3673
}
3674
3675
@Override
3676
public boolean replace(K key, V oldValue, V newValue) {
3677
typeCheck(key, newValue);
3678
return m.replace(key, oldValue, newValue);
3679
}
3680
3681
@Override
3682
public V replace(K key, V value) {
3683
typeCheck(key, value);
3684
return m.replace(key, value);
3685
}
3686
3687
@Override
3688
public V computeIfAbsent(K key,
3689
Function<? super K, ? extends V> mappingFunction) {
3690
Objects.requireNonNull(mappingFunction);
3691
return m.computeIfAbsent(key, k -> {
3692
V value = mappingFunction.apply(k);
3693
typeCheck(k, value);
3694
return value;
3695
});
3696
}
3697
3698
@Override
3699
public V computeIfPresent(K key,
3700
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
3701
return m.computeIfPresent(key, typeCheck(remappingFunction));
3702
}
3703
3704
@Override
3705
public V compute(K key,
3706
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
3707
return m.compute(key, typeCheck(remappingFunction));
3708
}
3709
3710
@Override
3711
public V merge(K key, V value,
3712
BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
3713
Objects.requireNonNull(remappingFunction);
3714
return m.merge(key, value, (v1, v2) -> {
3715
V newValue = remappingFunction.apply(v1, v2);
3716
typeCheck(null, newValue);
3717
return newValue;
3718
});
3719
}
3720
duke
Initial load
Dec 1, 2007
3721
/**
3722
* We need this class in addition to CheckedSet as Map.Entry permits
3723
* modification of the backing Map via the setValue operation. This
3724
* class is subtle: there are many possible attacks that must be
3725
* thwarted.
3726
*
3727
* @serial exclude
3728
*/
3729
static class CheckedEntrySet<K,V> implements Set<Map.Entry<K,V>> {
3730
private final Set<Map.Entry<K,V>> s;
3731
private final Class<V> valueType;
3732
3733
CheckedEntrySet(Set<Map.Entry<K, V>> s, Class<V> valueType) {
3734
this.s = s;
3735
this.valueType = valueType;
3736
}
3737
3738
public int size() { return s.size(); }
3739
public boolean isEmpty() { return s.isEmpty(); }
3740
public String toString() { return s.toString(); }
3741
public int hashCode() { return s.hashCode(); }
3742
public void clear() { s.clear(); }
3743
3744
public boolean add(Map.Entry<K, V> e) {
3745
throw new UnsupportedOperationException();
3746
}
3747
public boolean addAll(Collection<? extends Map.Entry<K, V>> coll) {
3748
throw new UnsupportedOperationException();
3749
}
3750
3751
public Iterator<Map.Entry<K,V>> iterator() {
3752
final Iterator<Map.Entry<K, V>> i = s.iterator();
3753
final Class<V> valueType = this.valueType;
3754
3755
return new Iterator<Map.Entry<K,V>>() {
3756
public boolean hasNext() { return i.hasNext(); }
3757
public void remove() { i.remove(); }
3758
3759
public Map.Entry<K,V> next() {
3760
return checkedEntry(i.next(), valueType);
3761
}
3762
};
3763
}
3764
3765
@SuppressWarnings("unchecked")
3766
public Object[] toArray() {
3767
Object[] source = s.toArray();
3768
3769
/*
3770
* Ensure that we don't get an ArrayStoreException even if
3771
* s.toArray returns an array of something other than Object
3772
*/
3773
Object[] dest = (CheckedEntry.class.isInstance(
3774
source.getClass().getComponentType()) ? source :
3775
new Object[source.length]);
3776
3777
for (int i = 0; i < source.length; i++)
3778
dest[i] = checkedEntry((Map.Entry<K,V>)source[i],
3779
valueType);
3780
return dest;
3781
}
3782
3783
@SuppressWarnings("unchecked")
3784
public <T> T[] toArray(T[] a) {
3785
// We don't pass a to s.toArray, to avoid window of
3786
// vulnerability wherein an unscrupulous multithreaded client
3787
// could get his hands on raw (unwrapped) Entries from s.
3788
T[] arr = s.toArray(a.length==0 ? a : Arrays.copyOf(a, 0));
3789
3790
for (int i=0; i<arr.length; i++)
3791
arr[i] = (T) checkedEntry((Map.Entry<K,V>)arr[i],
3792
valueType);
3793
if (arr.length > a.length)
3794
return arr;
3795
3796
System.arraycopy(arr, 0, a, 0, arr.length);
3797
if (a.length > arr.length)
3798
a[arr.length] = null;
3799
return a;
3800
}
3801
3802
/**
3803
* This method is overridden to protect the backing set against
3804
* an object with a nefarious equals function that senses
3805
* that the equality-candidate is Map.Entry and calls its
3806
* setValue method.
3807
*/
3808
public boolean contains(Object o) {
3809
if (!(o instanceof Map.Entry))
3810
return false;
3811
Map.Entry<?,?> e = (Map.Entry<?,?>) o;
3812
return s.contains(
3813
(e instanceof CheckedEntry) ? e : checkedEntry(e, valueType));
3814
}
3815
3816
/**
3817
* The bulk collection methods are overridden to protect
3818
* against an unscrupulous collection whose contains(Object o)
3819
* method senses when o is a Map.Entry, and calls o.setValue.
3820
*/
3821
public boolean containsAll(Collection<?> c) {
3822
for (Object o : c)
3823
if (!contains(o)) // Invokes safe contains() above
3824
return false;
3825
return true;
3826
}
3827
3828
public boolean remove(Object o) {
3829
if (!(o instanceof Map.Entry))
3830
return false;
3831
return s.remove(new AbstractMap.SimpleImmutableEntry
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
3832
<>((Map.Entry<?,?>)o));
duke
Initial load
Dec 1, 2007
3833
}
3834
3835
public boolean removeAll(Collection<?> c) {
3836
return batchRemove(c, false);
3837
}
3838
public boolean retainAll(Collection<?> c) {
3839
return batchRemove(c, true);
3840
}
3841
private boolean batchRemove(Collection<?> c, boolean complement) {
mduigou
8021591: Additional explicit null checks
Sep 13, 2013
3842
Objects.requireNonNull(c);
duke
Initial load
Dec 1, 2007
3843
boolean modified = false;
3844
Iterator<Map.Entry<K,V>> it = iterator();
3845
while (it.hasNext()) {
3846
if (c.contains(it.next()) != complement) {
3847
it.remove();
3848
modified = true;
3849
}
3850
}
3851
return modified;
3852
}
3853
3854
public boolean equals(Object o) {
3855
if (o == this)
3856
return true;
3857
if (!(o instanceof Set))
3858
return false;
3859
Set<?> that = (Set<?>) o;
3860
return that.size() == s.size()
3861
&& containsAll(that); // Invokes safe containsAll() above
3862
}
3863
3864
static <K,V,T> CheckedEntry<K,V,T> checkedEntry(Map.Entry<K,V> e,
3865
Class<T> valueType) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
3866
return new CheckedEntry<>(e, valueType);
duke
Initial load
Dec 1, 2007
3867
}
3868
3869
/**
3870
* This "wrapper class" serves two purposes: it prevents
3871
* the client from modifying the backing Map, by short-circuiting
3872
* the setValue method, and it protects the backing Map against
3873
* an ill-behaved Map.Entry that attempts to modify another
3874
* Map.Entry when asked to perform an equality check.
3875
*/
3876
private static class CheckedEntry<K,V,T> implements Map.Entry<K,V> {
3877
private final Map.Entry<K, V> e;
3878
private final Class<T> valueType;
3879
3880
CheckedEntry(Map.Entry<K, V> e, Class<T> valueType) {
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
3881
this.e = Objects.requireNonNull(e);
3882
this.valueType = Objects.requireNonNull(valueType);
duke
Initial load
Dec 1, 2007
3883
}
3884
3885
public K getKey() { return e.getKey(); }
3886
public V getValue() { return e.getValue(); }
3887
public int hashCode() { return e.hashCode(); }
3888
public String toString() { return e.toString(); }
3889
3890
public V setValue(V value) {
3891
if (value != null && !valueType.isInstance(value))
3892
throw new ClassCastException(badValueMsg(value));
3893
return e.setValue(value);
3894
}
3895
3896
private String badValueMsg(Object value) {
3897
return "Attempt to insert " + value.getClass() +
3898
" value into map with value type " + valueType;
3899
}
3900
3901
public boolean equals(Object o) {
3902
if (o == this)
3903
return true;
3904
if (!(o instanceof Map.Entry))
3905
return false;
3906
return e.equals(new AbstractMap.SimpleImmutableEntry
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
3907
<>((Map.Entry<?,?>)o));
duke
Initial load
Dec 1, 2007
3908
}
3909
}
3910
}
3911
}
3912
3913
/**
3914
* Returns a dynamically typesafe view of the specified sorted map.
3915
* Any attempt to insert a mapping whose key or value have the wrong
3916
* type will result in an immediate {@link ClassCastException}.
3917
* Similarly, any attempt to modify the value currently associated with
3918
* a key will result in an immediate {@link ClassCastException},
3919
* whether the modification is attempted directly through the map
3920
* itself, or through a {@link Map.Entry} instance obtained from the
3921
* map's {@link Map#entrySet() entry set} view.
3922
*
3923
* <p>Assuming a map contains no incorrectly typed keys or values
3924
* prior to the time a dynamically typesafe view is generated, and
3925
* that all subsequent access to the map takes place through the view
3926
* (or one of its collection views), it is <i>guaranteed</i> that the
3927
* map cannot contain an incorrectly typed key or value.
3928
*
3929
* <p>A discussion of the use of dynamically typesafe views may be
3930
* found in the documentation for the {@link #checkedCollection
3931
* checkedCollection} method.
3932
*
3933
* <p>The returned map will be serializable if the specified map is
3934
* serializable.
3935
*
3936
* <p>Since {@code null} is considered to be a value of any reference
3937
* type, the returned map permits insertion of null keys or values
3938
* whenever the backing map does.
3939
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
3940
* @param <K> the class of the map keys
3941
* @param <V> the class of the map values
duke
Initial load
Dec 1, 2007
3942
* @param m the map for which a dynamically typesafe view is to be
3943
* returned
3944
* @param keyType the type of key that {@code m} is permitted to hold
3945
* @param valueType the type of value that {@code m} is permitted to hold
3946
* @return a dynamically typesafe view of the specified map
3947
* @since 1.5
3948
*/
3949
public static <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K, V> m,
3950
Class<K> keyType,
3951
Class<V> valueType) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
3952
return new CheckedSortedMap<>(m, keyType, valueType);
duke
Initial load
Dec 1, 2007
3953
}
3954
3955
/**
3956
* @serial include
3957
*/
3958
static class CheckedSortedMap<K,V> extends CheckedMap<K,V>
3959
implements SortedMap<K,V>, Serializable
3960
{
3961
private static final long serialVersionUID = 1599671320688067438L;
3962
3963
private final SortedMap<K, V> sm;
3964
3965
CheckedSortedMap(SortedMap<K, V> m,
3966
Class<K> keyType, Class<V> valueType) {
3967
super(m, keyType, valueType);
3968
sm = m;
3969
}
3970
3971
public Comparator<? super K> comparator() { return sm.comparator(); }
3972
public K firstKey() { return sm.firstKey(); }
3973
public K lastKey() { return sm.lastKey(); }
3974
3975
public SortedMap<K,V> subMap(K fromKey, K toKey) {
3976
return checkedSortedMap(sm.subMap(fromKey, toKey),
3977
keyType, valueType);
3978
}
3979
public SortedMap<K,V> headMap(K toKey) {
3980
return checkedSortedMap(sm.headMap(toKey), keyType, valueType);
3981
}
3982
public SortedMap<K,V> tailMap(K fromKey) {
3983
return checkedSortedMap(sm.tailMap(fromKey), keyType, valueType);
3984
}
3985
}
3986
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
3987
/**
3988
* Returns a dynamically typesafe view of the specified navigable map.
3989
* Any attempt to insert a mapping whose key or value have the wrong
3990
* type will result in an immediate {@link ClassCastException}.
3991
* Similarly, any attempt to modify the value currently associated with
3992
* a key will result in an immediate {@link ClassCastException},
3993
* whether the modification is attempted directly through the map
3994
* itself, or through a {@link Map.Entry} instance obtained from the
3995
* map's {@link Map#entrySet() entry set} view.
3996
*
3997
* <p>Assuming a map contains no incorrectly typed keys or values
3998
* prior to the time a dynamically typesafe view is generated, and
3999
* that all subsequent access to the map takes place through the view
4000
* (or one of its collection views), it is <em>guaranteed</em> that the
4001
* map cannot contain an incorrectly typed key or value.
4002
*
4003
* <p>A discussion of the use of dynamically typesafe views may be
4004
* found in the documentation for the {@link #checkedCollection
4005
* checkedCollection} method.
4006
*
4007
* <p>The returned map will be serializable if the specified map is
4008
* serializable.
4009
*
4010
* <p>Since {@code null} is considered to be a value of any reference
4011
* type, the returned map permits insertion of null keys or values
4012
* whenever the backing map does.
4013
*
4014
* @param <K> type of map keys
4015
* @param <V> type of map values
4016
* @param m the map for which a dynamically typesafe view is to be
4017
* returned
4018
* @param keyType the type of key that {@code m} is permitted to hold
4019
* @param valueType the type of value that {@code m} is permitted to hold
4020
* @return a dynamically typesafe view of the specified map
4021
* @since 1.8
4022
*/
4023
public static <K,V> NavigableMap<K,V> checkedNavigableMap(NavigableMap<K, V> m,
4024
Class<K> keyType,
4025
Class<V> valueType) {
4026
return new CheckedNavigableMap<>(m, keyType, valueType);
4027
}
4028
4029
/**
4030
* @serial include
4031
*/
4032
static class CheckedNavigableMap<K,V> extends CheckedSortedMap<K,V>
4033
implements NavigableMap<K,V>, Serializable
4034
{
4035
private static final long serialVersionUID = -4852462692372534096L;
4036
4037
private final NavigableMap<K, V> nm;
4038
4039
CheckedNavigableMap(NavigableMap<K, V> m,
4040
Class<K> keyType, Class<V> valueType) {
4041
super(m, keyType, valueType);
4042
nm = m;
4043
}
4044
4045
public Comparator<? super K> comparator() { return nm.comparator(); }
4046
public K firstKey() { return nm.firstKey(); }
4047
public K lastKey() { return nm.lastKey(); }
4048
4049
public Entry<K, V> lowerEntry(K key) {
4050
Entry<K,V> lower = nm.lowerEntry(key);
4051
return (null != lower)
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
4052
? new CheckedMap.CheckedEntrySet.CheckedEntry<>(lower, valueType)
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4053
: null;
4054
}
4055
4056
public K lowerKey(K key) { return nm.lowerKey(key); }
4057
4058
public Entry<K, V> floorEntry(K key) {
4059
Entry<K,V> floor = nm.floorEntry(key);
4060
return (null != floor)
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
4061
? new CheckedMap.CheckedEntrySet.CheckedEntry<>(floor, valueType)
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4062
: null;
4063
}
4064
4065
public K floorKey(K key) { return nm.floorKey(key); }
4066
4067
public Entry<K, V> ceilingEntry(K key) {
4068
Entry<K,V> ceiling = nm.ceilingEntry(key);
4069
return (null != ceiling)
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
4070
? new CheckedMap.CheckedEntrySet.CheckedEntry<>(ceiling, valueType)
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4071
: null;
4072
}
4073
4074
public K ceilingKey(K key) { return nm.ceilingKey(key); }
4075
4076
public Entry<K, V> higherEntry(K key) {
4077
Entry<K,V> higher = nm.higherEntry(key);
4078
return (null != higher)
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
4079
? new CheckedMap.CheckedEntrySet.CheckedEntry<>(higher, valueType)
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4080
: null;
4081
}
4082
4083
public K higherKey(K key) { return nm.higherKey(key); }
4084
4085
public Entry<K, V> firstEntry() {
4086
Entry<K,V> first = nm.firstEntry();
4087
return (null != first)
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
4088
? new CheckedMap.CheckedEntrySet.CheckedEntry<>(first, valueType)
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4089
: null;
4090
}
4091
4092
public Entry<K, V> lastEntry() {
4093
Entry<K,V> last = nm.lastEntry();
4094
return (null != last)
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
4095
? new CheckedMap.CheckedEntrySet.CheckedEntry<>(last, valueType)
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4096
: null;
4097
}
4098
4099
public Entry<K, V> pollFirstEntry() {
4100
Entry<K,V> entry = nm.pollFirstEntry();
4101
return (null == entry)
4102
? null
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
4103
: new CheckedMap.CheckedEntrySet.CheckedEntry<>(entry, valueType);
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4104
}
4105
4106
public Entry<K, V> pollLastEntry() {
4107
Entry<K,V> entry = nm.pollLastEntry();
4108
return (null == entry)
4109
? null
lagergren
8022412: Fixed warnings in java.util root, except for HashMap
Aug 6, 2013
4110
: new CheckedMap.CheckedEntrySet.CheckedEntry<>(entry, valueType);
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4111
}
4112
4113
public NavigableMap<K, V> descendingMap() {
4114
return checkedNavigableMap(nm.descendingMap(), keyType, valueType);
4115
}
4116
4117
public NavigableSet<K> keySet() {
4118
return navigableKeySet();
4119
}
4120
4121
public NavigableSet<K> navigableKeySet() {
4122
return checkedNavigableSet(nm.navigableKeySet(), keyType);
4123
}
4124
4125
public NavigableSet<K> descendingKeySet() {
4126
return checkedNavigableSet(nm.descendingKeySet(), keyType);
4127
}
4128
4129
@Override
4130
public NavigableMap<K,V> subMap(K fromKey, K toKey) {
4131
return checkedNavigableMap(nm.subMap(fromKey, true, toKey, false),
4132
keyType, valueType);
4133
}
4134
4135
@Override
4136
public NavigableMap<K,V> headMap(K toKey) {
4137
return checkedNavigableMap(nm.headMap(toKey, false), keyType, valueType);
4138
}
4139
4140
@Override
4141
public NavigableMap<K,V> tailMap(K fromKey) {
4142
return checkedNavigableMap(nm.tailMap(fromKey, true), keyType, valueType);
4143
}
4144
4145
public NavigableMap<K, V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
4146
return checkedNavigableMap(nm.subMap(fromKey, fromInclusive, toKey, toInclusive), keyType, valueType);
4147
}
4148
4149
public NavigableMap<K, V> headMap(K toKey, boolean inclusive) {
4150
return checkedNavigableMap(nm.headMap(toKey, inclusive), keyType, valueType);
4151
}
4152
4153
public NavigableMap<K, V> tailMap(K fromKey, boolean inclusive) {
4154
return checkedNavigableMap(nm.tailMap(fromKey, inclusive), keyType, valueType);
4155
}
4156
}
4157
duke
Initial load
Dec 1, 2007
4158
// Empty collections
4159
4160
/**
4161
* Returns an iterator that has no elements. More precisely,
4162
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4163
* <ul>
duke
Initial load
Dec 1, 2007
4164
* <li>{@link Iterator#hasNext hasNext} always returns {@code
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4165
* false}.</li>
duke
Initial load
Dec 1, 2007
4166
* <li>{@link Iterator#next next} always throws {@link
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4167
* NoSuchElementException}.</li>
duke
Initial load
Dec 1, 2007
4168
* <li>{@link Iterator#remove remove} always throws {@link
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4169
* IllegalStateException}.</li>
duke
Initial load
Dec 1, 2007
4170
* </ul>
4171
*
4172
* <p>Implementations of this method are permitted, but not
4173
* required, to return the same object from multiple invocations.
4174
*
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4175
* @param <T> type of elements, if there were any, in the iterator
duke
Initial load
Dec 1, 2007
4176
* @return an empty iterator
4177
* @since 1.7
4178
*/
4179
@SuppressWarnings("unchecked")
4180
public static <T> Iterator<T> emptyIterator() {
4181
return (Iterator<T>) EmptyIterator.EMPTY_ITERATOR;
4182
}
4183
4184
private static class EmptyIterator<E> implements Iterator<E> {
4185
static final EmptyIterator<Object> EMPTY_ITERATOR
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
4186
= new EmptyIterator<>();
duke
Initial load
Dec 1, 2007
4187
4188
public boolean hasNext() { return false; }
4189
public E next() { throw new NoSuchElementException(); }
4190
public void remove() { throw new IllegalStateException(); }
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
4191
@Override
4192
public void forEachRemaining(Consumer<? super E> action) {
4193
Objects.requireNonNull(action);
4194
}
duke
Initial load
Dec 1, 2007
4195
}
4196
4197
/**
4198
* Returns a list iterator that has no elements. More precisely,
4199
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4200
* <ul>
duke
Initial load
Dec 1, 2007
4201
* <li>{@link Iterator#hasNext hasNext} and {@link
4202
* ListIterator#hasPrevious hasPrevious} always return {@code
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4203
* false}.</li>
duke
Initial load
Dec 1, 2007
4204
* <li>{@link Iterator#next next} and {@link ListIterator#previous
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4205
* previous} always throw {@link NoSuchElementException}.</li>
duke
Initial load
Dec 1, 2007
4206
* <li>{@link Iterator#remove remove} and {@link ListIterator#set
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4207
* set} always throw {@link IllegalStateException}.</li>
duke
Initial load
Dec 1, 2007
4208
* <li>{@link ListIterator#add add} always throws {@link
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4209
* UnsupportedOperationException}.</li>
duke
Initial load
Dec 1, 2007
4210
* <li>{@link ListIterator#nextIndex nextIndex} always returns
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4211
* {@code 0}.</li>
duke
Initial load
Dec 1, 2007
4212
* <li>{@link ListIterator#previousIndex previousIndex} always
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4213
* returns {@code -1}.</li>
duke
Initial load
Dec 1, 2007
4214
* </ul>
4215
*
4216
* <p>Implementations of this method are permitted, but not
4217
* required, to return the same object from multiple invocations.
4218
*
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4219
* @param <T> type of elements, if there were any, in the iterator
duke
Initial load
Dec 1, 2007
4220
* @return an empty list iterator
4221
* @since 1.7
4222
*/
4223
@SuppressWarnings("unchecked")
4224
public static <T> ListIterator<T> emptyListIterator() {
4225
return (ListIterator<T>) EmptyListIterator.EMPTY_ITERATOR;
4226
}
4227
4228
private static class EmptyListIterator<E>
4229
extends EmptyIterator<E>
4230
implements ListIterator<E>
4231
{
4232
static final EmptyListIterator<Object> EMPTY_ITERATOR
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
4233
= new EmptyListIterator<>();
duke
Initial load
Dec 1, 2007
4234
4235
public boolean hasPrevious() { return false; }
4236
public E previous() { throw new NoSuchElementException(); }
4237
public int nextIndex() { return 0; }
4238
public int previousIndex() { return -1; }
4239
public void set(E e) { throw new IllegalStateException(); }
4240
public void add(E e) { throw new UnsupportedOperationException(); }
4241
}
4242
4243
/**
4244
* Returns an enumeration that has no elements. More precisely,
4245
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4246
* <ul>
duke
Initial load
Dec 1, 2007
4247
* <li>{@link Enumeration#hasMoreElements hasMoreElements} always
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4248
* returns {@code false}.</li>
duke
Initial load
Dec 1, 2007
4249
* <li> {@link Enumeration#nextElement nextElement} always throws
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4250
* {@link NoSuchElementException}.</li>
duke
Initial load
Dec 1, 2007
4251
* </ul>
4252
*
4253
* <p>Implementations of this method are permitted, but not
4254
* required, to return the same object from multiple invocations.
4255
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4256
* @param <T> the class of the objects in the enumeration
duke
Initial load
Dec 1, 2007
4257
* @return an empty enumeration
4258
* @since 1.7
4259
*/
4260
@SuppressWarnings("unchecked")
4261
public static <T> Enumeration<T> emptyEnumeration() {
4262
return (Enumeration<T>) EmptyEnumeration.EMPTY_ENUMERATION;
4263
}
4264
4265
private static class EmptyEnumeration<E> implements Enumeration<E> {
4266
static final EmptyEnumeration<Object> EMPTY_ENUMERATION
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
4267
= new EmptyEnumeration<>();
duke
Initial load
Dec 1, 2007
4268
4269
public boolean hasMoreElements() { return false; }
4270
public E nextElement() { throw new NoSuchElementException(); }
4271
}
4272
4273
/**
4274
* The empty set (immutable). This set is serializable.
4275
*
4276
* @see #emptySet()
4277
*/
dxu
7193406: Clean-up JDK Build Warnings in java.util, java.io
Aug 31, 2012
4278
@SuppressWarnings("rawtypes")
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
4279
public static final Set EMPTY_SET = new EmptySet<>();
duke
Initial load
Dec 1, 2007
4280
4281
/**
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4282
* Returns an empty set (immutable). This set is serializable.
duke
Initial load
Dec 1, 2007
4283
* Unlike the like-named field, this method is parameterized.
4284
*
4285
* <p>This example illustrates the type-safe way to obtain an empty set:
4286
* <pre>
4287
* Set&lt;String&gt; s = Collections.emptySet();
4288
* </pre>
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4289
* @implNote Implementations of this method need not create a separate
4290
* {@code Set} object for each call. Using this method is likely to have
4291
* comparable cost to using the like-named field. (Unlike this method, the
4292
* field does not provide type safety.)
4293
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4294
* @param <T> the class of the objects in the set
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4295
* @return the empty set
duke
Initial load
Dec 1, 2007
4296
*
4297
* @see #EMPTY_SET
4298
* @since 1.5
4299
*/
4300
@SuppressWarnings("unchecked")
4301
public static final <T> Set<T> emptySet() {
4302
return (Set<T>) EMPTY_SET;
4303
}
4304
4305
/**
4306
* @serial include
4307
*/
4308
private static class EmptySet<E>
4309
extends AbstractSet<E>
4310
implements Serializable
4311
{
4312
private static final long serialVersionUID = 1582296315990362920L;
4313
4314
public Iterator<E> iterator() { return emptyIterator(); }
4315
4316
public int size() {return 0;}
4317
public boolean isEmpty() {return true;}
4318
4319
public boolean contains(Object obj) {return false;}
4320
public boolean containsAll(Collection<?> c) { return c.isEmpty(); }
4321
4322
public Object[] toArray() { return new Object[0]; }
4323
4324
public <T> T[] toArray(T[] a) {
4325
if (a.length > 0)
4326
a[0] = null;
4327
return a;
4328
}
4329
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
4330
// Override default methods in Collection
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
4331
@Override
4332
public void forEach(Consumer<? super E> action) {
4333
Objects.requireNonNull(action);
4334
}
4335
@Override
4336
public boolean removeIf(Predicate<? super E> filter) {
4337
Objects.requireNonNull(filter);
4338
return false;
4339
}
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
4340
@Override
4341
public Spliterator<E> spliterator() { return Spliterators.emptySpliterator(); }
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
4342
duke
Initial load
Dec 1, 2007
4343
// Preserves singleton property
4344
private Object readResolve() {
4345
return EMPTY_SET;
4346
}
4347
}
4348
mduigou
4533691: Add Collections.emptySortedSet()
Nov 3, 2011
4349
/**
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4350
* Returns an empty sorted set (immutable). This set is serializable.
mduigou
4533691: Add Collections.emptySortedSet()
Nov 3, 2011
4351
*
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4352
* <p>This example illustrates the type-safe way to obtain an empty
4353
* sorted set:
4354
* <pre> {@code
4355
* SortedSet<String> s = Collections.emptySortedSet();
4356
* }</pre>
mduigou
4533691: Add Collections.emptySortedSet()
Nov 3, 2011
4357
*
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4358
* @implNote Implementations of this method need not create a separate
4359
* {@code SortedSet} object for each call.
4360
*
4361
* @param <E> type of elements, if there were any, in the set
4362
* @return the empty sorted set
mduigou
4533691: Add Collections.emptySortedSet()
Nov 3, 2011
4363
* @since 1.8
4364
*/
4365
@SuppressWarnings("unchecked")
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4366
public static <E> SortedSet<E> emptySortedSet() {
4367
return (SortedSet<E>) UnmodifiableNavigableSet.EMPTY_NAVIGABLE_SET;
mduigou
4533691: Add Collections.emptySortedSet()
Nov 3, 2011
4368
}
4369
4370
/**
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4371
* Returns an empty navigable set (immutable). This set is serializable.
4372
*
4373
* <p>This example illustrates the type-safe way to obtain an empty
4374
* navigable set:
4375
* <pre> {@code
4376
* NavigableSet<String> s = Collections.emptyNavigableSet();
4377
* }</pre>
4378
*
4379
* @implNote Implementations of this method need not
4380
* create a separate {@code NavigableSet} object for each call.
4381
*
4382
* @param <E> type of elements, if there were any, in the set
4383
* @return the empty navigable set
4384
* @since 1.8
mduigou
4533691: Add Collections.emptySortedSet()
Nov 3, 2011
4385
*/
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4386
@SuppressWarnings("unchecked")
4387
public static <E> NavigableSet<E> emptyNavigableSet() {
4388
return (NavigableSet<E>) UnmodifiableNavigableSet.EMPTY_NAVIGABLE_SET;
mduigou
4533691: Add Collections.emptySortedSet()
Nov 3, 2011
4389
}
4390
duke
Initial load
Dec 1, 2007
4391
/**
4392
* The empty list (immutable). This list is serializable.
4393
*
4394
* @see #emptyList()
4395
*/
dxu
7193406: Clean-up JDK Build Warnings in java.util, java.io
Aug 31, 2012
4396
@SuppressWarnings("rawtypes")
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
4397
public static final List EMPTY_LIST = new EmptyList<>();
duke
Initial load
Dec 1, 2007
4398
4399
/**
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4400
* Returns an empty list (immutable). This list is serializable.
duke
Initial load
Dec 1, 2007
4401
*
4402
* <p>This example illustrates the type-safe way to obtain an empty list:
4403
* <pre>
4404
* List&lt;String&gt; s = Collections.emptyList();
4405
* </pre>
psandoz
8030848: Collections.sort(List l, Comparator) should defer to List.so…
Jan 24, 2014
4406
*
4407
* @implNote
4408
* Implementations of this method need not create a separate <tt>List</tt>
4409
* object for each call. Using this method is likely to have comparable
4410
* cost to using the like-named field. (Unlike this method, the field does
4411
* not provide type safety.)
duke
Initial load
Dec 1, 2007
4412
*
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4413
* @param <T> type of elements, if there were any, in the list
4414
* @return an empty immutable list
4415
*
duke
Initial load
Dec 1, 2007
4416
* @see #EMPTY_LIST
4417
* @since 1.5
4418
*/
4419
@SuppressWarnings("unchecked")
4420
public static final <T> List<T> emptyList() {
4421
return (List<T>) EMPTY_LIST;
4422
}
4423
4424
/**
4425
* @serial include
4426
*/
4427
private static class EmptyList<E>
4428
extends AbstractList<E>
4429
implements RandomAccess, Serializable {
4430
private static final long serialVersionUID = 8842843931221139166L;
4431
4432
public Iterator<E> iterator() {
4433
return emptyIterator();
4434
}
4435
public ListIterator<E> listIterator() {
4436
return emptyListIterator();
4437
}
4438
4439
public int size() {return 0;}
4440
public boolean isEmpty() {return true;}
4441
4442
public boolean contains(Object obj) {return false;}
4443
public boolean containsAll(Collection<?> c) { return c.isEmpty(); }
4444
4445
public Object[] toArray() { return new Object[0]; }
4446
4447
public <T> T[] toArray(T[] a) {
4448
if (a.length > 0)
4449
a[0] = null;
4450
return a;
4451
}
4452
4453
public E get(int index) {
4454
throw new IndexOutOfBoundsException("Index: "+index);
4455
}
4456
4457
public boolean equals(Object o) {
4458
return (o instanceof List) && ((List<?>)o).isEmpty();
4459
}
4460
4461
public int hashCode() { return 1; }
4462
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
4463
@Override
4464
public boolean removeIf(Predicate<? super E> filter) {
4465
Objects.requireNonNull(filter);
4466
return false;
4467
}
4468
@Override
4469
public void replaceAll(UnaryOperator<E> operator) {
4470
Objects.requireNonNull(operator);
4471
}
4472
@Override
4473
public void sort(Comparator<? super E> c) {
4474
}
4475
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
4476
// Override default methods in Collection
4477
@Override
4478
public void forEach(Consumer<? super E> action) {
4479
Objects.requireNonNull(action);
4480
}
4481
4482
@Override
4483
public Spliterator<E> spliterator() { return Spliterators.emptySpliterator(); }
4484
duke
Initial load
Dec 1, 2007
4485
// Preserves singleton property
4486
private Object readResolve() {
4487
return EMPTY_LIST;
4488
}
4489
}
4490
4491
/**
4492
* The empty map (immutable). This map is serializable.
4493
*
4494
* @see #emptyMap()
4495
* @since 1.3
4496
*/
dxu
7193406: Clean-up JDK Build Warnings in java.util, java.io
Aug 31, 2012
4497
@SuppressWarnings("rawtypes")
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
4498
public static final Map EMPTY_MAP = new EmptyMap<>();
duke
Initial load
Dec 1, 2007
4499
4500
/**
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4501
* Returns an empty map (immutable). This map is serializable.
duke
Initial load
Dec 1, 2007
4502
*
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4503
* <p>This example illustrates the type-safe way to obtain an empty map:
duke
Initial load
Dec 1, 2007
4504
* <pre>
4505
* Map&lt;String, Date&gt; s = Collections.emptyMap();
4506
* </pre>
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4507
* @implNote Implementations of this method need not create a separate
4508
* {@code Map} object for each call. Using this method is likely to have
4509
* comparable cost to using the like-named field. (Unlike this method, the
4510
* field does not provide type safety.)
duke
Initial load
Dec 1, 2007
4511
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4512
* @param <K> the class of the map keys
4513
* @param <V> the class of the map values
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4514
* @return an empty map
duke
Initial load
Dec 1, 2007
4515
* @see #EMPTY_MAP
4516
* @since 1.5
4517
*/
4518
@SuppressWarnings("unchecked")
4519
public static final <K,V> Map<K,V> emptyMap() {
4520
return (Map<K,V>) EMPTY_MAP;
4521
}
4522
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4523
/**
4524
* Returns an empty sorted map (immutable). This map is serializable.
4525
*
4526
* <p>This example illustrates the type-safe way to obtain an empty map:
4527
* <pre> {@code
4528
* SortedMap<String, Date> s = Collections.emptySortedMap();
4529
* }</pre>
4530
*
4531
* @implNote Implementations of this method need not create a separate
4532
* {@code SortedMap} object for each call.
4533
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4534
* @param <K> the class of the map keys
4535
* @param <V> the class of the map values
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4536
* @return an empty sorted map
4537
* @since 1.8
4538
*/
4539
@SuppressWarnings("unchecked")
4540
public static final <K,V> SortedMap<K,V> emptySortedMap() {
4541
return (SortedMap<K,V>) UnmodifiableNavigableMap.EMPTY_NAVIGABLE_MAP;
4542
}
4543
4544
/**
4545
* Returns an empty navigable map (immutable). This map is serializable.
4546
*
4547
* <p>This example illustrates the type-safe way to obtain an empty map:
4548
* <pre> {@code
4549
* NavigableMap<String, Date> s = Collections.emptyNavigableMap();
4550
* }</pre>
4551
*
4552
* @implNote Implementations of this method need not create a separate
4553
* {@code NavigableMap} object for each call.
4554
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4555
* @param <K> the class of the map keys
4556
* @param <V> the class of the map values
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4557
* @return an empty navigable map
4558
* @since 1.8
4559
*/
4560
@SuppressWarnings("unchecked")
4561
public static final <K,V> NavigableMap<K,V> emptyNavigableMap() {
4562
return (NavigableMap<K,V>) UnmodifiableNavigableMap.EMPTY_NAVIGABLE_MAP;
4563
}
4564
duke
Initial load
Dec 1, 2007
4565
/**
4566
* @serial include
4567
*/
4568
private static class EmptyMap<K,V>
4569
extends AbstractMap<K,V>
4570
implements Serializable
4571
{
4572
private static final long serialVersionUID = 6428348081105594320L;
4573
4574
public int size() {return 0;}
4575
public boolean isEmpty() {return true;}
4576
public boolean containsKey(Object key) {return false;}
4577
public boolean containsValue(Object value) {return false;}
4578
public V get(Object key) {return null;}
4579
public Set<K> keySet() {return emptySet();}
4580
public Collection<V> values() {return emptySet();}
4581
public Set<Map.Entry<K,V>> entrySet() {return emptySet();}
4582
4583
public boolean equals(Object o) {
4584
return (o instanceof Map) && ((Map<?,?>)o).isEmpty();
4585
}
4586
4587
public int hashCode() {return 0;}
4588
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
4589
// Override default methods in Map
4590
@Override
4591
@SuppressWarnings("unchecked")
4592
public V getOrDefault(Object k, V defaultValue) {
4593
return defaultValue;
4594
}
4595
4596
@Override
4597
public void forEach(BiConsumer<? super K, ? super V> action) {
4598
Objects.requireNonNull(action);
4599
}
4600
4601
@Override
4602
public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
4603
Objects.requireNonNull(function);
4604
}
4605
4606
@Override
4607
public V putIfAbsent(K key, V value) {
4608
throw new UnsupportedOperationException();
4609
}
4610
4611
@Override
4612
public boolean remove(Object key, Object value) {
4613
throw new UnsupportedOperationException();
4614
}
4615
4616
@Override
4617
public boolean replace(K key, V oldValue, V newValue) {
4618
throw new UnsupportedOperationException();
4619
}
4620
4621
@Override
4622
public V replace(K key, V value) {
4623
throw new UnsupportedOperationException();
4624
}
4625
4626
@Override
4627
public V computeIfAbsent(K key,
4628
Function<? super K, ? extends V> mappingFunction) {
4629
throw new UnsupportedOperationException();
4630
}
4631
4632
@Override
4633
public V computeIfPresent(K key,
4634
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
4635
throw new UnsupportedOperationException();
4636
}
4637
4638
@Override
4639
public V compute(K key,
4640
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
4641
throw new UnsupportedOperationException();
4642
}
4643
4644
@Override
4645
public V merge(K key, V value,
4646
BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
4647
throw new UnsupportedOperationException();
4648
}
4649
duke
Initial load
Dec 1, 2007
4650
// Preserves singleton property
4651
private Object readResolve() {
4652
return EMPTY_MAP;
4653
}
4654
}
4655
4656
// Singleton collections
4657
4658
/**
4659
* Returns an immutable set containing only the specified object.
4660
* The returned set is serializable.
4661
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4662
* @param <T> the class of the objects in the set
duke
Initial load
Dec 1, 2007
4663
* @param o the sole object to be stored in the returned set.
4664
* @return an immutable set containing only the specified object.
4665
*/
4666
public static <T> Set<T> singleton(T o) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
4667
return new SingletonSet<>(o);
duke
Initial load
Dec 1, 2007
4668
}
4669
4670
static <E> Iterator<E> singletonIterator(final E e) {
4671
return new Iterator<E>() {
4672
private boolean hasNext = true;
4673
public boolean hasNext() {
4674
return hasNext;
4675
}
4676
public E next() {
4677
if (hasNext) {
4678
hasNext = false;
4679
return e;
4680
}
4681
throw new NoSuchElementException();
4682
}
4683
public void remove() {
4684
throw new UnsupportedOperationException();
4685
}
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
4686
@Override
4687
public void forEachRemaining(Consumer<? super E> action) {
4688
Objects.requireNonNull(action);
4689
if (hasNext) {
4690
action.accept(e);
4691
hasNext = false;
4692
}
4693
}
4694
};
4695
}
4696
4697
/**
4698
* Creates a {@code Spliterator} with only the specified element
4699
*
4700
* @param <T> Type of elements
4701
* @return A singleton {@code Spliterator}
4702
*/
4703
static <T> Spliterator<T> singletonSpliterator(final T element) {
4704
return new Spliterator<T>() {
4705
long est = 1;
4706
4707
@Override
4708
public Spliterator<T> trySplit() {
4709
return null;
4710
}
4711
4712
@Override
4713
public boolean tryAdvance(Consumer<? super T> consumer) {
4714
Objects.requireNonNull(consumer);
4715
if (est > 0) {
4716
est--;
4717
consumer.accept(element);
4718
return true;
4719
}
4720
return false;
4721
}
4722
4723
@Override
4724
public void forEachRemaining(Consumer<? super T> consumer) {
4725
tryAdvance(consumer);
4726
}
4727
4728
@Override
4729
public long estimateSize() {
4730
return est;
4731
}
4732
4733
@Override
4734
public int characteristics() {
4735
int value = (element != null) ? Spliterator.NONNULL : 0;
4736
4737
return value | Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.IMMUTABLE |
4738
Spliterator.DISTINCT | Spliterator.ORDERED;
4739
}
duke
Initial load
Dec 1, 2007
4740
};
4741
}
4742
4743
/**
4744
* @serial include
4745
*/
4746
private static class SingletonSet<E>
4747
extends AbstractSet<E>
4748
implements Serializable
4749
{
4750
private static final long serialVersionUID = 3193687207550431679L;
4751
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
4752
private final E element;
duke
Initial load
Dec 1, 2007
4753
4754
SingletonSet(E e) {element = e;}
4755
4756
public Iterator<E> iterator() {
4757
return singletonIterator(element);
4758
}
4759
4760
public int size() {return 1;}
4761
4762
public boolean contains(Object o) {return eq(o, element);}
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
4763
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
4764
// Override default methods for Collection
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
4765
@Override
4766
public void forEach(Consumer<? super E> action) {
4767
action.accept(element);
4768
}
4769
@Override
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
4770
public Spliterator<E> spliterator() {
4771
return singletonSpliterator(element);
4772
}
4773
@Override
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
4774
public boolean removeIf(Predicate<? super E> filter) {
4775
throw new UnsupportedOperationException();
4776
}
duke
Initial load
Dec 1, 2007
4777
}
4778
4779
/**
4780
* Returns an immutable list containing only the specified object.
4781
* The returned list is serializable.
4782
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4783
* @param <T> the class of the objects in the list
duke
Initial load
Dec 1, 2007
4784
* @param o the sole object to be stored in the returned list.
4785
* @return an immutable list containing only the specified object.
4786
* @since 1.3
4787
*/
4788
public static <T> List<T> singletonList(T o) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
4789
return new SingletonList<>(o);
duke
Initial load
Dec 1, 2007
4790
}
4791
4792
/**
4793
* @serial include
4794
*/
4795
private static class SingletonList<E>
4796
extends AbstractList<E>
4797
implements RandomAccess, Serializable {
4798
4799
private static final long serialVersionUID = 3093736618740652951L;
4800
4801
private final E element;
4802
4803
SingletonList(E obj) {element = obj;}
4804
4805
public Iterator<E> iterator() {
4806
return singletonIterator(element);
4807
}
4808
4809
public int size() {return 1;}
4810
4811
public boolean contains(Object obj) {return eq(obj, element);}
4812
4813
public E get(int index) {
4814
if (index != 0)
4815
throw new IndexOutOfBoundsException("Index: "+index+", Size: 1");
4816
return element;
4817
}
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
4818
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
4819
// Override default methods for Collection
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
4820
@Override
4821
public void forEach(Consumer<? super E> action) {
4822
action.accept(element);
4823
}
4824
@Override
4825
public boolean removeIf(Predicate<? super E> filter) {
4826
throw new UnsupportedOperationException();
4827
}
4828
@Override
4829
public void replaceAll(UnaryOperator<E> operator) {
4830
throw new UnsupportedOperationException();
4831
}
4832
@Override
4833
public void sort(Comparator<? super E> c) {
4834
}
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
4835
@Override
4836
public Spliterator<E> spliterator() {
4837
return singletonSpliterator(element);
4838
}
duke
Initial load
Dec 1, 2007
4839
}
4840
4841
/**
4842
* Returns an immutable map, mapping only the specified key to the
4843
* specified value. The returned map is serializable.
4844
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4845
* @param <K> the class of the map keys
4846
* @param <V> the class of the map values
duke
Initial load
Dec 1, 2007
4847
* @param key the sole key to be stored in the returned map.
4848
* @param value the value to which the returned map maps <tt>key</tt>.
4849
* @return an immutable map containing only the specified key-value
4850
* mapping.
4851
* @since 1.3
4852
*/
4853
public static <K,V> Map<K,V> singletonMap(K key, V value) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
4854
return new SingletonMap<>(key, value);
duke
Initial load
Dec 1, 2007
4855
}
4856
4857
/**
4858
* @serial include
4859
*/
4860
private static class SingletonMap<K,V>
4861
extends AbstractMap<K,V>
4862
implements Serializable {
4863
private static final long serialVersionUID = -6979724477215052911L;
4864
4865
private final K k;
4866
private final V v;
4867
4868
SingletonMap(K key, V value) {
4869
k = key;
4870
v = value;
4871
}
4872
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
4873
public int size() {return 1;}
4874
public boolean isEmpty() {return false;}
4875
public boolean containsKey(Object key) {return eq(key, k);}
4876
public boolean containsValue(Object value) {return eq(value, v);}
4877
public V get(Object key) {return (eq(key, k) ? v : null);}
duke
Initial load
Dec 1, 2007
4878
mduigou
8035284: Remove redundant initializations to null
Apr 11, 2014
4879
private transient Set<K> keySet;
4880
private transient Set<Map.Entry<K,V>> entrySet;
4881
private transient Collection<V> values;
duke
Initial load
Dec 1, 2007
4882
4883
public Set<K> keySet() {
4884
if (keySet==null)
4885
keySet = singleton(k);
4886
return keySet;
4887
}
4888
4889
public Set<Map.Entry<K,V>> entrySet() {
4890
if (entrySet==null)
4891
entrySet = Collections.<Map.Entry<K,V>>singleton(
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
4892
new SimpleImmutableEntry<>(k, v));
duke
Initial load
Dec 1, 2007
4893
return entrySet;
4894
}
4895
4896
public Collection<V> values() {
4897
if (values==null)
4898
values = singleton(v);
4899
return values;
4900
}
4901
mduigou
8004518: Add in-place operations to Map
Apr 16, 2013
4902
// Override default methods in Map
4903
@Override
4904
public V getOrDefault(Object key, V defaultValue) {
4905
return eq(key, k) ? v : defaultValue;
4906
}
4907
4908
@Override
4909
public void forEach(BiConsumer<? super K, ? super V> action) {
4910
action.accept(k, v);
4911
}
4912
4913
@Override
4914
public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
4915
throw new UnsupportedOperationException();
4916
}
4917
4918
@Override
4919
public V putIfAbsent(K key, V value) {
4920
throw new UnsupportedOperationException();
4921
}
4922
4923
@Override
4924
public boolean remove(Object key, Object value) {
4925
throw new UnsupportedOperationException();
4926
}
4927
4928
@Override
4929
public boolean replace(K key, V oldValue, V newValue) {
4930
throw new UnsupportedOperationException();
4931
}
4932
4933
@Override
4934
public V replace(K key, V value) {
4935
throw new UnsupportedOperationException();
4936
}
4937
4938
@Override
4939
public V computeIfAbsent(K key,
4940
Function<? super K, ? extends V> mappingFunction) {
4941
throw new UnsupportedOperationException();
4942
}
4943
4944
@Override
4945
public V computeIfPresent(K key,
4946
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
4947
throw new UnsupportedOperationException();
4948
}
4949
4950
@Override
4951
public V compute(K key,
4952
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
4953
throw new UnsupportedOperationException();
4954
}
4955
4956
@Override
4957
public V merge(K key, V value,
4958
BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
4959
throw new UnsupportedOperationException();
4960
}
duke
Initial load
Dec 1, 2007
4961
}
4962
4963
// Miscellaneous
4964
4965
/**
4966
* Returns an immutable list consisting of <tt>n</tt> copies of the
4967
* specified object. The newly allocated data object is tiny (it contains
4968
* a single reference to the data object). This method is useful in
4969
* combination with the <tt>List.addAll</tt> method to grow lists.
4970
* The returned list is serializable.
4971
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
4972
* @param <T> the class of the object to copy and of the objects
4973
* in the returned list.
duke
Initial load
Dec 1, 2007
4974
* @param n the number of elements in the returned list.
4975
* @param o the element to appear repeatedly in the returned list.
4976
* @return an immutable list consisting of <tt>n</tt> copies of the
4977
* specified object.
dl
7003745: Code style cleanups (sync from Dougs CVS)
Dec 1, 2010
4978
* @throws IllegalArgumentException if {@code n < 0}
duke
Initial load
Dec 1, 2007
4979
* @see List#addAll(Collection)
4980
* @see List#addAll(int, Collection)
4981
*/
4982
public static <T> List<T> nCopies(int n, T o) {
4983
if (n < 0)
4984
throw new IllegalArgumentException("List length = " + n);
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
4985
return new CopiesList<>(n, o);
duke
Initial load
Dec 1, 2007
4986
}
4987
4988
/**
4989
* @serial include
4990
*/
4991
private static class CopiesList<E>
4992
extends AbstractList<E>
4993
implements RandomAccess, Serializable
4994
{
4995
private static final long serialVersionUID = 2739099268398711800L;
4996
4997
final int n;
4998
final E element;
4999
5000
CopiesList(int n, E e) {
5001
assert n >= 0;
5002
this.n = n;
5003
element = e;
5004
}
5005
5006
public int size() {
5007
return n;
5008
}
5009
5010
public boolean contains(Object obj) {
5011
return n != 0 && eq(obj, element);
5012
}
5013
5014
public int indexOf(Object o) {
5015
return contains(o) ? 0 : -1;
5016
}
5017
5018
public int lastIndexOf(Object o) {
5019
return contains(o) ? n - 1 : -1;
5020
}
5021
5022
public E get(int index) {
5023
if (index < 0 || index >= n)
5024
throw new IndexOutOfBoundsException("Index: "+index+
5025
", Size: "+n);
5026
return element;
5027
}
5028
5029
public Object[] toArray() {
5030
final Object[] a = new Object[n];
5031
if (element != null)
5032
Arrays.fill(a, 0, n, element);
5033
return a;
5034
}
5035
dxu
7193406: Clean-up JDK Build Warnings in java.util, java.io
Aug 31, 2012
5036
@SuppressWarnings("unchecked")
duke
Initial load
Dec 1, 2007
5037
public <T> T[] toArray(T[] a) {
5038
final int n = this.n;
5039
if (a.length < n) {
5040
a = (T[])java.lang.reflect.Array
5041
.newInstance(a.getClass().getComponentType(), n);
5042
if (element != null)
5043
Arrays.fill(a, 0, n, element);
5044
} else {
5045
Arrays.fill(a, 0, n, element);
5046
if (a.length > n)
5047
a[n] = null;
5048
}
5049
return a;
5050
}
5051
5052
public List<E> subList(int fromIndex, int toIndex) {
5053
if (fromIndex < 0)
5054
throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
5055
if (toIndex > n)
5056
throw new IndexOutOfBoundsException("toIndex = " + toIndex);
5057
if (fromIndex > toIndex)
5058
throw new IllegalArgumentException("fromIndex(" + fromIndex +
5059
") > toIndex(" + toIndex + ")");
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
5060
return new CopiesList<>(toIndex - fromIndex, element);
duke
Initial load
Dec 1, 2007
5061
}
henryjen
8023275: Wrapping collections should override default methods
Aug 27, 2013
5062
5063
// Override default methods in Collection
5064
@Override
5065
public Stream<E> stream() {
5066
return IntStream.range(0, n).mapToObj(i -> element);
5067
}
5068
5069
@Override
5070
public Stream<E> parallelStream() {
5071
return IntStream.range(0, n).parallel().mapToObj(i -> element);
5072
}
5073
5074
@Override
5075
public Spliterator<E> spliterator() {
5076
return stream().spliterator();
5077
}
duke
Initial load
Dec 1, 2007
5078
}
5079
5080
/**
mduigou
7030442: Add missing @param tag for Collections.reverseOrder()
Mar 25, 2011
5081
* Returns a comparator that imposes the reverse of the <em>natural
5082
* ordering</em> on a collection of objects that implement the
5083
* {@code Comparable} interface. (The natural ordering is the ordering
5084
* imposed by the objects' own {@code compareTo} method.) This enables a
duke
Initial load
Dec 1, 2007
5085
* simple idiom for sorting (or maintaining) collections (or arrays) of
mduigou
7030442: Add missing @param tag for Collections.reverseOrder()
Mar 25, 2011
5086
* objects that implement the {@code Comparable} interface in
5087
* reverse-natural-order. For example, suppose {@code a} is an array of
duke
Initial load
Dec 1, 2007
5088
* strings. Then: <pre>
5089
* Arrays.sort(a, Collections.reverseOrder());
5090
* </pre> sorts the array in reverse-lexicographic (alphabetical) order.<p>
5091
*
5092
* The returned comparator is serializable.
5093
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
5094
* @param <T> the class of the objects compared by the comparator
mduigou
7030442: Add missing @param tag for Collections.reverseOrder()
Mar 25, 2011
5095
* @return A comparator that imposes the reverse of the <i>natural
duke
Initial load
Dec 1, 2007
5096
* ordering</i> on a collection of objects that implement
5097
* the <tt>Comparable</tt> interface.
5098
* @see Comparable
5099
*/
dxu
7193406: Clean-up JDK Build Warnings in java.util, java.io
Aug 31, 2012
5100
@SuppressWarnings("unchecked")
duke
Initial load
Dec 1, 2007
5101
public static <T> Comparator<T> reverseOrder() {
5102
return (Comparator<T>) ReverseComparator.REVERSE_ORDER;
5103
}
5104
5105
/**
5106
* @serial include
5107
*/
5108
private static class ReverseComparator
5109
implements Comparator<Comparable<Object>>, Serializable {
5110
5111
private static final long serialVersionUID = 7207038068494060240L;
5112
5113
static final ReverseComparator REVERSE_ORDER
5114
= new ReverseComparator();
5115
5116
public int compare(Comparable<Object> c1, Comparable<Object> c2) {
5117
return c2.compareTo(c1);
5118
}
5119
mduigou
8001667: Comparator combinators and extension methods
Mar 8, 2013
5120
private Object readResolve() { return Collections.reverseOrder(); }
henryjen
8009736: Comparator API cleanup
Jun 11, 2013
5121
5122
@Override
5123
public Comparator<Comparable<Object>> reversed() {
5124
return Comparator.naturalOrder();
5125
}
duke
Initial load
Dec 1, 2007
5126
}
5127
5128
/**
5129
* Returns a comparator that imposes the reverse ordering of the specified
mduigou
7030442: Add missing @param tag for Collections.reverseOrder()
Mar 25, 2011
5130
* comparator. If the specified comparator is {@code null}, this method is
duke
Initial load
Dec 1, 2007
5131
* equivalent to {@link #reverseOrder()} (in other words, it returns a
mduigou
7030442: Add missing @param tag for Collections.reverseOrder()
Mar 25, 2011
5132
* comparator that imposes the reverse of the <em>natural ordering</em> on
5133
* a collection of objects that implement the Comparable interface).
duke
Initial load
Dec 1, 2007
5134
*
5135
* <p>The returned comparator is serializable (assuming the specified
mduigou
7030442: Add missing @param tag for Collections.reverseOrder()
Mar 25, 2011
5136
* comparator is also serializable or {@code null}).
duke
Initial load
Dec 1, 2007
5137
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
5138
* @param <T> the class of the objects compared by the comparator
mduigou
7030442: Add missing @param tag for Collections.reverseOrder()
Mar 25, 2011
5139
* @param cmp a comparator who's ordering is to be reversed by the returned
5140
* comparator or {@code null}
5141
* @return A comparator that imposes the reverse ordering of the
5142
* specified comparator.
duke
Initial load
Dec 1, 2007
5143
* @since 1.5
5144
*/
5145
public static <T> Comparator<T> reverseOrder(Comparator<T> cmp) {
5146
if (cmp == null)
5147
return reverseOrder();
5148
5149
if (cmp instanceof ReverseComparator2)
5150
return ((ReverseComparator2<T>)cmp).cmp;
5151
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
5152
return new ReverseComparator2<>(cmp);
duke
Initial load
Dec 1, 2007
5153
}
5154
5155
/**
5156
* @serial include
5157
*/
5158
private static class ReverseComparator2<T> implements Comparator<T>,
5159
Serializable
5160
{
5161
private static final long serialVersionUID = 4374092139857L;
5162
5163
/**
5164
* The comparator specified in the static factory. This will never
5165
* be null, as the static factory returns a ReverseComparator
5166
* instance if its argument is null.
5167
*
5168
* @serial
5169
*/
5170
final Comparator<T> cmp;
5171
5172
ReverseComparator2(Comparator<T> cmp) {
5173
assert cmp != null;
5174
this.cmp = cmp;
5175
}
5176
5177
public int compare(T t1, T t2) {
5178
return cmp.compare(t2, t1);
5179
}
5180
5181
public boolean equals(Object o) {
5182
return (o == this) ||
5183
(o instanceof ReverseComparator2 &&
5184
cmp.equals(((ReverseComparator2)o).cmp));
5185
}
5186
5187
public int hashCode() {
5188
return cmp.hashCode() ^ Integer.MIN_VALUE;
5189
}
henryjen
8009736: Comparator API cleanup
Jun 11, 2013
5190
5191
@Override
5192
public Comparator<T> reversed() {
5193
return cmp;
5194
}
duke
Initial load
Dec 1, 2007
5195
}
5196
5197
/**
5198
* Returns an enumeration over the specified collection. This provides
5199
* interoperability with legacy APIs that require an enumeration
5200
* as input.
5201
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
5202
* @param <T> the class of the objects in the collection
duke
Initial load
Dec 1, 2007
5203
* @param c the collection for which an enumeration is to be returned.
5204
* @return an enumeration over the specified collection.
5205
* @see Enumeration
5206
*/
5207
public static <T> Enumeration<T> enumeration(final Collection<T> c) {
5208
return new Enumeration<T>() {
5209
private final Iterator<T> i = c.iterator();
5210
5211
public boolean hasMoreElements() {
5212
return i.hasNext();
5213
}
5214
5215
public T nextElement() {
5216
return i.next();
5217
}
5218
};
5219
}
5220
5221
/**
5222
* Returns an array list containing the elements returned by the
5223
* specified enumeration in the order they are returned by the
5224
* enumeration. This method provides interoperability between
5225
* legacy APIs that return enumerations and new APIs that require
5226
* collections.
5227
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
5228
* @param <T> the class of the objects returned by the enumeration
duke
Initial load
Dec 1, 2007
5229
* @param e enumeration providing elements for the returned
5230
* array list
5231
* @return an array list containing the elements returned
5232
* by the specified enumeration.
5233
* @since 1.4
5234
* @see Enumeration
5235
* @see ArrayList
5236
*/
5237
public static <T> ArrayList<T> list(Enumeration<T> e) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
5238
ArrayList<T> l = new ArrayList<>();
duke
Initial load
Dec 1, 2007
5239
while (e.hasMoreElements())
5240
l.add(e.nextElement());
5241
return l;
5242
}
5243
5244
/**
5245
* Returns true if the specified arguments are equal, or both null.
mduigou
7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set}
Jul 12, 2013
5246
*
5247
* NB: Do not replace with Object.equals until JDK-8015417 is resolved.
duke
Initial load
Dec 1, 2007
5248
*/
5249
static boolean eq(Object o1, Object o2) {
5250
return o1==null ? o2==null : o1.equals(o2);
5251
}
5252
5253
/**
5254
* Returns the number of elements in the specified collection equal to the
5255
* specified object. More formally, returns the number of elements
5256
* <tt>e</tt> in the collection such that
5257
* <tt>(o == null ? e == null : o.equals(e))</tt>.
5258
*
5259
* @param c the collection in which to determine the frequency
5260
* of <tt>o</tt>
5261
* @param o the object whose frequency is to be determined
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
5262
* @return the number of elements in {@code c} equal to {@code o}
duke
Initial load
Dec 1, 2007
5263
* @throws NullPointerException if <tt>c</tt> is null
5264
* @since 1.5
5265
*/
5266
public static int frequency(Collection<?> c, Object o) {
5267
int result = 0;
5268
if (o == null) {
5269
for (Object e : c)
5270
if (e == null)
5271
result++;
5272
} else {
5273
for (Object e : c)
5274
if (o.equals(e))
5275
result++;
5276
}
5277
return result;
5278
}
5279
5280
/**
mduigou
6728865: Provide a better heuristics for Collections.disjoint method
Jan 14, 2011
5281
* Returns {@code true} if the two specified collections have no
duke
Initial load
Dec 1, 2007
5282
* elements in common.
5283
*
5284
* <p>Care must be exercised if this method is used on collections that
mduigou
6728865: Provide a better heuristics for Collections.disjoint method
Jan 14, 2011
5285
* do not comply with the general contract for {@code Collection}.
duke
Initial load
Dec 1, 2007
5286
* Implementations may elect to iterate over either collection and test
5287
* for containment in the other collection (or to perform any equivalent
5288
* computation). If either collection uses a nonstandard equality test
mduigou
6728865: Provide a better heuristics for Collections.disjoint method
Jan 14, 2011
5289
* (as does a {@link SortedSet} whose ordering is not <em>compatible with
5290
* equals</em>, or the key set of an {@link IdentityHashMap}), both
duke
Initial load
Dec 1, 2007
5291
* collections must use the same nonstandard equality test, or the
5292
* result of this method is undefined.
5293
*
mduigou
6728865: Provide a better heuristics for Collections.disjoint method
Jan 14, 2011
5294
* <p>Care must also be exercised when using collections that have
5295
* restrictions on the elements that they may contain. Collection
5296
* implementations are allowed to throw exceptions for any operation
5297
* involving elements they deem ineligible. For absolute safety the
5298
* specified collections should contain only elements which are
5299
* eligible elements for both collections.
5300
*
duke
Initial load
Dec 1, 2007
5301
* <p>Note that it is permissible to pass the same collection in both
mduigou
6728865: Provide a better heuristics for Collections.disjoint method
Jan 14, 2011
5302
* parameters, in which case the method will return {@code true} if and
5303
* only if the collection is empty.
duke
Initial load
Dec 1, 2007
5304
*
5305
* @param c1 a collection
5306
* @param c2 a collection
mduigou
6728865: Provide a better heuristics for Collections.disjoint method
Jan 14, 2011
5307
* @return {@code true} if the two specified collections have no
5308
* elements in common.
5309
* @throws NullPointerException if either collection is {@code null}.
5310
* @throws NullPointerException if one collection contains a {@code null}
5311
* element and {@code null} is not an eligible element for the other collection.
mduigou
6546713: link the word (optional) in exception specifications to the …
Apr 21, 2011
5312
* (<a href="Collection.html#optional-restrictions">optional</a>)
mduigou
6728865: Provide a better heuristics for Collections.disjoint method
Jan 14, 2011
5313
* @throws ClassCastException if one collection contains an element that is
mduigou
6546713: link the word (optional) in exception specifications to the …
Apr 21, 2011
5314
* of a type which is ineligible for the other collection.
5315
* (<a href="Collection.html#optional-restrictions">optional</a>)
duke
Initial load
Dec 1, 2007
5316
* @since 1.5
5317
*/
5318
public static boolean disjoint(Collection<?> c1, Collection<?> c2) {
mduigou
6728865: Provide a better heuristics for Collections.disjoint method
Jan 14, 2011
5319
// The collection to be used for contains(). Preference is given to
5320
// the collection who's contains() has lower O() complexity.
5321
Collection<?> contains = c2;
5322
// The collection to be iterated. If the collections' contains() impl
5323
// are of different O() complexity, the collection with slower
5324
// contains() will be used for iteration. For collections who's
5325
// contains() are of the same complexity then best performance is
5326
// achieved by iterating the smaller collection.
5327
Collection<?> iterate = c1;
5328
5329
// Performance optimization cases. The heuristics:
5330
// 1. Generally iterate over c1.
5331
// 2. If c1 is a Set then iterate over c2.
5332
// 3. If either collection is empty then result is always true.
5333
// 4. Iterate over the smaller Collection.
5334
if (c1 instanceof Set) {
5335
// Use c1 for contains as a Set's contains() is expected to perform
5336
// better than O(N/2)
5337
iterate = c2;
5338
contains = c1;
5339
} else if (!(c2 instanceof Set)) {
5340
// Both are mere Collections. Iterate over smaller collection.
5341
// Example: If c1 contains 3 elements and c2 contains 50 elements and
5342
// assuming contains() requires ceiling(N/2) comparisons then
5343
// checking for all c1 elements in c2 would require 75 comparisons
5344
// (3 * ceiling(50/2)) vs. checking all c2 elements in c1 requiring
5345
// 100 comparisons (50 * ceiling(3/2)).
5346
int c1size = c1.size();
5347
int c2size = c2.size();
5348
if (c1size == 0 || c2size == 0) {
5349
// At least one collection is empty. Nothing will match.
5350
return true;
5351
}
5352
5353
if (c1size > c2size) {
5354
iterate = c2;
5355
contains = c1;
5356
}
duke
Initial load
Dec 1, 2007
5357
}
5358
mduigou
6728865: Provide a better heuristics for Collections.disjoint method
Jan 14, 2011
5359
for (Object e : iterate) {
5360
if (contains.contains(e)) {
5361
// Found a common element. Collections are not disjoint.
duke
Initial load
Dec 1, 2007
5362
return false;
mduigou
6728865: Provide a better heuristics for Collections.disjoint method
Jan 14, 2011
5363
}
5364
}
5365
5366
// No common elements were found.
duke
Initial load
Dec 1, 2007
5367
return true;
5368
}
5369
5370
/**
5371
* Adds all of the specified elements to the specified collection.
5372
* Elements to be added may be specified individually or as an array.
5373
* The behavior of this convenience method is identical to that of
5374
* <tt>c.addAll(Arrays.asList(elements))</tt>, but this method is likely
5375
* to run significantly faster under most implementations.
5376
*
5377
* <p>When elements are specified individually, this method provides a
5378
* convenient way to add a few elements to an existing collection:
5379
* <pre>
5380
* Collections.addAll(flavors, "Peaches 'n Plutonium", "Rocky Racoon");
5381
* </pre>
5382
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
5383
* @param <T> the class of the elements to add and of the collection
duke
Initial load
Dec 1, 2007
5384
* @param c the collection into which <tt>elements</tt> are to be inserted
5385
* @param elements the elements to insert into <tt>c</tt>
5386
* @return <tt>true</tt> if the collection changed as a result of the call
5387
* @throws UnsupportedOperationException if <tt>c</tt> does not support
5388
* the <tt>add</tt> operation
5389
* @throws NullPointerException if <tt>elements</tt> contains one or more
5390
* null values and <tt>c</tt> does not permit null elements, or
5391
* if <tt>c</tt> or <tt>elements</tt> are <tt>null</tt>
5392
* @throws IllegalArgumentException if some property of a value in
5393
* <tt>elements</tt> prevents it from being added to <tt>c</tt>
5394
* @see Collection#addAll(Collection)
5395
* @since 1.5
5396
*/
darcy
7006578: Project Coin: Retrofit JDK libraries with @SafeVarargs
Jan 25, 2011
5397
@SafeVarargs
duke
Initial load
Dec 1, 2007
5398
public static <T> boolean addAll(Collection<? super T> c, T... elements) {
5399
boolean result = false;
5400
for (T element : elements)
5401
result |= c.add(element);
5402
return result;
5403
}
5404
5405
/**
5406
* Returns a set backed by the specified map. The resulting set displays
5407
* the same ordering, concurrency, and performance characteristics as the
5408
* backing map. In essence, this factory method provides a {@link Set}
5409
* implementation corresponding to any {@link Map} implementation. There
5410
* is no need to use this method on a {@link Map} implementation that
5411
* already has a corresponding {@link Set} implementation (such as {@link
5412
* HashMap} or {@link TreeMap}).
5413
*
5414
* <p>Each method invocation on the set returned by this method results in
5415
* exactly one method invocation on the backing map or its <tt>keySet</tt>
5416
* view, with one exception. The <tt>addAll</tt> method is implemented
5417
* as a sequence of <tt>put</tt> invocations on the backing map.
5418
*
5419
* <p>The specified map must be empty at the time this method is invoked,
5420
* and should not be accessed directly after this method returns. These
5421
* conditions are ensured if the map is created empty, passed directly
5422
* to this method, and no reference to the map is retained, as illustrated
5423
* in the following code fragment:
5424
* <pre>
5425
* Set&lt;Object&gt; weakHashSet = Collections.newSetFromMap(
5426
* new WeakHashMap&lt;Object, Boolean&gt;());
5427
* </pre>
5428
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
5429
* @param <E> the class of the map keys and of the objects in the
5430
* returned set
duke
Initial load
Dec 1, 2007
5431
* @param map the backing map
5432
* @return the set backed by the map
5433
* @throws IllegalArgumentException if <tt>map</tt> is not empty
5434
* @since 1.6
5435
*/
5436
public static <E> Set<E> newSetFromMap(Map<E, Boolean> map) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
5437
return new SetFromMap<>(map);
duke
Initial load
Dec 1, 2007
5438
}
5439
5440
/**
5441
* @serial include
5442
*/
5443
private static class SetFromMap<E> extends AbstractSet<E>
5444
implements Set<E>, Serializable
5445
{
5446
private final Map<E, Boolean> m; // The backing map
5447
private transient Set<E> s; // Its keySet
5448
5449
SetFromMap(Map<E, Boolean> map) {
5450
if (!map.isEmpty())
5451
throw new IllegalArgumentException("Map is non-empty");
5452
m = map;
5453
s = map.keySet();
5454
}
5455
5456
public void clear() { m.clear(); }
5457
public int size() { return m.size(); }
5458
public boolean isEmpty() { return m.isEmpty(); }
5459
public boolean contains(Object o) { return m.containsKey(o); }
5460
public boolean remove(Object o) { return m.remove(o) != null; }
5461
public boolean add(E e) { return m.put(e, Boolean.TRUE) == null; }
5462
public Iterator<E> iterator() { return s.iterator(); }
5463
public Object[] toArray() { return s.toArray(); }
5464
public <T> T[] toArray(T[] a) { return s.toArray(a); }
5465
public String toString() { return s.toString(); }
5466
public int hashCode() { return s.hashCode(); }
5467
public boolean equals(Object o) { return o == this || s.equals(o); }
5468
public boolean containsAll(Collection<?> c) {return s.containsAll(c);}
5469
public boolean removeAll(Collection<?> c) {return s.removeAll(c);}
5470
public boolean retainAll(Collection<?> c) {return s.retainAll(c);}
5471
// addAll is the only inherited implementation
5472
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
5473
// Override default methods in Collection
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
5474
@Override
5475
public void forEach(Consumer<? super E> action) {
5476
s.forEach(action);
5477
}
5478
@Override
5479
public boolean removeIf(Predicate<? super E> filter) {
5480
return s.removeIf(filter);
5481
}
5482
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
5483
@Override
5484
public Spliterator<E> spliterator() {return s.spliterator();}
henryjen
8023275: Wrapping collections should override default methods
Aug 27, 2013
5485
@Override
5486
public Stream<E> stream() {return s.stream();}
5487
@Override
5488
public Stream<E> parallelStream() {return s.parallelStream();}
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
5489
duke
Initial load
Dec 1, 2007
5490
private static final long serialVersionUID = 2454657854757543876L;
5491
5492
private void readObject(java.io.ObjectInputStream stream)
5493
throws IOException, ClassNotFoundException
5494
{
5495
stream.defaultReadObject();
5496
s = m.keySet();
5497
}
5498
}
5499
5500
/**
5501
* Returns a view of a {@link Deque} as a Last-in-first-out (Lifo)
5502
* {@link Queue}. Method <tt>add</tt> is mapped to <tt>push</tt>,
5503
* <tt>remove</tt> is mapped to <tt>pop</tt> and so on. This
5504
* view can be useful when you would like to use a method
5505
* requiring a <tt>Queue</tt> but you need Lifo ordering.
5506
*
5507
* <p>Each method invocation on the queue returned by this method
5508
* results in exactly one method invocation on the backing deque, with
5509
* one exception. The {@link Queue#addAll addAll} method is
5510
* implemented as a sequence of {@link Deque#addFirst addFirst}
5511
* invocations on the backing deque.
5512
*
bpb
8020409: Clean up doclint problems in java.util package, part 1
Jul 15, 2013
5513
* @param <T> the class of the objects in the deque
duke
Initial load
Dec 1, 2007
5514
* @param deque the deque
5515
* @return the queue
5516
* @since 1.6
5517
*/
5518
public static <T> Queue<T> asLifoQueue(Deque<T> deque) {
smarks
6880112: Project Coin: Port JDK core library code to use diamond oper…
Dec 20, 2010
5519
return new AsLIFOQueue<>(deque);
duke
Initial load
Dec 1, 2007
5520
}
5521
5522
/**
5523
* @serial include
5524
*/
5525
static class AsLIFOQueue<E> extends AbstractQueue<E>
5526
implements Queue<E>, Serializable {
5527
private static final long serialVersionUID = 1802017725587941708L;
5528
private final Deque<E> q;
5529
AsLIFOQueue(Deque<E> q) { this.q = q; }
5530
public boolean add(E e) { q.addFirst(e); return true; }
5531
public boolean offer(E e) { return q.offerFirst(e); }
5532
public E poll() { return q.pollFirst(); }
5533
public E remove() { return q.removeFirst(); }
5534
public E peek() { return q.peekFirst(); }
5535
public E element() { return q.getFirst(); }
5536
public void clear() { q.clear(); }
5537
public int size() { return q.size(); }
5538
public boolean isEmpty() { return q.isEmpty(); }
5539
public boolean contains(Object o) { return q.contains(o); }
5540
public boolean remove(Object o) { return q.remove(o); }
5541
public Iterator<E> iterator() { return q.iterator(); }
5542
public Object[] toArray() { return q.toArray(); }
5543
public <T> T[] toArray(T[] a) { return q.toArray(a); }
5544
public String toString() { return q.toString(); }
5545
public boolean containsAll(Collection<?> c) {return q.containsAll(c);}
5546
public boolean removeAll(Collection<?> c) {return q.removeAll(c);}
5547
public boolean retainAll(Collection<?> c) {return q.retainAll(c);}
5548
// We use inherited addAll; forwarding addAll would be wrong
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
5549
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
5550
// Override default methods in Collection
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
5551
@Override
psandoz
8011426: java.util collection Spliterator implementations
Apr 17, 2013
5552
public void forEach(Consumer<? super E> action) {q.forEach(action);}
5553
@Override
akhil
8001647: default methods for Collections - forEach, removeIf, replace…
Apr 22, 2013
5554
public boolean removeIf(Predicate<? super E> filter) {
5555
return q.removeIf(filter);
5556
}
henryjen
8023275: Wrapping collections should override default methods
Aug 27, 2013
5557
@Override
5558
public Spliterator<E> spliterator() {return q.spliterator();}
5559
@Override
5560
public Stream<E> stream() {return q.stream();}
5561
@Override
5562
public Stream<E> parallelStream() {return q.parallelStream();}
duke
Initial load
Dec 1, 2007
5563
}
5564
}