自定义集合接口

接口的定义

     接口其实简单来讲就是定义一些公共方法的集合，是一种高级的封装
但是说到接口又不得不提到父类，这两者还是有一定的差别：
  1、接口是单继承
  2、多实现
  3、父子关系
     a、复用，方法名和参数返回值可以复用
     b、接口与实现类是一种扩展的关系：如果要扩展一个已有类的功 
     能，我们通常不会选择修改该类的源码，而是新建一个类，去继
     承该类，并实现扩展接口。

自定义的集合接口（具体可以参考ArrayList类）

/**
 * 集合接口
 *
 * 定义未来该接口下的实现类中公共行为
 * 结构根据需要自行定义
 * @param <T> 泛型
 */
public interface List<T> {
    /**
     * 获取集合中元素的实际数量
     * @return int
     */
    int size();

    /**
     * 集合是否为空
     * 集合中实际元素的数量是否为0
     * @return
     */
    boolean isEmpty();

    /**
     * 将集合元素以数组形式返回
     * @return Object数组
     */
    Object[] roArray();

    /**
     * 返回参数元素在集合中第一次的实际位置
     * @param t
     * @return -1 ：不存在；否则返回>=0的有效位置
     */
    int indexOf(T t);

    /**
     * 返回参数元素在集合中最后一次的实际位置
     * @param t
     * @return -1 ：不存在；否则返回>=0的有效位置
     */
    int lastIndexOf(T t);


    /**
     * 集合中是否包含参数元素
     * @param t
     * @return  true：包含   false：不包含
     */
    boolean contains(T t);

    /**
     * 向集合中新增一个元素
     * @param t
     */
    void add(T t);

    /**
     * 将参数数组中的元素新增到集合中
     * @param arr
     */
    void add(T[] arr );

    /**
     * 将参数集合添加到当前集合中
     * @param list
     */
    void add(List<T> list);

    /**
     * 删除指定位置的集合元素
     * @param index
     * @return null:表示位置越界，否则返回该位置的元素
     */
    T remove(int index);

    /**
     * 从集合中删除参数元素
     * @param t
     * @return true：删除成功  false：表示删除失败（元素不存在）
     */
    boolean remove(T t);
}

迭代器接口

/**
 * 迭代器的行为定义
 * @param <T>
 */
public interface Iterator<T> {

    boolean hasNext();
    T next();
}


/**
 * 需要实现迭代功能的集合
 * @param <T>
 */
public interface Iterable<T> {
    Iterator<T> iterator();

}

实现类

public class ArrayList<T> implements List<T>,Iterable<T> {
    /**
     * 默认初始容量
     */
    private static final  int DEFAULT_CAPACITY = 10;
    /**
     * 默认源数据的扩容率
     */
    private static final float DEFAULT_EXPAND_RATE=1.5F;
    /**
     * 核心的源数据
     */
    private Object[] elementDate;
    /**
     * 常量空数组
     */
    private final Object[] EMPTY_DATA = {};
    /**
     * 数组拷贝的临时记录点
     */
    private Object[] copy = EMPTY_DATA;
    /**
     * 新元素的起始位置，当前数组中元素的数量
     */
    private int size;

    public ArrayList(){
            this(DEFAULT_CAPACITY);
    }

    public ArrayList(int initCapacity){
        if(initCapacity==0){
            elementDate = EMPTY_DATA;
        }else if(initCapacity>0){
            elementDate = new Object[initCapacity];
        }else{
            System.err.println("初始化容量错误:initCapacity"+initCapacity);
        }
    }

    private void ensureCapacity(int needCapacity){
        int expandCapacity = needExpand(needCapacity);
        if(expandCapacity <0){
            return;
        }
        final int newCapacity = (int)Math.ceil((elementDate.length+expandCapacity)*DEFAULT_EXPAND_RATE);
        copy = elementDate;
        elementDate = new Object[newCapacity];
        System.arraycopy(copy,0,elementDate,0,size);
        copy = EMPTY_DATA;
    }

    private int needExpand(int needCapacity){
        return needCapacity - (elementDate.length-size);
    }

    @Override
    public int size() {
        return size;
    }

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

    @Override
    public Object[] roArray() {
        return Arrays.copyOf(elementDate,size);
    }

    @Override
    public int indexOf(T t) {
        for (int i = 0; i <size ; i++) {
            if(elementDate[i].equals(t)){
                return i;
            }
        }
        return -1;
    }

    @Override
    public int lastIndexOf(T t) {
        for (int i = size-1; i >0; i--) {
            if(elementDate[i].equals(t)){
                return i;
            }
        }
        return -1;
    }

    @Override
    public boolean contains(T t) {
        return -1 != indexOf(t);
    }

    @Override
    public void add(T t) {
        ensureCapacity(1);
        elementDate[size++]= t;
    }

    @Override
    public void add(T[] arr) {
        ensureCapacity(arr.length);
        System.arraycopy(arr,0,elementDate,size,arr.length);
        size += arr.length;
    }

    @Override
    public void add(List<T> list) {
        add((T[])list.roArray());
    }

    @Override
    public T remove(int index) {
        if(index<0 || index>=size){
            return null;
        }
        T t = (T)elementDate[index];
        for (int i = index; i <size-1 ; i++) {
            elementDate[i] = elementDate[i+1];
        }
        elementDate[--size] = null;
        return t;
    }

    @Override
    public boolean remove(T t) {
        int index = indexOf(t);
        if(-1==index){
            return false;
        }
        remove(index);
        return true;
    }

    @Override
    public Iterator<T> iterator(){
        return  new Iterator<T>() {
            private int index = -1;


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

            @Override
            public T next() {
                return (T)elementDate[index];
            }
        };
    }
}

你学会了吗？喜欢就点个赞吧！