ViewVC Help

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

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

Comparing jsr166/src/main/java/util/ArrayList.java (file contents):
Revision 1.11 by jsr166, Mon Nov 28 03:59:23 2005 UTC vs.
Revision 1.19 by dl, Wed Apr 19 15:07:14 2006 UTC

#	Line 1 | Line 1
1		/*
2	<	* %W% %E%
2	>	* @(#)ArrayList.java   1.56 06/03/14
3		*
4	<	* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
4	>	* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
5		* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
6		*/
7
8		package java.util;
9	–	import java.util.*; // for javadoc (till 6280605 is fixed)
9
10		/**
11		* Resizable-array implementation of the <tt>List</tt> interface.  Implements
#	Line 72 | Line 71 | import java.util.*; // for javadoc (till
71		*
72		* @author  Josh Bloch
73		* @author  Neal Gafter
74	<	* @version %I%, %G%
74	>	* @version 1.56, 03/14/06
75		* @see     Collection
76		* @see     List
77		* @see     LinkedList
#	Line 123 | Line 122 | public class ArrayList<E> extends Abstra
122		/**
123		* Constructs a list containing the elements of the specified
124		* collection, in the order they are returned by the collection's
125	<	* iterator.  The <tt>ArrayList</tt> instance has an initial capacity of
127	<	* 110% the size of the specified collection.
125	>	* iterator.
126		*
127		* @param c the collection whose elements are to be placed into this list
128		* @throws NullPointerException if the specified collection is null
129		*/
130		public ArrayList(Collection<? extends E> c) {
131	<	int size = c.size();
132	<	// 10% for growth
133	<	int cap = ((size/10)+1)*11;
134	<	if (cap > 0) {
135	<	Object[] a = new Object[cap];
138	<	a[size] = a[size+1] = UNALLOCATED;
139	<	Object[] b = c.toArray(a);
140	<	if (b[size] == null && b[size+1] == UNALLOCATED) {
141	<	b[size+1] = null;
142	<	elementData = b;
143	<	this.size = size;
144	<	return;
145	<	}
146	<	}
147	<	initFromConcurrentlyMutating(c);
131	>	elementData = c.toArray();
132	>	size = elementData.length;
133	>	// c.toArray might (incorrectly) not return Object[] (see 6260652)
134	>	if (elementData.getClass() != Object[].class)
135	>	elementData = Arrays.copyOf(elementData, size, Object[].class);
136		}
137
138		private void initFromConcurrentlyMutating(Collection<? extends E> c) {
#	Line 189 | Line 177 | public class ArrayList<E> extends Abstra
177		* @param minCapacity the desired minimum capacity
178		*/
179		private void growArray(int minCapacity) {
180	<	if (minCapacity < 0)
181	<	throw new OutOfMemoryError(); // int overflow
180	>	if (minCapacity < 0) // overflow
181	>	throw new OutOfMemoryError();
182		int oldCapacity = elementData.length;
183		// Double size if small; else grow by 50%
184	<	int newCapacity = ((oldCapacity < 64)?
185	<	((oldCapacity + 1) * 2):
186	<	((oldCapacity * 3) / 2));
184	>	int newCapacity = ((oldCapacity < 64) ?
185	>	((oldCapacity + 1) * 2) :
186	>	((oldCapacity / 2) * 3));
187	>	if (newCapacity < 0) // overflow
188	>	newCapacity = Integer.MAX_VALUE;
189		if (newCapacity < minCapacity)
190		newCapacity = minCapacity;
191		elementData = Arrays.copyOf(elementData, newCapacity);
#	Line 345 | Line 335 | public class ArrayList<E> extends Abstra
335		// Positional Access Operations
336
337		/**
338	<	* Returns error message string for IndexOutOfBoundsExceptions
338	>	* Throws an appropriate exception for indexing errors.
339		*/
340	<	private String ioobe(int index) {
341	<	return "Index: " + index + ", Size: " + size;
340	>	private static void indexOutOfBounds(int i, int s) {
341	>	throw new IndexOutOfBoundsException("Index: " + i + ", Size: " + s);
342		}
343
344		/**
#	Line 360 | Line 350 | public class ArrayList<E> extends Abstra
350		*/
351		public E get(int index) {
352		if (index >= size)
353	<	throw new IndexOutOfBoundsException(ioobe(index));
354	<	return (E)elementData[index];
353	>	indexOutOfBounds(index, size);
354	>	return (E) elementData[index];
355		}
356
357		/**
#	Line 375 | Line 365 | public class ArrayList<E> extends Abstra
365		*/
366		public E set(int index, E element) {
367		if (index >= size)
368	<	throw new IndexOutOfBoundsException(ioobe(index));
379	<
368	>	indexOutOfBounds(index, size);
369		E oldValue = (E) elementData[index];
370		elementData[index] = element;
371		return oldValue;
#	Line 394 | Line 383 | public class ArrayList<E> extends Abstra
383		if (s >= elementData.length)
384		growArray(s + 1);
385		elementData[s] = e;
386	<	size = s + 1;
387	<	return true;
386	>	size = s + 1;
387	>	return true;
388		}
389
390		/**
#	Line 410 | Line 399 | public class ArrayList<E> extends Abstra
399		public void add(int index, E element) {
400		int s = size;
401		if (index > s || index < 0)
402	<	throw new IndexOutOfBoundsException(ioobe(index));
402	>	indexOutOfBounds(index, s);
403		modCount++;
404		if (s >= elementData.length)
405		growArray(s + 1);
406		System.arraycopy(elementData, index,
407	<	elementData, index + 1, s - index);
407	>	elementData, index + 1, s - index);
408		elementData[index] = element;
409		size = s + 1;
410		}
#	Line 432 | Line 421 | public class ArrayList<E> extends Abstra
421		public E remove(int index) {
422		int s = size - 1;
423		if (index > s)
424	<	throw new IndexOutOfBoundsException(ioobe(index));
424	>	indexOutOfBounds(index, size);
425		modCount++;
426	<	E oldValue = (E)elementData[index];
426	>	E oldValue = (E) elementData[index];
427		int numMoved = s - index;
428		if (numMoved > 0)
429		System.arraycopy(elementData, index + 1,
430	<	elementData, index, numMoved);
430	>	elementData, index, numMoved);
431		elementData[s] = null;
432	<	size = s;
432	>	size = s;
433		return oldValue;
434		}
435
#	Line 540 | Line 529 | public class ArrayList<E> extends Abstra
529		*/
530		public boolean addAll(int index, Collection<? extends E> c) {
531		if (index > size || index < 0)
532	<	throw new IndexOutOfBoundsException(ioobe(index));
532	>	indexOutOfBounds(index, size);
533
534		Object[] a = c.toArray();
535		int numNew = a.length;
#	Line 602 | Line 591 | public class ArrayList<E> extends Abstra
591		for (int i=0; i<size; i++)
592		s.writeObject(elementData[i]);
593
594	<	if (modCount != expectedModCount) {
594	>	if (expectedModCount != modCount) {
595		throw new ConcurrentModificationException();
596		}
597
#	Line 625 | Line 614 | public class ArrayList<E> extends Abstra
614		for (int i=0; i<size; i++)
615		a[i] = s.readObject();
616		}
628	–
629	–
630	–	/**
631	–	* Returns a list-iterator of the elements in this list (in proper
632	–	* sequence), starting at the specified position in the list.
633	–	* Obeys the general contract of <tt>List.listIterator(int)</tt>.<p>
634	–	*
635	–	* The list-iterator is <i>fail-fast</i>: if the list is structurally
636	–	* modified at any time after the Iterator is created, in any way except
637	–	* through the list-iterator's own <tt>remove</tt> or <tt>add</tt>
638	–	* methods, the list-iterator will throw a
639	–	* <tt>ConcurrentModificationException</tt>.  Thus, in the face of
640	–	* concurrent modification, the iterator fails quickly and cleanly, rather
641	–	* than risking arbitrary, non-deterministic behavior at an undetermined
642	–	* time in the future.
643	–	*
644	–	* @param index index of the first element to be returned from the
645	–	*              list-iterator (by a call to <tt>next</tt>)
646	–	* @return a ListIterator of the elements in this list (in proper
647	–	*         sequence), starting at the specified position in the list
648	–	* @throws IndexOutOfBoundsException {@inheritDoc}
649	–	* @see List#listIterator(int)
650	–	*/
651	–	public ListIterator<E> listIterator(int index) {
652	–	if (index < 0 || index > size)
653	–	throw new IndexOutOfBoundsException(ioobe(index));
654	–	return new ArrayListIterator(index);
655	–	}
656	–
657	–	/**
658	–	* {@inheritDoc}
659	–	*/
660	–	public ListIterator<E> listIterator() {
661	–	return new ArrayListIterator(0);
662	–	}
663	–
664	–	/**
665	–	* Returns an iterator over the elements in this list in proper sequence.
666	–	*
667	–	* @return an iterator over the elements in this list in proper sequence
668	–	*/
669	–	public Iterator<E> iterator() {
670	–	return new ArrayListIterator(0);
671	–	}
672	–
673	–	/**
674	–	* A streamlined version of AbstractList.ListItr
675	–	*/
676	–	final class ArrayListIterator implements ListIterator<E> {
677	–	int cursor;           // index of next element to return;
678	–	int lastRet;          // index of last element, or -1 if no such
679	–	int expectedModCount; // to check for CME
680	–
681	–	ArrayListIterator(int index) {
682	–	cursor = index;
683	–	lastRet = -1;
684	–	expectedModCount = modCount;
685	–	}
686	–
687	–	public boolean hasNext() {
688	–	return cursor < size;
689	–	}
690	–
691	–	public boolean hasPrevious() {
692	–	return cursor > 0;
693	–	}
694	–
695	–	public int nextIndex() {
696	–	return cursor;
697	–	}
698	–
699	–	public int previousIndex() {
700	–	return cursor - 1;
701	–	}
702	–
703	–	public E next() {
704	–	try {
705	–	int i = cursor;
706	–	E next = get(i);
707	–	lastRet = i;
708	–	cursor = i + 1;
709	–	return next;
710	–	} catch (IndexOutOfBoundsException ex) {
711	–	throw new NoSuchElementException();
712	–	} finally {
713	–	if (expectedModCount != modCount)
714	–	throw new ConcurrentModificationException();
715	–	}
716	–	}
717	–
718	–	public E previous() {
719	–	try {
720	–	int i = cursor - 1;
721	–	E prev = get(i);
722	–	lastRet = i;
723	–	cursor = i;
724	–	return prev;
725	–	} catch (IndexOutOfBoundsException ex) {
726	–	throw new NoSuchElementException();
727	–	} finally {
728	–	if (modCount != expectedModCount)
729	–	throw new ConcurrentModificationException();
730	–	}
731	–	}
732	–
733	–	public void remove() {
734	–	if (lastRet < 0)
735	–	throw new IllegalStateException();
736	–	if (modCount != expectedModCount)
737	–	throw new ConcurrentModificationException();
738	–	ArrayList.this.remove(lastRet);
739	–	if (lastRet < cursor)
740	–	cursor--;
741	–	lastRet = -1;
742	–	expectedModCount = modCount;
743	–	}
744	–
745	–	public void set(E e) {
746	–	if (lastRet < 0)
747	–	throw new IllegalStateException();
748	–	if (modCount != expectedModCount)
749	–	throw new ConcurrentModificationException();
750	–	ArrayList.this.set(lastRet, e);
751	–	expectedModCount = modCount;
752	–	}
753	–
754	–	public void add(E e) {
755	–	if (modCount != expectedModCount)
756	–	throw new ConcurrentModificationException();
757	–	ArrayList.this.add(cursor++, e);
758	–	lastRet = -1;
759	–	expectedModCount = modCount;
760	–	}
761	–	}
617		}

Diff Legend

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