ArrayList类注释翻译、源码分析

HashMap源码分析 ：http://blog.csdn.net/disiwei1012/article/details/73530598

HashSet类注释翻译、fast-fail、源码分析 ：http://blog.csdn.net/disiwei1012/article/details/73692452

Hashtable类注释翻译、源码分析 ：http://blog.csdn.net/disiwei1012/article/details/73744181

一、类注释翻译

/**
* Resizable -array implementation of the <tt> List</tt> interface.  Implements
* all optional list operations, and permits all elements, including
* <tt>null </tt> .  In addition to implementing the <tt> List</tt> interface,
* this class provides methods to manipulate the size of the array that is
* used internally to store the list.  (This class is roughly equivalent to
* <tt>Vector </tt> , except that it is unsynchronized.)

用“可伸缩数组”来实现List接口。实现了所有List接口中的方法，并且允许存放所有元素，包括Null。

除了实现了List接口，本类还是提供操作数组大小的方法。（本类和Vector类似，只是本类是非同步的）

* <p>The <tt> size</tt> , <tt>isEmpty </tt> , <tt> get </tt>, <tt> set</tt> ,
* <tt>iterator </tt> , and <tt> listIterator </tt> operations run in constant
* time.  The <tt> add</tt> operation runs in <i>amortized constant time</i> ,
* that is, adding n elements requires O(n) time.  All of the other operations
* run in linear time (roughly speaking).  The constant factor is low compared
* to that for the <tt> LinkedList</tt> implementation.

size、isEmpty、get、set、iterator、listIterator 这些操作用的时间是常量，(也就是说这些操作与元素的个数无关，操作的时间为o(1)）。

add操作花费恒定分摊时间，也就是说插入n的元素的时间为o（n），其实分摊之后，也就相当于插入一个元素的时间为o（1）。

粗略的来说本类的其他操作都能在线性的时间内完成。（也就是说这些操作与元素的个成线性关系，操作的时间复杂度o（n））

What is meant by “Constant Amortized Time” when talking about time complexity of an algorithm?

https://stackoverflow.com/questions/200384/constant-amortized-time

* <p>Each <tt> ArrayList</tt> instance has a <i> capacity</i> .  The capacity is
* the size of the array used to store the elements in the list.  It is always
* at least as large as the list size.  As elements are added to an ArrayList,
* its capacity grows automatically.  The details of the growth policy are not
* specified beyond the fact that adding an element has constant amortized
* time cost.

每个ArrayList实例都有一个容量。这个容量也就是用来存储元素的数组的大小，它至少等于list大小（list大小就是数组实际存放元素的个数）。

当一个元素被添加到集合中，这个集合的容量会自动增长。除了要求添加一个元素的效率为“恒定分摊时间”，对于具体实现的细节没有特别的要求。

* <p>An application can increase the capacity of an <tt> ArrayList</tt> instance
* before adding a large number of elements using the <tt> ensureCapacity</tt>
* operation.  This may reduce the amount of incremental reallocation.

在大批量插入元素前，使用ensureCapacity操作来增加集合的容量。这或许能够减少扩容之后新数组的大小。

【This may reduce the amount of incremental reallocation. 】这句的翻译感觉有点怪怪的。

* <p><strong>Note that this implementation is not synchronized.</strong>
* If multiple threads access an <tt> ArrayList</tt> instance concurrently,
* and at least one of the threads modifies the list structurally, it
* <i>must </i> be synchronized externally.  (A structural modification is
* any operation that adds or deletes one or more elements, or explicitly
* resizes the backing array; merely setting the value of an element is not
* a structural modification.)  This is typically accomplished by
* synchronizing on some object that naturally encapsulates the list.

此类是非同步的。如果多个线程同时操作ArrayList实例，至少一个线程结构性的修改，必须要保证线程的同步。

（结构性修改：增加或删除元素，或者调整数组大小，仅仅修改属性的值不属于结构性修改）

典型的实现是同步操作数组。

* If no such object exists, the list should be "wrapped" using the
* {@link Collections#synchronizedList Collections.synchronizedList}
* method.  This is best done at creation time, to prevent accidental
* unsynchronized access to the list: <pre>
*   List list = Collections.synchronizedList(new ArrayList(...));</pre>

如果这种对象不存在，又想同步集合，可以这样写：

Collections.synchronizedList(new ArrayList(...))

* <p><a name="fail-fast"/>
* The iterators returned by this class's {@link #iterator() iterator} and
* {@link #listIterator(int) listIterator} methods are <em> fail- fast </em>:
* if the list is structurally modified at any time after the iterator is
* created, in any way except through the iterator's own
* {@link ListIterator#remove() remove} or
* {@link ListIterator#add(Object) add} methods, the iterator will throw a
* {@link ConcurrentModificationException}.  Thus, in the face of
* concurrent modification, the iterator fails quickly and cleanly, rather
* than risking arbitrary, non - deterministic behavior at an undetermined
* time in the future.

* <p>Note that the fail - fast behavior of an iterator cannot be guaranteed
* as it is, generally speaking, impossible to make any hard guarantees in the
* presence of unsynchronized concurrent modification.  Fail- fast iterators
* throw {@code ConcurrentModificationException} on a best- effort basis.
* Therefore, it would be wrong to write a program that depended on this
* exception for its correctness:  <i> the fail- fast behavior of iterators
* should be used only to detect bugs. </i>

关于fail-fast特性的介绍，请参考：http://www.cnblogs.com/skywang12345/p/3308762.html

二、源码分析

public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
private static final long serialVersionUID = 8683452581122892189L;

/**
* 实际用来存储元素的地方，ArrayList的底层数据结构
* 该数组的大小即为ArrayList的容量
*/
private transient Object[] elementData ;

