ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/main/java/util/AbstractCollection.java

Comparing jsr166/src/main/java/util/AbstractCollection.java (file contents):
Revision 1.11 by jsr166, Sun May 20 07:54:01 2007 UTC vs.
Revision 1.14 by jsr166, Tue Aug 24 06:00:44 2010 UTC

#	Line 54 | Line 54 | package java.util;
54		*
55		* @author  Josh Bloch
56		* @author  Neal Gafter
57	–	* @version %I%, %G%
57		* @see Collection
58		* @since 1.2
59		*/
#	Line 84 | Line 83 | public abstract class AbstractCollection
83		* <p>This implementation returns <tt>size() == 0</tt>.
84		*/
85		public boolean isEmpty() {
86	<	return size() == 0;
86	>	return size() == 0;
87		}
88
89		/**
#	Line 97 | Line 96 | public abstract class AbstractCollection
96		* @throws NullPointerException {@inheritDoc}
97		*/
98		public boolean contains(Object o) {
99	<	Iterator<E> e = iterator();
100	<	if (o==null) {
101	<	while (e.hasNext())
102	<	if (e.next()==null)
103	<	return true;
104	<	} else {
105	<	while (e.hasNext())
106	<	if (o.equals(e.next()))
107	<	return true;
108	<	}
109	<	return false;
99	>	Iterator<E> it = iterator();
100	>	if (o==null) {
101	>	while (it.hasNext())
102	>	if (it.next()==null)
103	>	return true;
104	>	} else {
105	>	while (it.hasNext())
106	>	if (o.equals(it.next()))
107	>	return true;
108	>	}
109	>	return false;
110		}
111
112		/**
#	Line 134 | Line 133 | public abstract class AbstractCollection
133		*/
134		public Object[] toArray() {
135		// Estimate size of array; be prepared to see more or fewer elements
136	<	Object[] r = new Object[size()];
136	>	Object[] r = new Object[size()];
137		Iterator<E> it = iterator();
138	<	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;
138	>	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		}
145
146		/**
#	Line 179 | Line 178 | public abstract class AbstractCollection
178		.newInstance(a.getClass().getComponentType(), size);
179		Iterator<E> it = iterator();
180
181	<	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;
181	>	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		}
192
193		/**
#	Line 202 | Line 201 | public abstract class AbstractCollection
201		*         further elements returned by the iterator, trimmed to size
202		*/
203		private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
204	<	int i = r.length;
204	>	int i = r.length;
205		while (it.hasNext()) {
206		int cap = r.length;
207		if (i == cap) {
208		int newCap = ((cap / 2) + 1) * 3;
209		if (newCap <= cap) { // integer overflow
210	<	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();
210	>	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		}
219		// trim if overallocated
220		return (i == r.length) ? r : Arrays.copyOf(r, i);
#	Line 236 | Line 235 | public abstract class AbstractCollection
235		* @throws IllegalStateException         {@inheritDoc}
236		*/
237		public boolean add(E e) {
238	<	throw new UnsupportedOperationException();
238	>	throw new UnsupportedOperationException();
239		}
240
241		/**
#	Line 256 | Line 255 | public abstract class AbstractCollection
255		* @throws NullPointerException          {@inheritDoc}
256		*/
257		public boolean remove(Object o) {
258	<	Iterator<E> e = iterator();
259	<	if (o==null) {
260	<	while (e.hasNext()) {
261	<	if (e.next()==null) {
262	<	e.remove();
263	<	return true;
264	<	}
265	<	}
266	<	} else {
267	<	while (e.hasNext()) {
268	<	if (o.equals(e.next())) {
269	<	e.remove();
270	<	return true;
271	<	}
272	<	}
273	<	}
274	<	return false;
258	>	Iterator<E> it = iterator();
259	>	if (o==null) {
260	>	while (it.hasNext()) {
261	>	if (it.next()==null) {
262	>	it.remove();
263	>	return true;
264	>	}
265	>	}
266	>	} else {
267	>	while (it.hasNext()) {
268	>	if (o.equals(it.next())) {
269	>	it.remove();
270	>	return true;
271	>	}
272	>	}
273	>	}
274	>	return false;
275		}
276
277
#	Line 291 | Line 290 | public abstract class AbstractCollection
290		* @see #contains(Object)
291		*/
292		public boolean containsAll(Collection<?> c) {
293	<	Iterator<?> e = c.iterator();
294	<	while (e.hasNext())
295	<	if (!contains(e.next()))
296	<	return false;
297	<	return true;
293	>	Iterator<?> it = c.iterator();
294	>	while (it.hasNext())
295	>	if (!contains(it.next()))
296	>	return false;
297	>	return true;
298		}
299
300		/**
#	Line 317 | Line 316 | public abstract class AbstractCollection
316		* @see #add(Object)
317		*/
318		public boolean addAll(Collection<? extends E> c) {
319	<	boolean modified = false;
320	<	Iterator<? extends E> e = c.iterator();
321	<	while (e.hasNext()) {
322	<	if (add(e.next()))
323	<	modified = true;
324	<	}
325	<	return modified;
319	>	boolean modified = false;
320	>	Iterator<? extends E> it = c.iterator();
321	>	while (it.hasNext()) {
322	>	if (add(it.next()))
323	>	modified = true;
324	>	}
325	>	return modified;
326		}
327
328		/**
#	Line 348 | Line 347 | public abstract class AbstractCollection
347		* @see #contains(Object)
348		*/
349		public boolean removeAll(Collection<?> c) {
350	<	boolean modified = false;
351	<	Iterator<?> e = iterator();
352	<	while (e.hasNext()) {
353	<	if (c.contains(e.next())) {
354	<	e.remove();
355	<	modified = true;
356	<	}
357	<	}
358	<	return modified;
350	>	boolean modified = false;
351	>	Iterator<?> it = iterator();
352	>	while (it.hasNext()) {
353	>	if (c.contains(it.next())) {
354	>	it.remove();
355	>	modified = true;
356	>	}
357	>	}
358	>	return modified;
359		}
360
361		/**
#	Line 381 | Line 380 | public abstract class AbstractCollection
380		* @see #contains(Object)
381		*/
382		public boolean retainAll(Collection<?> c) {
383	<	boolean modified = false;
384	<	Iterator<E> e = iterator();
385	<	while (e.hasNext()) {
386	<	if (!c.contains(e.next())) {
387	<	e.remove();
388	<	modified = true;
389	<	}
390	<	}
391	<	return modified;
383	>	boolean modified = false;
384	>	Iterator<E> it = iterator();
385	>	while (it.hasNext()) {
386	>	if (!c.contains(it.next())) {
387	>	it.remove();
388	>	modified = true;
389	>	}
390	>	}
391	>	return modified;
392		}
393
394		/**
#	Line 408 | Line 407 | public abstract class AbstractCollection
407		* @throws UnsupportedOperationException {@inheritDoc}
408		*/
409		public void clear() {
410	<	Iterator<E> e = iterator();
411	<	while (e.hasNext()) {
412	<	e.next();
413	<	e.remove();
414	<	}
410	>	Iterator<E> it = iterator();
411	>	while (it.hasNext()) {
412	>	it.next();
413	>	it.remove();
414	>	}
415		}
416
417
#	Line 429 | Line 428 | public abstract class AbstractCollection
428		* @return a string representation of this collection
429		*/
430		public String toString() {
431	<	Iterator<E> i = iterator();
432	<	if (! i.hasNext())
433	<	return "[]";
434	<
435	<	StringBuilder sb = new StringBuilder();
436	<	sb.append('[');
437	<	for (;;) {
438	<	E e = i.next();
439	<	sb.append(e == this ? "(this Collection)" : e);
440	<	if (! i.hasNext())
441	<	return sb.append(']').toString();
442	<	sb.append(", ");
443	<	}
431	>	Iterator<E> it = iterator();
432	>	if (! it.hasNext())
433	>	return "[]";
434	>
435	>	StringBuilder sb = new StringBuilder();
436	>	sb.append('[');
437	>	for (;;) {
438	>	E e = it.next();
439	>	sb.append(e == this ? "(this Collection)" : e);
440	>	if (! it.hasNext())
441	>	return sb.append(']').toString();
442	>	sb.append(", ");
443	>	}
444		}
445
446		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines