src/share/classes/java/util/Collections.java

Print this page
rev 6970 : [mq]: collections

*** 28,38 **** --- 28,41 ---- import java.io.ObjectOutputStream; import java.io.IOException; import java.lang.reflect.Array; import java.util.function.BiConsumer; import java.util.function.BiFunction; + import java.util.function.Consumer; import java.util.function.Function; + import java.util.function.Predicate; + import java.util.function.UnaryOperator; /** * This class consists exclusively of static methods that operate on or return * collections. It contains polymorphic algorithms that operate on * collections, "wrappers", which return a new collection backed by a
*** 1108,1117 **** --- 1111,1129 ---- throw new UnsupportedOperationException(); } public void clear() { throw new UnsupportedOperationException(); } + + @Override + public void forEach(Consumer<? super E> action) { + c.forEach(action); + } + @Override + public boolean removeIf(Predicate<? super E> filter) { + throw new UnsupportedOperationException(); + } } /** * Returns an unmodifiable view of the specified set. This method allows * modules to provide users with "read-only" access to internal sets.
*** 1238,1247 **** --- 1250,1269 ---- public int indexOf(Object o) {return list.indexOf(o);} public int lastIndexOf(Object o) {return list.lastIndexOf(o);} public boolean addAll(int index, Collection<? extends E> c) { throw new UnsupportedOperationException(); } + + @Override + public void replaceAll(UnaryOperator<E> operator) { + throw new UnsupportedOperationException(); + } + @Override + public void sort(Comparator<? super E> c) { + throw new UnsupportedOperationException(); + } + public ListIterator<E> listIterator() {return listIterator(0);} public ListIterator<E> listIterator(final int index) { return new ListIterator<E>() { private final ListIterator<? extends E> i
*** 1740,1749 **** --- 1762,1780 ---- synchronized (mutex) {return c.toString();} } private void writeObject(ObjectOutputStream s) throws IOException { synchronized (mutex) {s.defaultWriteObject();} } + + @Override + public void forEach(Consumer<? super E> action) { + synchronized (mutex) {c.forEach(action);} + } + @Override + public boolean removeIf(Predicate<? super E> filter) { + synchronized (mutex) {return c.removeIf(filter);} + } } /** * Returns a synchronized (thread-safe) set backed by the specified * set. In order to guarantee serial access, it is critical that
*** 1994,2003 **** --- 2025,2043 ---- return new SynchronizedList<>(list.subList(fromIndex, toIndex), mutex); } } + @Override + public void replaceAll(UnaryOperator<E> operator) { + synchronized (mutex) {list.replaceAll(operator);} + } + @Override + public void sort(Comparator<? super E> c) { + synchronized (mutex) {list.sort(c);} + } + /** * SynchronizedRandomAccessList instances are serialized as * SynchronizedList instances to allow them to be deserialized * in pre-1.4 JREs (which do not have SynchronizedRandomAccessList). * This method inverts the transformation. As a beneficial
*** 2490,2499 **** --- 2530,2548 ---- // in the contents of coll and provides all-or-nothing // semantics (which we wouldn't get if we type-checked each // element as we added it) return c.addAll(checkedCopyOf(coll)); } + + @Override + public void forEach(Consumer<? super E> action) { + c.forEach(action); + } + @Override + public boolean removeIf(Predicate<? super E> filter) { + return c.removeIf(filter); + } } /** * Returns a dynamically typesafe view of the specified queue. * Any attempt to insert an element of the wrong type will result in
*** 2751,2760 **** --- 2800,2818 ---- } public List<E> subList(int fromIndex, int toIndex) { return new CheckedList<>(list.subList(fromIndex, toIndex), type); } + + @Override + public void replaceAll(UnaryOperator<E> operator) { + list.replaceAll(operator); + } + @Override + public void sort(Comparator<? super E> c) { + list.sort(c); + } } /** * @serial include */
*** 3414,3423 **** --- 3472,3491 ---- if (a.length > 0) a[0] = null; return a; } + @Override + public void forEach(Consumer<? super E> action) { + Objects.requireNonNull(action); + } + @Override + public boolean removeIf(Predicate<? super E> filter) { + Objects.requireNonNull(filter); + return false; + } + // Preserves singleton property private Object readResolve() { return EMPTY_SET; } }
*** 3521,3530 **** --- 3589,3608 ---- @Override public E last() { throw new NoSuchElementException(); } + + @Override + public void forEach(Consumer<? super E> action) { + Objects.requireNonNull(action); + } + @Override + public boolean removeIf(Predicate<? super E> filter) { + Objects.requireNonNull(filter); + return false; + } } /** * The empty list (immutable). This list is serializable. *
*** 3590,3599 **** --- 3668,3695 ---- return (o instanceof List) && ((List<?>)o).isEmpty(); } public int hashCode() { return 1; } + @Override + public void forEach(Consumer<? super E> action) { + Objects.requireNonNull(action); + } + @Override + public boolean removeIf(Predicate<? super E> filter) { + Objects.requireNonNull(filter); + return false; + } + @Override + public void replaceAll(UnaryOperator<E> operator) { + Objects.requireNonNull(operator); + } + @Override + public void sort(Comparator<? super E> c) { + Objects.requireNonNull(c); + } + // Preserves singleton property private Object readResolve() { return EMPTY_LIST; } }
*** 3768,3777 **** --- 3864,3882 ---- } public int size() {return 1;} public boolean contains(Object o) {return eq(o, element);} + + @Override + public void forEach(Consumer<? super E> action) { + action.accept(element); + } + @Override + public boolean removeIf(Predicate<? super E> filter) { + throw new UnsupportedOperationException(); + } } /** * Returns an immutable list containing only the specified object. * The returned list is serializable.
*** 3808,3817 **** --- 3913,3938 ---- public E get(int index) { if (index != 0) throw new IndexOutOfBoundsException("Index: "+index+", Size: 1"); return element; } + + @Override + public void forEach(Consumer<? super E> action) { + action.accept(element); + } + @Override + public boolean removeIf(Predicate<? super E> filter) { + throw new UnsupportedOperationException(); + } + @Override + public void replaceAll(UnaryOperator<E> operator) { + throw new UnsupportedOperationException(); + } + @Override + public void sort(Comparator<? super E> c) { + } } /** * Returns an immutable map, mapping only the specified key to the * specified value. The returned map is serializable.
*** 4406,4415 **** --- 4527,4545 ---- public boolean containsAll(Collection<?> c) {return s.containsAll(c);} public boolean removeAll(Collection<?> c) {return s.removeAll(c);} public boolean retainAll(Collection<?> c) {return s.retainAll(c);} // addAll is the only inherited implementation + @Override + public void forEach(Consumer<? super E> action) { + s.forEach(action); + } + @Override + public boolean removeIf(Predicate<? super E> filter) { + return s.removeIf(filter); + } + private static final long serialVersionUID = 2454657854757543876L; private void readObject(java.io.ObjectInputStream stream) throws IOException, ClassNotFoundException {
*** 4464,4470 **** --- 4594,4609 ---- public String toString() { return q.toString(); } public boolean containsAll(Collection<?> c) {return q.containsAll(c);} public boolean removeAll(Collection<?> c) {return q.removeAll(c);} public boolean retainAll(Collection<?> c) {return q.retainAll(c);} // We use inherited addAll; forwarding addAll would be wrong + + @Override + public void forEach(Consumer<? super E> action) { + q.forEach(action); + } + @Override + public boolean removeIf(Predicate<? super E> filter) { + return q.removeIf(filter); + } } }