ArrayList的实现

ArrayList泛型类的实现。
内部类实现方式源码：

package main.java.arraydemo;

import java.util.Iterator;

/**
 * DateTime: 2016/11/4 09:42
 * 功能：实现ArrayList泛型类的实现：
 *       MyArrayList将保持基础数组，数组的容量，以及存储在MyArrayList中的当前项数；
 *       MyArrayList将提供一个机制以改变数组的容量，通过获得一个新的suzuki，将老数组拷贝到新数组中改变数组的容量，允许虚拟机回收老数组；
 *       MyArrayList将提供get和set的实现；
 *       MyArrayList将提供基本的方法，如size isEmpty clear remove add ；
 *       MyArrayList将提供一个实现Iterator接口的类，这个类将存储迭代序列中的下一项的下标，并提供next hasNext remove等方法的实现;
 */
public class MyArrayList<T> implements Iterable<T> {

    //默认数组容量大小
    private static final int DEFAULT_CAPACITY=10;

    //当前容量大小
    private int size;

    //数组
    private T[] items;

    //默认构造函数
    public MyArrayList(){
        init();
    }

    //初始化
    private void init(){
        size=0;
        ensureCapacity(DEFAULT_CAPACITY);
    }

    //清除
    public void clear(){
        init();
    }

    //返回size
    public int size(){
        return this.size;
    }

    //是否为空
    public boolean isEmpty(){
        return 0==size();
    }

    //收缩数组大小
    public void trimToSize(){
        ensureCapacity(size());
    }

    //获取指定下标的元素
    public T get(int index){
        if(0>index || size()< index){
            throw  new ArrayIndexOutOfBoundsException("数组下标越界");
        }
        return items[index];
    }

    //设置指定下标的元素,并返回旧的元素
    public T set(int index, T value){
        if(0>index || size()< index){
            throw  new ArrayIndexOutOfBoundsException("数组下标越界");
        }
        T oldValue=items[index];
        items[index]=value;
        return oldValue;
    }

    //自动扩容或收缩数组
    public void ensureCapacity(int newCapacity){
        if(newCapacity < this.size){
            return;
        }
        T[] oldArr=this.items;
        items= (T[]) new Object[newCapacity];
        for ( int i = 0; i < size(); i++ ) {
            items[i]=oldArr[i];
        }
    }

    //新增元素
    public boolean add(T value){
        try {
            add(size(),value);
            return true;
        }catch ( Exception e ){
            e.printStackTrace();
        }
         return false;
    }

    //新增元素
    private void add(int index,T value){
        if(items.length==size()){
            ensureCapacity(size()*2+1);
        }
        for ( int i = size; i > index; i-- ) {
            items[i]=items[i-1];
        }
        items[index]=value;
        size++;
    }

    //删除元素
    public T remove(int index){
        T oldValue=items[index];
        for ( int i = index; i < size()-1; i++ ) {
            items[i]=items[i+1];
        }
        size--;
        return oldValue;
    }

    //迭代器方法的实现
    @Override
    public Iterator<T> iterator() {
        return new ArrayListIterator();
    }

    //迭代器类
    private class ArrayListIterator implements Iterator<T>{

        //当前下标
        private int current=0;

        @Override
        public boolean hasNext() {
            return current<size();
        }

        @Override
        public T next() {
            if(!hasNext())
                throw new java.util.NoSuchElementException();
            return items[current++];
        }

        @Override
        public void remove() {
            MyArrayList.this.remove(--current);
        }
    }

}

测试：

package test.java;

import main.java.arraydemo.MyArrayList;

import java.util.Iterator;

/**
 * DateTime: 2016/11/4 10:24
 * 功能：
 * 思路：
 */


public class MyArrayListTest {
    public static void main(String[] args) {
        MyArrayList arrayList=new MyArrayList();
        System.out.println("//增加测试");
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        arrayList.add(4);

        System.out.println("//迭代器测试");
        Iterator iterator=arrayList.iterator();
        while ( iterator.hasNext()  ){
            System.out.println(iterator.next());
        }

        System.out.println(" //设置测试");
        arrayList.set(2,200);
        System.out.println("//获取测试");
        System.out.println(arrayList.get(2));
        System.out.println(" //删除测试");
        arrayList.remove(1);
        Iterator iterator1=arrayList.iterator();
        while ( iterator1.hasNext()  ){
            System.out.println(iterator1.next());
        }

    }

}

结果：