/**
* ArrayList存储元素个数
*
*/
private int size ;

/**
* 带初始容量initialCapacity的构造函数
*/
public ArrayList( int initialCapacity ) {
super ();
if (initialCapacity < 0)//如果初始容量小于0，抛出异常
throw new IllegalArgumentException( "Illegal Capacity: "+
initialCapacity );
创建底层数据，大小为initialCapacity
this.elementData = new Object[ initialCapacity];
}

/**
* 无参构造器，默认容量为10
*/
public ArrayList() {
this (10);
}

/**
* 创建一个参数为集合对象c的构造函数，将c中的元素添加到ArrayList中
* 通过迭代器返回的顺序和和c中的一样
* @throws 如果c为null,则抛出空指针异常
*/
public ArrayList(Collection<? extends E> c ) {
elementData = c .toArray();
size = elementData .length ;
// c.toArray might (incorrectly) not return Object[] (see 6260652)
//toArray有可能不返回Object[]，具体参考：http://bugs.java.com/bugdatabase/view_bug.do?bug_id=6260652
//如果toArray方法返回的不是Object[]，则将elementData转化成Object[]，
//为ArrayList要能存放任何元素
if (elementData .getClass() != Object[]. class)
elementData = Arrays.copyOf( elementData , size , Object[]. class);
}

/**
* 缩短ArrayList容量大小和存储元素的个数相等
*/
public void trimToSize() {
//修改次数+1
modCount++;
int oldCapacity = elementData .length ;
if (size < oldCapacity ) {//如果当前数组大小>实际存储的元素个数，则缩小数组的大小
elementData = Arrays.copyOf( elementData , size );
}
}

/**
* 为了确保数组大小大于minCapacity，也就是数组大小大于需要存储的元素个数，增加数组的大小
* @param    minCapacity   the desired minimum capacity
*/
public void ensureCapacity( int minCapacity ) {
if (minCapacity > 0)
//对数组进行扩容
ensureCapacityInternal( minCapacity );
}

//数组扩容函数
private void ensureCapacityInternal( int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData .length > 0)
grow( minCapacity );
}

/**
* 数组最大容量限制
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**
* 增加数组容量函数
* @param minCapacity 渴望数组大小
*/
private void grow(int minCapacity ) {
// overflow-conscious code
int oldCapacity = elementData .length ;
//新数组大小为原数组的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity ;
if (newCapacity - MAX_ARRAY_SIZE > 0)
//如果新数组大小大于数组最大容量限制
newCapacity = hugeCapacity( minCapacity );
// minCapacity is usually close to size, so this is a win:
//拷贝数组
elementData = Arrays.copyOf( elementData , newCapacity );
}

//如果新数组大小大于数组最大容量限制
private static int hugeCapacity( int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer. MAX_VALUE :
MAX_ARRAY_SIZE ;
}

/**
* 获取存储元素个数
*/
public int size() {
return size ;
}

