32 * Expert Group and released to the public domain, as explained at
33 * http://creativecommons.org/publicdomain/zero/1.0/
34 */
35
36 package java.util.concurrent;
37
38 import java.io.ObjectStreamField;
39 import java.io.Serializable;
40 import java.lang.reflect.ParameterizedType;
41 import java.lang.reflect.Type;
42 import java.util.AbstractMap;
43 import java.util.Arrays;
44 import java.util.Collection;
45 import java.util.Comparator;
46 import java.util.Enumeration;
47 import java.util.HashMap;
48 import java.util.Hashtable;
49 import java.util.Iterator;
50 import java.util.Map;
51 import java.util.NoSuchElementException;
52 import java.util.Set;
53 import java.util.Spliterator;
54 import java.util.concurrent.ConcurrentMap;
55 import java.util.concurrent.ForkJoinPool;
56 import java.util.concurrent.atomic.AtomicReference;
57 import java.util.concurrent.locks.LockSupport;
58 import java.util.concurrent.locks.ReentrantLock;
59 import java.util.function.BiConsumer;
60 import java.util.function.BiFunction;
61 import java.util.function.BinaryOperator;
62 import java.util.function.Consumer;
63 import java.util.function.DoubleBinaryOperator;
64 import java.util.function.Function;
65 import java.util.function.IntBinaryOperator;
66 import java.util.function.LongBinaryOperator;
67 import java.util.function.ToDoubleBiFunction;
68 import java.util.function.ToDoubleFunction;
69 import java.util.function.ToIntBiFunction;
70 import java.util.function.ToIntFunction;
71 import java.util.function.ToLongBiFunction;
4393 sb.append(e == this ? "(this Collection)" : e);
4394 if (!it.hasNext())
4395 break;
4396 sb.append(',').append(' ');
4397 }
4398 }
4399 return sb.append(']').toString();
4400 }
4401
4402 public final boolean containsAll(Collection<?> c) {
4403 if (c != this) {
4404 for (Object e : c) {
4405 if (e == null || !contains(e))
4406 return false;
4407 }
4408 }
4409 return true;
4410 }
4411
4412 public final boolean removeAll(Collection<?> c) {
4413 boolean modified = false;
4414 for (Iterator<E> it = iterator(); it.hasNext();) {
4415 if (c.contains(it.next())) {
4416 it.remove();
4417 modified = true;
4418 }
4419 }
4420 return modified;
4421 }
4422
4423 public final boolean retainAll(Collection<?> c) {
4424 boolean modified = false;
4425 for (Iterator<E> it = iterator(); it.hasNext();) {
4426 if (!c.contains(it.next())) {
4427 it.remove();
4428 modified = true;
4429 }
4430 }
4431 return modified;
4432 }
4433
4434 }
4435
4436 /**
4437 * A view of a ConcurrentHashMap as a {@link Set} of keys, in
4438 * which additions may optionally be enabled by mapping to a
4439 * common value. This class cannot be directly instantiated.
4440 * See {@link #keySet() keySet()},
4441 * {@link #keySet(Object) keySet(V)},
4442 * {@link #newKeySet() newKeySet()},
4443 * {@link #newKeySet(int) newKeySet(int)}.
|
32 * Expert Group and released to the public domain, as explained at
33 * http://creativecommons.org/publicdomain/zero/1.0/
34 */
35
36 package java.util.concurrent;
37
38 import java.io.ObjectStreamField;
39 import java.io.Serializable;
40 import java.lang.reflect.ParameterizedType;
41 import java.lang.reflect.Type;
42 import java.util.AbstractMap;
43 import java.util.Arrays;
44 import java.util.Collection;
45 import java.util.Comparator;
46 import java.util.Enumeration;
47 import java.util.HashMap;
48 import java.util.Hashtable;
49 import java.util.Iterator;
50 import java.util.Map;
51 import java.util.NoSuchElementException;
52 import java.util.Objects;
53 import java.util.Set;
54 import java.util.Spliterator;
55 import java.util.concurrent.ConcurrentMap;
56 import java.util.concurrent.ForkJoinPool;
57 import java.util.concurrent.atomic.AtomicReference;
58 import java.util.concurrent.locks.LockSupport;
59 import java.util.concurrent.locks.ReentrantLock;
60 import java.util.function.BiConsumer;
61 import java.util.function.BiFunction;
62 import java.util.function.BinaryOperator;
63 import java.util.function.Consumer;
64 import java.util.function.DoubleBinaryOperator;
65 import java.util.function.Function;
66 import java.util.function.IntBinaryOperator;
67 import java.util.function.LongBinaryOperator;
68 import java.util.function.ToDoubleBiFunction;
69 import java.util.function.ToDoubleFunction;
70 import java.util.function.ToIntBiFunction;
71 import java.util.function.ToIntFunction;
72 import java.util.function.ToLongBiFunction;
4394 sb.append(e == this ? "(this Collection)" : e);
4395 if (!it.hasNext())
4396 break;
4397 sb.append(',').append(' ');
4398 }
4399 }
4400 return sb.append(']').toString();
4401 }
4402
4403 public final boolean containsAll(Collection<?> c) {
4404 if (c != this) {
4405 for (Object e : c) {
4406 if (e == null || !contains(e))
4407 return false;
4408 }
4409 }
4410 return true;
4411 }
4412
4413 public final boolean removeAll(Collection<?> c) {
4414 Objects.requireNonNull(c);
4415 boolean modified = false;
4416 for (Iterator<E> it = iterator(); it.hasNext();) {
4417 if (c.contains(it.next())) {
4418 it.remove();
4419 modified = true;
4420 }
4421 }
4422 return modified;
4423 }
4424
4425 public final boolean retainAll(Collection<?> c) {
4426 Objects.requireNonNull(c);
4427 boolean modified = false;
4428 for (Iterator<E> it = iterator(); it.hasNext();) {
4429 if (!c.contains(it.next())) {
4430 it.remove();
4431 modified = true;
4432 }
4433 }
4434 return modified;
4435 }
4436
4437 }
4438
4439 /**
4440 * A view of a ConcurrentHashMap as a {@link Set} of keys, in
4441 * which additions may optionally be enabled by mapping to a
4442 * common value. This class cannot be directly instantiated.
4443 * See {@link #keySet() keySet()},
4444 * {@link #keySet(Object) keySet(V)},
4445 * {@link #newKeySet() newKeySet()},
4446 * {@link #newKeySet(int) newKeySet(int)}.
|