ArrayList底层实现(JAVA)

因为高级语言封装的特性，让程序员很少去关注一些数据结构的底层实现,但是想往高级方向发展,修炼内功是尤为重要的,下面鉴于个人学习分享下集合的底层实现.

public class MyArrayList<E> {


// 默认容量
private static final int DEFAULT_CAPACITY = 10;
// 默认空元素
private static final Object[] EMPTY_ELEMENT = {};
// 自定义容量要用到的数组
private transient Object[] elementData;
// 数组容量的大小
private int size;
// 修改次数
private int modCount;


public MyArrayList() {
this.elementData = EMPTY_ELEMENT;
}


// 自定义容量
public MyArrayList(int initialCapacity) {
// 如果容量设置小于0则抛出异常
if (initialCapacity < 0) {
try {
throw new Exception("容量有误");
} catch (Exception e) {
e.printStackTrace();
}
}
this.elementData = new Object[initialCapacity];
}


// 增功能
public boolean add(E e) {
// 扩容算法
ensureCapacityInternal(size + 1);
// 向数组中添加元素
elementData[size++] = e;
return true;
}


// 扩容算法
public void ensureCapacityInternal(int minCapacity) {
// 如果是用默认构造器的方式操作数组
if (elementData == EMPTY_ELEMENT) {
minCapacity = Math.min(DEFAULT_CAPACITY, minCapacity);
}
// 扩容
ensureExplicitCapacity(minCapacity);
}


public void ensureExplicitCapacity(int minCapacity) {
                //记录修改次数,迭代器模式用的到这个变量
modCount++;
// 扩容
if (minCapacity - elementData.length > 0) {
grow(minCapacity);
}
}


// 如何扩容的
public void grow(int minCapacity) {


// 当前数组的容量
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
// ?
if (newCapacity < minCapacity) {
newCapacity = minCapacity;
}
elementData = Arrays.copyOf(elementData, newCapacity);
}


// 移除元素
public E remove(int index) {
// 检查索引是否越界
rangCheck(index);
modCount++;
// 获取要移除元素
E oldValue = (E) elementData[index];


int numMoved = size - index - 1;
if (numMoved > 0) {
System.arraycopy(elementData, index + 1, elementData, index,
numMoved);
}
elementData[--size] = null;
return oldValue;
}


// 修改某元素
public E set(int index, E element) {
rangCheck(index);
E oldVlaue = (E) elementData[index];
elementData[index] = element;
return oldVlaue;
}


//查询元素的位置
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;

}

// 检查索引是否越界
private void rangCheck(int index) {
if (index >= size) {
try {
throw new Exception("索引越界");
} catch (Exception e) {
e.printStackTrace();
}
}
}


}

以上是模仿jdk中ArrayList写的简易集合,个人心得,其实集合底层实现也就是操作object类型的数组,其核心算法就是扩容算法,每次扩当前容量+容量的一半,然后用数组工具类去实现,如果跟到最底层会发现其实数组的移位还是调用了c++ public static native void arraycopy(Object src,  int  srcPos,int length);

本地方法去实现的,因为数组移位涉及到内存的操作，本地语言来操纵,性能应该会更好,因为只想介绍数据结构本身,所以jdk集合内部其实用到了迭代器模式，非常精妙，这里我就没去实现.jdk1.6以后的foreach就是基于迭代器来遍历输出集合存放的元素的,