public ArrayList(int initialCapacity)
{
if (initialCapacity > 0)
{
this.elementData = new Object[initialCapacity];
}
else if (initialCapacity == 0)
{
//注意初始容量为0时给的对象,EMPTY_ELEMENTDATA
this.elementData = EMPTY_ELEMENTDATA;
}
else
{
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
public ArrayList()
{
//默认构造函数
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
public ArrayList(Collection<? extends E> c)
{
//转入的集合转换为数组
elementData = c.toArray();
//改变自己的size
if ((size = elementData.length) != 0)
{
//这里有个坑,可能不能正确的返回Object[] Class对象,不能的话复制
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else
{
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
//截断,在原数组上移动
public void trimToSize()
{
modCount++;
if (size < elementData.length)
{
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
//比较关心的几个方法,存放,取出,查找
//查找,运行时间上界O(n),从这里也可用看出是允许放null
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;
}
//反向查找
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;
}
//返回index位置的元素
E elementData(int index)
{
return (E) elementData[index];
}
//获取对应位置元素,O(1)
public E get(int index)
{
//检查size,并没有判断小于0
rangeCheck(index);
return elementData(index);
}
//将元素放在对应位置,index<size，list当成数组使用,注意,这样的代码会报错
//List<String> list = new ArrayList<>(100);
// list.set(10, "123");
//根据构造函数可以知道,已经开辟了100长度的数组,但是就是不让你用
public E set(int index, E element)
{
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
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
elementData = Arrays.copyOf(elementData, newCapacity);
}
private void ensureExplicitCapacity(int minCapacity)
{
modCount++;
// overflow-conscious code
//1-0,进入if,进行内存复制,开辟新的数组
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void ensureCapacityInternal(int minCapacity)
{
//构造函数给0,这里是false
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
{
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
//ensureExplicitCapacity(1);
ensureExplicitCapacity(minCapacity);
}
//增加一个元素
public boolean add(E e)
{
//为什么构造函数给0会被打死,看下面这个函数,一来就要新数组,新的数组长度也只有1
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
//元素放到index位置,0<=index<size
public void add(int index, E element)
{
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
//移除
public E remove(int index)
{
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
//内存复制
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
//O(n)的移除,注意在fastRemove方法里面也会出现内存复制
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;
}
//为什么elementData不用置null,方便重用
public void clear()
{
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
//浅克隆
public Object clone()
{
try {
ArrayList<?> v = (ArrayList<?>) 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(e);
}
}
//返回副本
public Object[] toArray()
{
return Arrays.copyOf(elementData, size);
}
结尾附上一个内存分布的代码,有指针真好
int main(int argc, char* argv[])
{
//int ba[4];
int a[] = { 1, 2, 3, 4 };
int c = 5;
int d = 6;
int dd = 7;
cout << a << endl;
cout << a[-1] << endl;
cout << a-1 << endl;
cout<<&dd<<endl;
cout << &d << endl;
cout << &c << endl;
//memcpy(ba, a, sizeof(int) * 4);
//cout << ba[0] << endl;
//cout << ba[1] << endl;
return 0;
}