/**
* 判断是否存储元素
*/
public boolean isEmpty() {
return size == 0;
}

/**
* 集合中是否包含元素o
*/
public boolean contains(Object o ) {
return indexOf(o ) >= 0;
}

/**
* 返回元素在集合中的位置（初次出现的位置）
* 如果集合中不存在该元素，则返回-1，null不能放在equals的左边
*/
public int indexOf(Object o ) {
if (o == null) {
for (int i = 0; i < size ; i ++)
if (elementData [i ]== null)
return i ;
} else {
for (int i = 0; i < size ; i ++)
if (o .equals(elementData [i ]))
return i ;
}
return -1;
}

/**
* 返回元素在集合中的位置（最后出现的位置）
* 如果集合中不存在该元素，则返回-1，null不能放在equals的左边
*/
public int lastIndexOf(Object o ) {
if (o == null) {
for (int i = size -1; i >= 0; i--)
if (elementData [i ]== null)
return i ;
} else {
for (int i = size -1; i >= 0; i--)
if (o .equals(elementData [i ]))
return i ;
}
return -1;
}

/**
* 浅拷贝一个此ArrayList,并返回
* @return a clone of this <tt> ArrayList </tt> instance
*/
public Object clone() {
try {
@SuppressWarnings ("unchecked" )
ArrayList<E> v = (ArrayList<E>) super .clone();
v. elementData = Arrays.copyOf( elementData , size );
v. modCount = 0;
return v ;
} catch (CloneNotSupportedException e ) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
}

/**
*  返回一个包含全部元素的数组
*/
public Object[] toArray() {
return Arrays.copyOf( elementData , size );
}

/**
* 返回一个指定类型包含全部元素的数组
*/
@SuppressWarnings( "unchecked" )
public <T> T[] toArray(T[] a) {
if (a .length < size )
// Make a new array of a's runtime type, but my contents:
return (T[]) Arrays.copyOf( elementData , size , a .getClass());
System. arraycopy( elementData, 0, a, 0, size);
if (a .length > size )
a[ size] = null ;
return a ;
}

//返回数组指定位置上的元素
E elementData( int index) {
return (E) elementData [index ];
}

/**
* 返回数组指定位置上的元素
*/
public E get( int index ) {
rangeCheck( index);

return elementData(index );
}

/**
* 替换数组指定位置上的元素
*/
public E set( int index , E element ) {
rangeCheck( index);

E oldValue = elementData( index);
elementData [index ] = element ;
return oldValue ;
}

/**
* 在数组的尾部追加一个元素
*/
public boolean add(E e ) {
//先判断数组是否需要扩容
ensureCapacityInternal( size + 1);  // Increments modCount!!
elementData [size ++] = e ;
return true ;
}

/**
* Inserts the specified element at the specified position in this
* list. Shifts the element currently at that position (if any) and
* any subsequent elements to the right (adds one to their indices).
* 在指定位置插入元素
*/
public void add(int index , E element ) {
rangeCheckForAdd( index);
//判断元素是否需要扩容
ensureCapacityInternal( size + 1);  // Increments modCount!!
//System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
//src:源数组;srcPos:源数组要复制的起始位置;dest:目的数组;destPos:目的数组放置的起始位置;length:复制的长度。
//将元素该位置的元素以及之后的数组全部往后移植一位
System. arraycopy( elementData, index, elementData , index + 1,size - index);
elementData [index ] = element ;
size++;
}

/**
* Removes the element at the specified position in this list.
* Shifts any subsequent elements to the left (subtracts one from their
* indices).
* 移除指定位置元素
*/
public E remove( int index ) {
rangeCheck( index);
//修改次数+1
modCount++;
E oldValue = elementData( index);

int numMoved = size - index - 1;
if (numMoved > 0)
System. arraycopy( elementData, index+1, elementData , index , numMoved);
//删除最后一个数组元素的指针，即释放最后一个数组元素指向的对象，让GC能够回收该对象
//关于GC root不熟悉的看下JVM
elementData [--size ] = null; // Let gc do its work
//返回被移除位置的元素
return oldValue ;
}

/**
* 移除集合中的某个元素，如果集合中不存在该元素，则什么都不做
* 返回是否移除成功
*/
public boolean remove(Object o ) {
if (o == null) {
for (int index = 0; index < size ; index ++)
if (elementData [index ] == null) {
fastRemove( index);
return true ;
}
} else {
for (int index = 0; index < size ; index ++)
if (o .equals(elementData [index ])) {
fastRemove( index);
return true ;
}
}
return false ;
}

