java/util/AbstractCollection.java

/*
 * Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package java.util;

/**
 * This class provides a skeletal implementation of the <tt>Collection</tt>
 * interface, to minimize the effort required to implement this interface. <p>
 *
 * To implement an unmodifiable collection, the programmer needs only to
 * extend this class and provide implementations for the <tt>iterator</tt> and
 * <tt>size</tt> methods.  (The iterator returned by the <tt>iterator</tt>
 * method must implement <tt>hasNext</tt> and <tt>next</tt>.)<p>
 *
 * To implement a modifiable collection, the programmer must additionally
 * override this class's <tt>add</tt> method (which otherwise throws an
 * <tt>UnsupportedOperationException</tt>), and the iterator returned by the
 * <tt>iterator</tt> method must additionally implement its <tt>remove</tt>
 * method.<p>
 *
 * The programmer should generally provide a void (no argument) and
 * <tt>Collection</tt> constructor, as per the recommendation in the
 * <tt>Collection</tt> interface specification.<p>
 *
 * The documentation for each non-abstract method in this class describes its
 * implementation in detail.  Each of these methods may be overridden if
 * the collection being implemented admits a more efficient implementation.<p>
 *
 * This class is a member of the
 * <a href="{@docRoot}/../technotes/guides/collections/index.html">
 * Java Collections Framework</a>.
 *
 * @author  Josh Bloch
 * @author  Neal Gafter
 * @see Collection
 * @since 1.2
 */

public abstract class AbstractCollection<E> implements Collection<E> {
    /**
     * Sole constructor.  (For invocation by subclass constructors, typically
     * implicit.)
     */
    protected AbstractCollection() {
    }

    // Query Operations

    /**
     * Returns an iterator over the elements contained in this collection.
     *
     * @return an iterator over the elements contained in this collection
     */
    public abstract Iterator<E> iterator();

    public abstract int size();

    /**
     * {@inheritDoc}
     *
     * <p>This implementation returns <tt>size() == 0</tt>.
     */
    public boolean isEmpty() {
        return size() == 0;
    }

    /**
     * {@inheritDoc}
     *
     * <p>This implementation iterates over the elements in the collection,
     * checking each element in turn for equality with the specified element.
     *
     * @throws ClassCastException   {@inheritDoc}
     * @throws NullPointerException {@inheritDoc}
     */
    public boolean contains(Object o) {
        Iterator<E> it = iterator();
        if (o==null) {
            while (it.hasNext())
                if (it.next()==null)
                    return true;
        } else {
            while (it.hasNext())
                if (o.equals(it.next()))
                    return true;
        }
        return false;
    }

    /**
     * {@inheritDoc}
     *
     * <p>This implementation returns an array containing all the elements
     * returned by this collection's iterator, in the same order, stored in
     * consecutive elements of the array, starting with index {@code 0}.
     * The length of the returned array is equal to the number of elements
     * returned by the iterator, even if the size of this collection changes
     * during iteration, as might happen if the collection permits
     * concurrent modification during iteration.  The {@code size} method is
     * called only as an optimization hint; the correct result is returned
     * even if the iterator returns a different number of elements.
     *
     * <p>This method is equivalent to:
     *
     *  <pre> {@code
     * List<E> list = new ArrayList<E>(size());
     * for (E e : this)
     *     list.add(e);
     * return list.toArray();
     * }</pre>
     */
    public Object[] toArray() {
        // Estimate size of array; be prepared to see more or fewer elements
        Object[] r = new Object[size()];
        Iterator<E> it = iterator();
        for (int i = 0; i < r.length; i++) {
            if (! it.hasNext()) // fewer elements than expected
                return Arrays.copyOf(r, i);
            r[i] = it.next();
        }
        return it.hasNext() ? finishToArray(r, it) : r;
    }

