自己实现ArrayList类（大部分

<span style="font-family: Arial, Helvetica, sans-serif;">import java.util.ArrayList;</span>

import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
/**
 * 
 * 项目名称：Hwk  
 * 类全名:Hwk0718.MyArrayList    
 * 类描述：    
 * 创建人：Admin
 * 创建时间：2015年7月19日 下午12:55:36    
 * 修改备注：    
 * @version  jdk1.7 
 * 
 * Copyright (c) 2015, xxxx@163.com All Rights Reserved.
 */
public class MyArrayList<E> {

    private static final int DEFAULT_CAPACITY = 10;

    private Object[] elementData = new Object[DEFAULT_CAPACITY];

    private int size;

    public MyArrayList()
    {
        super();
        clear();
    }

    /**
     * 
     * checkIndex:检测传入下标是否越界. <br/> 
     * TODO(这里描述这个方法适用条件 – 可选).<br/> 
     * @author Administrator 
     * @param index
     * @throws RuntimeException 
     * @since JDK 1.7
     */
    public void checkIndex(int index) throws RuntimeException
    {
        if (index >= size || index < 0)
        {
            throw new RuntimeException("下标越界");
        }
    }

    /**
     * 
     * ensureCapacity:用于创建合适大小的数组(扩容). <br/> 
     * TODO(这里描述这个方法适用条件 – 可选).<br/> 
     * @author Administrator 
     * @param defaultCapacity 
     * @since JDK 1.7
     */
    private void ensureCapacity(int defaultCapacity)
    {
        if (size > defaultCapacity)
        {
            return;
        }
        Object[] obj = elementData;
        elementData = new Object[defaultCapacity];
        System.arraycopy(obj, 0, elementData, 0, size);
    }

    public int size()
    {
        return size;
    }

    public boolean isEmpty()
    {
        return size() == 0;
    }

    // 检测是否包含该元素
    public boolean contains(Object o)
    {
        return indexOf(o) >= 0;
    }

    // 转换成数组
    public Object[] toArray()
    {
        Object[] obj = new Object[size];
        System.arraycopy(elementData, 0, obj, 0, size);
        return obj;
    }

    // 转换成数组
    public <T> T[] toArray(T[] a)
    {
        if (a.length < size)
        {
            System.arraycopy(elementData, 0, a, 0, a.length);
        } else if (a.length >= size)
        {
            System.arraycopy(elementData, 0, a, 0, size);
            for (int i = size; i < a.length; i++)
            {
                a[i] = null;
            }
        }
        return a;
    }

    // 添加元素
    public boolean add(E e)
    {
        add(size, e);
        return true;
    }

    // 移除元素
    public boolean remove(Object o)
    {

        boolean b = false;
        if (o == null)
        {
            for (int i = 0; i < elementData.length; i++)
            {
                if (elementData[i] == null)
                {
                    remove(i);
                    b = true;
                }
            }
        }
        for (int i = 0; i < elementData.length; i++)
        {
            if (elementData[i].equals(o))
            {
                remove(i);
                b = true;
            }
        }
        return b;
    }

    public void clear()
    {
        size = 0;
        ensureCapacity(DEFAULT_CAPACITY);
    }

    // 获得对应下标元素
    public E get(int index)
    {
        checkIndex(index);
        return (E) elementData[index];
    }

    // 插入index位置元素，并返回当前位置元素
    public E set(int index, E element)
    {
        checkIndex(index);
        E oldObj = (E) elementData[index];
        elementData[index] = element;
        return oldObj;
    }

    // 添加对应下标元素
    public void add(int index, E element)
    {
        if (elementData.length == size())
        {
            ensureCapacity(size() * 2 + 1);
        }
        // 数组后移System.arraycopy(elementData
        // ,index,elementData,index+1,size-index);
        for (int i = size(); i > index; i--)
        {
            elementData[i] = elementData[i - 1];
        }
        elementData[index] = element;
        size++;
    }

    // 移除对应下标元素
    public E remove(int index)
    {
        checkIndex(index);
        E removeE = (E) elementData[index];
        if (size - index - 1 > 0)
        {
            System.arraycopy(elementData, index + 1, elementData, index, size - index - 1);
        }
        size--;
        elementData[size] = null;

        return removeE;
    }

    // 获得该对象的下标
    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;
    }

    // 获得迭代器
    public Iterator<E> iterator()
    {
        return new Itr();
    }

    // 实现Iterator接口
    private class Itr implements Iterator<E> {
        private int cursor = 0;

        @Override
        public boolean hasNext()
        {
            if (cursor < size())
            {
                return true;
            }
            return false;
        }

        @Override
        public E next()
        {
            if (cursor >= size)
                throw new NoSuchElementException();

            return (E) elementData[cursor++];
        }

        @Override
        public void remove()
        {

            MyArrayList.this.remove(--cursor);

        }

    }

}

参考文章：http://blog.csdn.net/duanyugen/article/details/10441945#java

同时参考了ArrayList源码，写出下面MyArrayList类，以锻炼自己的Java基础。

个人水平有限，在迭代器方面没有按照源码做过多的考虑，可能会出现多种状况，请大家指点。