/*
* Private remove method that skips bounds checking and does not
* return the value removed.
* remove(Object o )方法的内部使用方法，私有。
* 此方法相比remove(int index)有何特点？
* 没有进行范围判断，即rangeCheck( index)；也不返回被删除元素
*/
private void fastRemove( int index) {
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0)
System. arraycopy( elementData, index+1, elementData , index ,
numMoved);
elementData [--size ] = null; // Let gc do its work
}

/**
* 移除所有元素
*/
public void clear() {
modCount++;

// Let gc do its work
for (int i = 0; i < size ; i ++)
elementData [i ] = null;

size = 0;
}

/**
* 追加集合c中的所有元素到ArrayList集合中，存放的先后顺序保持不变。
/
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a .length ;
//判断是否需要增加数组容量
ensureCapacityInternal( size + numNew);  // Increments modCount
System. arraycopy( a, 0, elementData, size, numNew );
size += numNew;
return numNew != 0;

}

/**
* 在执行位置插入集合c中的全部元素
*/
public boolean addAll(int index , Collection<? extends E> c ) {
rangeCheckForAdd( index);

Object[] a = c.toArray();
int numNew = a .length ;
ensureCapacityInternal( size + numNew);  // Increments modCount

int numMoved = size - index ;
if (numMoved > 0)
System. arraycopy( elementData, index, elementData , index + numNew ,
numMoved);

System. arraycopy( a, 0, elementData, index, numNew );
size += numNew;
return numNew != 0;
}

/**
* 移除指定范围内的元素
*/
protected void removeRange( int fromIndex, int toIndex ) {
modCount++;
int numMoved = size - toIndex ;
System. arraycopy( elementData, toIndex, elementData , fromIndex ,
numMoved);

// Let gc do its work
int newSize = size - (toIndex -fromIndex );
while (size != newSize )
elementData [--size ] = null;
}

/**
* 检测指定位置与元素个数大小，如果指定位置大于存储元素个数，则抛出IndexOutOfBoundsException
*/
private void rangeCheck( int index) {
if (index >= size )
throw new IndexOutOfBoundsException(outOfBoundsMsg(index ));
}

/**
* add and addAll操作判断范围的特有方法
*/
private void rangeCheckForAdd( int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index ));
}

/**
* Constructs an IndexOutOfBoundsException detail message.
* Of the many possible refactorings of the error handling code,
* this "outlining" performs best with both server and client VMs.
*/
private String outOfBoundsMsg( int index ) {
return "Index: " +index +", Size: " +size ;
}

/**
* 移除与集合c有交集的元素，使用批量移除方法
*/
public boolean removeAll(Collection<?> c ) {

return batchRemove(c , false);
}

/**
* 保留与集合c有交集的元素，使用批量移除方法
*/
public boolean retainAll(Collection<?> c ) {
return batchRemove(c , true);
}

**下面详细看下批量移除方法：batchRemove。

首先需要明确一点：数组也属于引用数据类型，final Object[] elementData。对于引用类型而言，我们不能改变final修饰的引用的指向，但是我们可以修改指向的具体内容里面的值。就以数组为例：**

public static void main(String[] args) {
final String[] s = {"a" ,"b" ,"c" };
//不能修改指向
// s = new String[5]; The final local variable s cannot be assigned. It must be blank and not using a compound assignment

System.out.println(Arrays.toString(s));

//虽然不能修改指向，但是我们可以修改指向对象中的内容
s[0] = "d";
s[1] = "e";
s[2] = "f";

System.out.println(Arrays.toString(s));

}

输出结果：
[a, b, c]
[d, e, f]

batchRemove定义一个引用指向元素组，然后对原数组中的元素进行操作。

private boolean batchRemove(Collection<?> c , boolean complement ) {
final Object[] elementData = this. elementData;
int r = 0, w = 0;
boolean modified = false;
try {
for (; r < size ; r ++)
if (c .contains( elementData[ r]) == complement )
elementData [w ++] = elementData [r ];
} finally {
// Preserve behavioral compatibility with AbstractCollection,
// even if c.contains() throws.
if (r != size ) {
System. arraycopy( elementData, r,
elementData , w ,
size - r);
w += size - r;
}
if (w != size ) {
for (int i = w ; i < size ; i ++)
elementData [i ] = null;
modCount += size - w;
size = w;
modified = true ;
}
}
return modified ;
}