    /**
     * {@inheritDoc}
     *
     * <p>This implementation returns an array containing all the elements
     * returned by this collection's iterator in the same order, stored in
     * consecutive elements of the array, starting with index {@code 0}.
     * If the number of elements returned by the iterator is too large to
     * fit into the specified array, then the elements are returned in a
     * newly allocated array with length equal to the number of elements
     * returned by the iterator, even if the size of this collection
     * changes during iteration, as might happen if the collection permits
     * concurrent modification during iteration.  The {@code size} method is
     * called only as an optimization hint; the correct result is returned
     * even if the iterator returns a different number of elements.
     *
     * <p>This method is equivalent to:
     *
     *  <pre> {@code
     * List<E> list = new ArrayList<E>(size());
     * for (E e : this)
     *     list.add(e);
     * return list.toArray(a);
     * }</pre>
     *
     * @throws ArrayStoreException  {@inheritDoc}
     * @throws NullPointerException {@inheritDoc}
     */
    public <T> T[] toArray(T[] a) {
        // Estimate size of array; be prepared to see more or fewer elements
        int size = size();
        T[] r = a.length >= size ? a :
                  (T[])java.lang.reflect.Array
                  .newInstance(a.getClass().getComponentType(), size);
        Iterator<E> it = iterator();

        for (int i = 0; i < r.length; i++) {
            if (! it.hasNext()) { // fewer elements than expected
                if (a != r)
                    return Arrays.copyOf(r, i);
                r[i] = null; // null-terminate
                return r;
            }
            r[i] = (T)it.next();
        }
        return it.hasNext() ? finishToArray(r, it) : r;
    }