public ListIterator<E> listIterator( int index ) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException( "Index: "+ index);
return new ListItr( index);
}

public ListIterator<E> listIterator() {
return new ListItr(0);
}

public Iterator<E> iterator() {
return new Itr();
}

/**
* 实现Iterator接口的迭代器（内部使用）
*/
private class Itr implements Iterator<E> {
int cursor ;       // 指向当前元素的下一个元素
int lastRet = -1; // 最后一个返回的元素的位置
int expectedModCount = modCount ; //用来判断是否抛出ConcurrentModificationException

//是否还有下一个元素，如果下一个元素的位置小于存储元素数量，返回true,否则false
public boolean hasNext() {
return cursor != size ;
}

//返回下一个元素
@SuppressWarnings ("unchecked" )
public E next() {
//判断是否抛出ConcurrentModificationException（即fast-fail）
checkForComodification();
int i = cursor ;
if (i >= size )
throw new NoSuchElementException();
Object[] elementData = ArrayList.this .elementData ;
if (i >= elementData .length )
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData [lastRet = i ];
}

//移除一个元素
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
//判断是否抛出ConcurrentModificationException（即fast-fail）
checkForComodification();

try {
//移除最后一个返回的元素
ArrayList. this .remove(lastRet );
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount ;
} catch (IndexOutOfBoundsException ex ) {
throw new ConcurrentModificationException();
}
}

//fast-fail具体实现
final void checkForComodification() {
if (modCount != expectedModCount )
throw new ConcurrentModificationException();
}
}

/**
* 实现ListIterator接口的迭代器（内部使用）
*/
private class ListItr extends Itr implements ListIterator<E> {
//构造函数
ListItr( int index ) {
super ();
cursor = index;
}
//前面是否还有元素
public boolean hasPrevious() {
return cursor != 0;
}
//返回下一个元素位置
public int nextIndex() {
return cursor ;
}
//返回前一个元素位置
public int previousIndex() {
return cursor - 1;
}

//返回前一个元素
@SuppressWarnings ("unchecked" )
public E previous() {
checkForComodification();
int i = cursor - 1;
if (i < 0)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this .elementData ;
if (i >= elementData .length )
throw new ConcurrentModificationException();
cursor = i;
return (E) elementData [lastRet = i ];
}
//设置一个元素
public void set(E e ) {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();

try {
ArrayList. this .set(lastRet , e );
} catch (IndexOutOfBoundsException ex ) {
throw new ConcurrentModificationException();
}
}
//增加一个元素
public void add(E e ) {
checkForComodification();

try {
int i = cursor ;
ArrayList. this .add(i , e );
cursor = i + 1;
lastRet = -1;
expectedModCount = modCount ;
} catch (IndexOutOfBoundsException ex ) {
throw new ConcurrentModificationException();
}
}
}

public List<E> subList( int fromIndex , int toIndex) {
subListRangeCheck(fromIndex , toIndex , size );
return new SubList( this, 0, fromIndex , toIndex );
}

static void subListRangeCheck( int fromIndex, int toIndex , int size ) {
if (fromIndex < 0)
throw new IndexOutOfBoundsException("fromIndex = " + fromIndex );
if (toIndex > size )
throw new IndexOutOfBoundsException( "toIndex = " + toIndex);
if (fromIndex > toIndex )
throw new IllegalArgumentException("fromIndex(" + fromIndex +
") > toIndex(" + toIndex + ")");
}