    /**
     * Reallocates the array being used within toArray when the iterator
     * returned more elements than expected, and finishes filling it from
     * the iterator.
     *
     * @param r the array, replete with previously stored elements
     * @param it the in-progress iterator over this collection
     * @return array containing the elements in the given array, plus any
     *         further elements returned by the iterator, trimmed to size
     */
    private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
        int i = r.length;
        while (it.hasNext()) {
            int cap = r.length;
            if (i == cap) {
                int newCap = ((cap / 2) + 1) * 3;
                if (newCap <= cap) { // integer overflow
                    if (cap == Integer.MAX_VALUE)
                        throw new OutOfMemoryError
                            ("Required array size too large");
                    newCap = Integer.MAX_VALUE;
                }
                r = Arrays.copyOf(r, newCap);
            }
            r[i++] = (T)it.next();
        }
        // trim if overallocated
        return (i == r.length) ? r : Arrays.copyOf(r, i);
    }

    // Modification Operations

    /**
     * {@inheritDoc}
     *
     * <p>This implementation always throws an
     * <tt>UnsupportedOperationException</tt>.
     *
     * @throws UnsupportedOperationException {@inheritDoc}
     * @throws ClassCastException            {@inheritDoc}
     * @throws NullPointerException          {@inheritDoc}
     * @throws IllegalArgumentException      {@inheritDoc}
     * @throws IllegalStateException         {@inheritDoc}
     */
    public boolean add(E e) {
        throw new UnsupportedOperationException();
    }

    /**
     * {@inheritDoc}
     *
     * <p>This implementation iterates over the collection looking for the
     * specified element.  If it finds the element, it removes the element
     * from the collection using the iterator's remove method.
     *
     * <p>Note that this implementation throws an
     * <tt>UnsupportedOperationException</tt> if the iterator returned by this
     * collection's iterator method does not implement the <tt>remove</tt>
     * method and this collection contains the specified object.
     *
     * @throws UnsupportedOperationException {@inheritDoc}
     * @throws ClassCastException            {@inheritDoc}
     * @throws NullPointerException          {@inheritDoc}
     */
    public boolean remove(Object o) {
        Iterator<E> it = iterator();
        if (o==null) {
            while (it.hasNext()) {
                if (it.next()==null) {
                    it.remove();
                    return true;
                }
            }
        } else {
            while (it.hasNext()) {
                if (o.equals(it.next())) {
                    it.remove();
                    return true;
                }
            }
        }
        return false;
    }


    // Bulk Operations

    /**
     * {@inheritDoc}
     *
     * <p>This implementation iterates over the specified collection,
     * checking each element returned by the iterator in turn to see
     * if it's contained in this collection.  If all elements are so
     * contained <tt>true</tt> is returned, otherwise <tt>false</tt>.
     *
     * @throws ClassCastException            {@inheritDoc}
     * @throws NullPointerException          {@inheritDoc}
     * @see #contains(Object)
     */
    public boolean containsAll(Collection<?> c) {
        Iterator<?> it = c.iterator();
        while (it.hasNext())
            if (!contains(it.next()))
                return false;
        return true;
    }

    /**
     * {@inheritDoc}
     *
     * <p>This implementation iterates over the specified collection, and adds
     * each object returned by the iterator to this collection, in turn.
     *
     * <p>Note that this implementation will throw an
     * <tt>UnsupportedOperationException</tt> unless <tt>add</tt> is
     * overridden (assuming the specified collection is non-empty).
     *
     * @throws UnsupportedOperationException {@inheritDoc}
     * @throws ClassCastException            {@inheritDoc}
     * @throws NullPointerException          {@inheritDoc}
     * @throws IllegalArgumentException      {@inheritDoc}
     * @throws IllegalStateException         {@inheritDoc}
     *
     * @see #add(Object)
     */
    public boolean addAll(Collection<? extends E> c) {
        boolean modified = false;
        Iterator<? extends E> it = c.iterator();
        while (it.hasNext()) {
            if (add(it.next()))
                modified = true;
        }
        return modified;
    }

    /**
     * {@inheritDoc}
     *
     * <p>This implementation iterates over this collection, checking each
     * element returned by the iterator in turn to see if it's contained
     * in the specified collection.  If it's so contained, it's removed from
     * this collection with the iterator's <tt>remove</tt> method.
     *
     * <p>Note that this implementation will throw an
     * <tt>UnsupportedOperationException</tt> if the iterator returned by the
     * <tt>iterator</tt> method does not implement the <tt>remove</tt> method
     * and this collection contains one or more elements in common with the
     * specified collection.
     *
     * @throws UnsupportedOperationException {@inheritDoc}
     * @throws ClassCastException            {@inheritDoc}
     * @throws NullPointerException          {@inheritDoc}
     *
     * @see #remove(Object)
     * @see #contains(Object)
     */
    public boolean removeAll(Collection<?> c) {
        boolean modified = false;
        Iterator<?> it = iterator();
        while (it.hasNext()) {
            if (c.contains(it.next())) {
                it.remove();
                modified = true;
            }
        }
        return modified;
    }

    /**
     * {@inheritDoc}
     *
     * <p>This implementation iterates over this collection, checking each
     * element returned by the iterator in turn to see if it's contained
     * in the specified collection.  If it's not so contained, it's removed
     * from this collection with the iterator's <tt>remove</tt> method.
     *
     * <p>Note that this implementation will throw an
     * <tt>UnsupportedOperationException</tt> if the iterator returned by the
     * <tt>iterator</tt> method does not implement the <tt>remove</tt> method
     * and this collection contains one or more elements not present in the
     * specified collection.
     *
     * @throws UnsupportedOperationException {@inheritDoc}
     * @throws ClassCastException            {@inheritDoc}
     * @throws NullPointerException          {@inheritDoc}
     *
     * @see #remove(Object)
     * @see #contains(Object)
     */
    public boolean retainAll(Collection<?> c) {
        boolean modified = false;
        Iterator<E> it = iterator();
        while (it.hasNext()) {
            if (!c.contains(it.next())) {
                it.remove();
                modified = true;
            }
        }
        return modified;
    }

    /**
     * {@inheritDoc}
     *
     * <p>This implementation iterates over this collection, removing each
     * element using the <tt>Iterator.remove</tt> operation.  Most
     * implementations will probably choose to override this method for
     * efficiency.
     *
     * <p>Note that this implementation will throw an
     * <tt>UnsupportedOperationException</tt> if the iterator returned by this
     * collection's <tt>iterator</tt> method does not implement the
     * <tt>remove</tt> method and this collection is non-empty.
     *
     * @throws UnsupportedOperationException {@inheritDoc}
     */
    public void clear() {
        Iterator<E> it = iterator();
        while (it.hasNext()) {
            it.next();
            it.remove();
        }
    }


    //  String conversion

    /**
     * Returns a string representation of this collection.  The string
     * representation consists of a list of the collection's elements in the
     * order they are returned by its iterator, enclosed in square brackets
     * (<tt>"[]"</tt>).  Adjacent elements are separated by the characters
     * <tt>", "</tt> (comma and space).  Elements are converted to strings as
     * by {@link String#valueOf(Object)}.
     *
     * @return a string representation of this collection
     */
    public String toString() {
        Iterator<E> it = iterator();
        if (! it.hasNext())
            return "[]";

        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (;;) {
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext())
                return sb.append(']').toString();
            sb.append(", ");
        }
    }

}
Revision:	1.15
Committed:	Sun Sep 5 21:32:18 2010 UTC (13 years, 8 months ago) by jsr166
Branch:	MAIN
Changes since 1.14:	+4 -4 lines
Log Message:	Update legal notices to Oracle wording
#	User	Rev	Content
1	dl	1.1	/*
2	jsr166	1.15	* Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved.
3	jsr166	1.11	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4	dl	1.1	*
5	jsr166	1.11	* 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
7			* published by the Free Software Foundation. Sun designates this
8			* particular file as subject to the "Classpath" exception as provided
9			* by Sun in the LICENSE file that accompanied this code.
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			*
21	jsr166	1.15	* 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.
24	dl	1.1	*/
25
26			package java.util;
27
28			/**
29			* This class provides a skeletal implementation of the <tt>Collection</tt>
30			* interface, to minimize the effort required to implement this interface. <p>
31			*
32			* To implement an unmodifiable collection, the programmer needs only to
33			* extend this class and provide implementations for the <tt>iterator</tt> and
34			* <tt>size</tt> methods. (The iterator returned by the <tt>iterator</tt>
35			* method must implement <tt>hasNext</tt> and <tt>next</tt>.)<p>
36			*
37			* To implement a modifiable collection, the programmer must additionally
38			* override this class's <tt>add</tt> method (which otherwise throws an
39			* <tt>UnsupportedOperationException</tt>), and the iterator returned by the
40			* <tt>iterator</tt> method must additionally implement its <tt>remove</tt>
41			* method.<p>
42			*
43			* The programmer should generally provide a void (no argument) and
44			* <tt>Collection</tt> constructor, as per the recommendation in the
45			* <tt>Collection</tt> interface specification.<p>
46			*
47	jsr166	1.9	* The documentation for each non-abstract method in this class describes its
48	dl	1.1	* implementation in detail. Each of these methods may be overridden if
49			* the collection being implemented admits a more efficient implementation.<p>
50			*
51			* This class is a member of the
52	jsr166	1.8	* <a href="{@docRoot}/../technotes/guides/collections/index.html">
53	dl	1.1	* Java Collections Framework</a>.
54			*
55			* @author Josh Bloch
56			* @author Neal Gafter
57			* @see Collection
58			* @since 1.2
59			*/
60
61			public abstract class AbstractCollection<E> implements Collection<E> {
62			/**
63			* Sole constructor. (For invocation by subclass constructors, typically
64			* implicit.)
65			*/
66			protected AbstractCollection() {
67			}
68
69			// Query Operations
70
71			/**
72			* Returns an iterator over the elements contained in this collection.
73			*
74			* @return an iterator over the elements contained in this collection
75			*/
76			public abstract Iterator<E> iterator();
77
78			public abstract int size();
79
80			/**
81			* {@inheritDoc}
82			*
83			* <p>This implementation returns <tt>size() == 0</tt>.
84			*/
85			public boolean isEmpty() {
86	jsr166	1.12	return size() == 0;
87	dl	1.1	}
88
89			/**
90			* {@inheritDoc}
91			*
92			* <p>This implementation iterates over the elements in the collection,
93			* checking each element in turn for equality with the specified element.
94			*
95			* @throws ClassCastException {@inheritDoc}
96			* @throws NullPointerException {@inheritDoc}
97			*/
98			public boolean contains(Object o) {
99	jsr166	1.14	Iterator<E> it = iterator();
100	jsr166	1.12	if (o==null) {
101	jsr166	1.14	while (it.hasNext())
102			if (it.next()==null)
103	jsr166	1.12	return true;
104			} else {
105	jsr166	1.14	while (it.hasNext())
106			if (o.equals(it.next()))
107	jsr166	1.12	return true;
108			}
109			return false;
110	dl	1.1	}
111
112			/**
113			* {@inheritDoc}
114			*
115	jsr166	1.9	* <p>This implementation returns an array containing all the elements
116			* returned by this collection's iterator, in the same order, stored in
117			* consecutive elements of the array, starting with index {@code 0}.
118			* The length of the returned array is equal to the number of elements
119			* returned by the iterator, even if the size of this collection changes
120			* during iteration, as might happen if the collection permits
121			* concurrent modification during iteration. The {@code size} method is
122			* called only as an optimization hint; the correct result is returned
123			* even if the iterator returns a different number of elements.
124			*
125			* <p>This method is equivalent to:
126			*
127			* <pre> {@code
128			* List<E> list = new ArrayList<E>(size());
129			* for (E e : this)
130			* list.add(e);
131			* return list.toArray();
132			* }</pre>
133	dl	1.1	*/
134			public Object[] toArray() {
135			// Estimate size of array; be prepared to see more or fewer elements
136	jsr166	1.12	Object[] r = new Object[size()];
137	jsr166	1.3	Iterator<E> it = iterator();
138	jsr166	1.12	for (int i = 0; i < r.length; i++) {
139			if (! it.hasNext()) // fewer elements than expected
140			return Arrays.copyOf(r, i);
141			r[i] = it.next();
142			}
143			return it.hasNext() ? finishToArray(r, it) : r;
144	dl	1.1	}
145
146			/**
147			* {@inheritDoc}
148			*
149	jsr166	1.9	* <p>This implementation returns an array containing all the elements
150			* returned by this collection's iterator in the same order, stored in
151			* consecutive elements of the array, starting with index {@code 0}.
152			* If the number of elements returned by the iterator is too large to
153			* fit into the specified array, then the elements are returned in a
154			* newly allocated array with length equal to the number of elements
155			* returned by the iterator, even if the size of this collection
156			* changes during iteration, as might happen if the collection permits
157			* concurrent modification during iteration. The {@code size} method is
158			* called only as an optimization hint; the correct result is returned
159			* even if the iterator returns a different number of elements.
160			*
161			* <p>This method is equivalent to:
162			*
163			* <pre> {@code
164			* List<E> list = new ArrayList<E>(size());
165			* for (E e : this)
166			* list.add(e);
167			* return list.toArray(a);
168			* }</pre>
169	dl	1.1	*
170			* @throws ArrayStoreException {@inheritDoc}
171			* @throws NullPointerException {@inheritDoc}
172			*/
173			public <T> T[] toArray(T[] a) {
174			// Estimate size of array; be prepared to see more or fewer elements
175			int size = size();
176	jsr166	1.3	T[] r = a.length >= size ? a :
177	dl	1.1	(T[])java.lang.reflect.Array
178			.newInstance(a.getClass().getComponentType(), size);
179	jsr166	1.3	Iterator<E> it = iterator();
180	jsr166	1.9
181	jsr166	1.12	for (int i = 0; i < r.length; i++) {
182			if (! it.hasNext()) { // fewer elements than expected
183			if (a != r)
184			return Arrays.copyOf(r, i);
185			r[i] = null; // null-terminate
186			return r;
187			}
188			r[i] = (T)it.next();
189			}
190			return it.hasNext() ? finishToArray(r, it) : r;
191	dl	1.1	}
192
193			/**
194	jsr166	1.9	* Reallocates the array being used within toArray when the iterator
195			* returned more elements than expected, and finishes filling it from
196			* the iterator.
197			*
198			* @param r the array, replete with previously stored elements
199			* @param it the in-progress iterator over this collection
200	jsr166	1.3	* @return array containing the elements in the given array, plus any
201			* further elements returned by the iterator, trimmed to size
202	dl	1.1	*/
203	jsr166	1.9	private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
204	jsr166	1.12	int i = r.length;
205	jsr166	1.2	while (it.hasNext()) {
206	dl	1.1	int cap = r.length;
207	jsr166	1.9	if (i == cap) {
208	dl	1.4	int newCap = ((cap / 2) + 1) * 3;
209			if (newCap <= cap) { // integer overflow
210	jsr166	1.12	if (cap == Integer.MAX_VALUE)
211			throw new OutOfMemoryError
212			("Required array size too large");
213			newCap = Integer.MAX_VALUE;
214			}
215			r = Arrays.copyOf(r, newCap);
216			}
217			r[i++] = (T)it.next();
218	jsr166	1.7	}
219	dl	1.1	// trim if overallocated
220	jsr166	1.9	return (i == r.length) ? r : Arrays.copyOf(r, i);
221	dl	1.1	}
222
223			// Modification Operations
224
225			/**
226			* {@inheritDoc}
227			*
228			* <p>This implementation always throws an
229			* <tt>UnsupportedOperationException</tt>.
230			*
231			* @throws UnsupportedOperationException {@inheritDoc}
232			* @throws ClassCastException {@inheritDoc}
233			* @throws NullPointerException {@inheritDoc}
234			* @throws IllegalArgumentException {@inheritDoc}
235			* @throws IllegalStateException {@inheritDoc}
236			*/
237			public boolean add(E e) {
238	jsr166	1.12	throw new UnsupportedOperationException();
239	dl	1.1	}
240
241			/**
242			* {@inheritDoc}
243			*
244			* <p>This implementation iterates over the collection looking for the
245			* specified element. If it finds the element, it removes the element
246			* from the collection using the iterator's remove method.
247			*
248			* <p>Note that this implementation throws an
249			* <tt>UnsupportedOperationException</tt> if the iterator returned by this
250			* collection's iterator method does not implement the <tt>remove</tt>
251			* method and this collection contains the specified object.
252			*
253			* @throws UnsupportedOperationException {@inheritDoc}
254			* @throws ClassCastException {@inheritDoc}
255			* @throws NullPointerException {@inheritDoc}
256			*/
257			public boolean remove(Object o) {
258	jsr166	1.14	Iterator<E> it = iterator();
259	jsr166	1.12	if (o==null) {
260	jsr166	1.14	while (it.hasNext()) {
261			if (it.next()==null) {
262			it.remove();
263	jsr166	1.12	return true;
264			}
265			}
266			} else {
267	jsr166	1.14	while (it.hasNext()) {
268			if (o.equals(it.next())) {
269			it.remove();
270	jsr166	1.12	return true;
271			}
272			}
273			}
274			return false;
275	dl	1.1	}
276
277
278			// Bulk Operations
279
280			/**
281			* {@inheritDoc}
282			*
283			* <p>This implementation iterates over the specified collection,
284			* checking each element returned by the iterator in turn to see
285			* if it's contained in this collection. If all elements are so
286			* contained <tt>true</tt> is returned, otherwise <tt>false</tt>.
287			*
288			* @throws ClassCastException {@inheritDoc}
289			* @throws NullPointerException {@inheritDoc}
290			* @see #contains(Object)
291			*/
292			public boolean containsAll(Collection<?> c) {
293	jsr166	1.14	Iterator<?> it = c.iterator();
294			while (it.hasNext())
295			if (!contains(it.next()))
296	jsr166	1.12	return false;
297			return true;
298	dl	1.1	}
299
300			/**
301			* {@inheritDoc}
302			*
303			* <p>This implementation iterates over the specified collection, and adds
304			* each object returned by the iterator to this collection, in turn.
305			*
306			* <p>Note that this implementation will throw an
307			* <tt>UnsupportedOperationException</tt> unless <tt>add</tt> is
308			* overridden (assuming the specified collection is non-empty).
309			*
310			* @throws UnsupportedOperationException {@inheritDoc}
311			* @throws ClassCastException {@inheritDoc}
312			* @throws NullPointerException {@inheritDoc}
313			* @throws IllegalArgumentException {@inheritDoc}
314			* @throws IllegalStateException {@inheritDoc}
315			*
316			* @see #add(Object)
317			*/
318			public boolean addAll(Collection<? extends E> c) {
319	jsr166	1.12	boolean modified = false;
320	jsr166	1.14	Iterator<? extends E> it = c.iterator();
321			while (it.hasNext()) {
322			if (add(it.next()))
323	jsr166	1.12	modified = true;
324			}
325			return modified;
326	dl	1.1	}
327
328			/**
329			* {@inheritDoc}
330			*
331			* <p>This implementation iterates over this collection, checking each
332			* element returned by the iterator in turn to see if it's contained
333			* in the specified collection. If it's so contained, it's removed from
334			* this collection with the iterator's <tt>remove</tt> method.
335			*
336			* <p>Note that this implementation will throw an
337			* <tt>UnsupportedOperationException</tt> if the iterator returned by the
338			* <tt>iterator</tt> method does not implement the <tt>remove</tt> method
339			* and this collection contains one or more elements in common with the
340			* specified collection.
341			*
342			* @throws UnsupportedOperationException {@inheritDoc}
343			* @throws ClassCastException {@inheritDoc}
344			* @throws NullPointerException {@inheritDoc}
345			*
346			* @see #remove(Object)
347			* @see #contains(Object)
348			*/
349			public boolean removeAll(Collection<?> c) {
350	jsr166	1.12	boolean modified = false;
351	jsr166	1.14	Iterator<?> it = iterator();
352			while (it.hasNext()) {
353			if (c.contains(it.next())) {
354			it.remove();
355	jsr166	1.12	modified = true;
356			}
357			}
358			return modified;
359	dl	1.1	}
360
361			/**
362			* {@inheritDoc}
363			*
364			* <p>This implementation iterates over this collection, checking each
365			* element returned by the iterator in turn to see if it's contained
366			* in the specified collection. If it's not so contained, it's removed
367			* from this collection with the iterator's <tt>remove</tt> method.
368			*
369			* <p>Note that this implementation will throw an
370			* <tt>UnsupportedOperationException</tt> if the iterator returned by the
371			* <tt>iterator</tt> method does not implement the <tt>remove</tt> method
372			* and this collection contains one or more elements not present in the
373			* specified collection.
374			*
375			* @throws UnsupportedOperationException {@inheritDoc}
376			* @throws ClassCastException {@inheritDoc}
377			* @throws NullPointerException {@inheritDoc}
378			*
379			* @see #remove(Object)
380			* @see #contains(Object)
381			*/
382			public boolean retainAll(Collection<?> c) {
383	jsr166	1.12	boolean modified = false;
384	jsr166	1.14	Iterator<E> it = iterator();
385			while (it.hasNext()) {
386			if (!c.contains(it.next())) {
387			it.remove();
388	jsr166	1.12	modified = true;
389			}
390			}
391			return modified;
392	dl	1.1	}
393
394			/**
395			* {@inheritDoc}
396			*
397			* <p>This implementation iterates over this collection, removing each
398			* element using the <tt>Iterator.remove</tt> operation. Most
399			* implementations will probably choose to override this method for
400			* efficiency.
401			*
402			* <p>Note that this implementation will throw an
403			* <tt>UnsupportedOperationException</tt> if the iterator returned by this
404			* collection's <tt>iterator</tt> method does not implement the
405			* <tt>remove</tt> method and this collection is non-empty.
406			*
407			* @throws UnsupportedOperationException {@inheritDoc}
408			*/
409			public void clear() {
410	jsr166	1.14	Iterator<E> it = iterator();
411			while (it.hasNext()) {
412			it.next();
413			it.remove();
414	jsr166	1.12	}
415	dl	1.1	}
416
417
418			// String conversion
419
420			/**
421			* Returns a string representation of this collection. The string
422			* representation consists of a list of the collection's elements in the
423			* order they are returned by its iterator, enclosed in square brackets
424			* (<tt>"[]"</tt>). Adjacent elements are separated by the characters
425			* <tt>", "</tt> (comma and space). Elements are converted to strings as
426			* by {@link String#valueOf(Object)}.
427			*
428			* @return a string representation of this collection
429			*/
430			public String toString() {
431	jsr166	1.14	Iterator<E> it = iterator();
432			if (! it.hasNext())
433	jsr166	1.12	return "[]";
434	dl	1.1
435	jsr166	1.12	StringBuilder sb = new StringBuilder();
436			sb.append('[');
437			for (;;) {
438	jsr166	1.14	E e = it.next();
439	jsr166	1.12	sb.append(e == this ? "(this Collection)" : e);
440	jsr166	1.14	if (! it.hasNext())
441	jsr166	1.12	return sb.append(']').toString();
442			sb.append(", ");
443			}
444	dl	1.1	}
445
446			}