//方法返回的List是ArrayList中某段数据的一个视图. 因此, 在操作此方法返回的List时, 同样会改变ArrayList的数据.
//对于结构性修改，通过该类修改，不会导致fast-false;但父ArrayList修改会导致该类的fast-false
private class SubList extends AbstractList<E> implements RandomAccess {
private final AbstractList<E> parent;
private final int parentOffset;
private final int offset;
int size ;

//parent 父类型
//offset 父类型的偏移量
//fromIndex 子列表的开始元素，位于父列表的位置
//toIndex 子列表的结束元素，位于父列表的位置
SubList(AbstractList<E> parent,
int offset , int fromIndex, int toIndex) {
this .parent = parent ;
this .parentOffset = fromIndex ;
this .offset = offset + fromIndex ;
this .size = toIndex - fromIndex ;
this .modCount = ArrayList. this. modCount;
}

public E set(int index , E e ) {
rangeCheck( index);
checkForComodification();
E oldValue = ArrayList.this .elementData(offset + index );
ArrayList. this .elementData [offset + index ] = e ;
return oldValue ;
}

public E get(int index ) {
rangeCheck( index);
checkForComodification();
return ArrayList. this.elementData( offset + index );
}

public int size() {
checkForComodification();
return this .size ;
}

public void add( int index, E e) {
rangeCheckForAdd( index);
checkForComodification();
parent.add( parentOffset + index , e );
this .modCount = parent .modCount ;
this .size ++;
}

public E remove( int index) {
rangeCheck( index);
checkForComodification();
E result = parent.remove( parentOffset + index );
this .modCount = parent .modCount ;
this .size --;
return result ;
}

protected void removeRange( int fromIndex, int toIndex ) {
checkForComodification();
parent.removeRange( parentOffset + fromIndex ,
parentOffset + toIndex );
this .modCount = parent .modCount ;
this .size -= toIndex - fromIndex ;
}

public boolean addAll(Collection<? extends E> c) {
return addAll(this .size , c );
}

public boolean addAll( int index, Collection<? extends E> c ) {
rangeCheckForAdd( index);
int cSize = c .size();
if (cSize ==0)
return false ;

checkForComodification();
parent.addAll( parentOffset + index , c );
this .modCount = parent .modCount ;
this .size += cSize ;
return true ;
}

public Iterator<E> iterator() {
return listIterator();
}

public ListIterator<E> listIterator( final int index ) {
checkForComodification();
rangeCheckForAdd( index);
final int offset = this. offset;

return new ListIterator<E>() {
int cursor = index ;
int lastRet = -1;
int expectedModCount = ArrayList.this .modCount ;

public boolean hasNext() {
return cursor != SubList. this. size;
}

@SuppressWarnings ("unchecked" )
public E next() {
checkForComodification();
int i = cursor ;
if (i >= SubList. this. size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this .elementData ;
if (offset + i >= elementData .length )
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData [offset + (lastRet = i )];
}

public boolean hasPrevious() {
return cursor != 0;
}

@SuppressWarnings ("unchecked" )
public E previous() {
checkForComodification();
int i = cursor - 1;
if (i < 0)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this .elementData ;
if (offset + i >= elementData .length )
throw new ConcurrentModificationException();
cursor = i;
return (E) elementData [offset + (lastRet = i )];
}

public int nextIndex() {
return cursor ;
}

public int previousIndex() {
return cursor - 1;
}

public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();

try {
SubList. this .remove(lastRet );
cursor = lastRet;
lastRet = -1;
expectedModCount = ArrayList.this .modCount ;
} catch (IndexOutOfBoundsException ex ) {
throw new ConcurrentModificationException();
}
}

public void set(E e ) {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();

try {
ArrayList. this .set(offset + lastRet , e );
} catch (IndexOutOfBoundsException ex ) {
throw new ConcurrentModificationException();
}
}

public void add(E e ) {
checkForComodification();

try {
int i = cursor ;
SubList. this .add(i , e );
cursor = i + 1;
lastRet = -1;
expectedModCount = ArrayList.this .modCount ;
} catch (IndexOutOfBoundsException ex ) {
throw new ConcurrentModificationException();
}
}

final void checkForComodification() {
if (expectedModCount != ArrayList.this .modCount )
throw new ConcurrentModificationException();
}
};
}

public List<E> subList( int fromIndex, int toIndex ) {
subListRangeCheck( fromIndex, toIndex, size);
return new SubList( this, offset, fromIndex , toIndex );
}

private void rangeCheck( int index) {
if (index < 0 || index >= this .size )
throw new IndexOutOfBoundsException(outOfBoundsMsg(index ));
}

private void rangeCheckForAdd( int index) {
if (index < 0 || index > this. size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index ));
}

private String outOfBoundsMsg( int index) {
return "Index: " +index +", Size: " + this. size;
}

private void checkForComodification() {
if (ArrayList. this. modCount != this .modCount )
throw new ConcurrentModificationException();
}
}
}