容器SuperClass——Group

容器就是用來存放數據的

數組就是一個容器：用來存放有限個數據的集合

Group類

定點添加        void add(int index, T el)
首添加          void addFirst(T el)
尾添加          void addLast(T el)

定位刪除        T remove(int index)
刪除首          T removeFirst()
刪除尾          T removeLast()
刪除某元素      int removeEl(T el)
刪除所有某元素  boolean removeEls(T el)
清空 clear      void clear()

修改 set        T set(int index, T el)

根據索引取元素  T get(int index)
根據元素取索引  int[] getIndex(T el)

是否包含元素    boolean contains(T el)
尾連接兩集合    Group<T> contact(Group<T> group)
定點連接集合    Group<T> contact(int index,Group<T> group)
是否爲空        boolean isEmpty() 
獲取大小        int size()

Group<T>

public abstract class Group<T> {
    protected int size;

    /**
     * 定點添加
     *
     * @param index 索引
     * @param el    數據元素
     */
    public abstract void add(int index, T el);

    /**
     * 首添加
     *
     * @param el 數據元素
     */
    public void addFirst(T el) {
        add(0, el);
    }

    /**
     * 尾添加
     *
     * @param el 數據元素
     */
    public void addLast(T el) {
        add(size - 1, el);
    }

    /**
     * 定位刪除
     *
     * @param index 索引
     * @return 刪除的元素
     */
    public abstract T remove(int index);

    /**
     * 刪除首位
     *
     * @return 刪除的元素
     */
    public T removeFirst() {
        return remove(0);
    }

    /**
     * 刪除尾位
     *
     * @return 刪除的元素
     */
    public T removeLast() {
        return remove(size - 1);
    }

    /**
     * 刪除指定元素的第一次出現時
     *
     * @param el 數據元素
     * @return 元素位置
     */
    public int removeEl(T el) {
        int[] indexes = getIndex(el);
        int index = -1;
        if (indexes.length > 0) {
            index = indexes[0];
            remove(indexes[0]);
        }
        return index;
    }

    /**
     * 刪除所有指定元素
     *
     * @param el 數據元素
     */
    public boolean removeEls(T el) {

        int[] indexArray = getIndex(el);
        if (indexArray.length != 0) {
            for (int i = 0; i < indexArray.length; i++) {
                remove(indexArray[i] - i); // 注意-i
            }
            return true;
        }
        return false;
    }

    /**
     * 清空集合
     */
    public abstract void clear();

    /**
     * 設置某位置的元素新值
     *
     * @param index 索引
     * @param el    新值
     * @return 舊值
     */
    public abstract T set(int index, T el);

    /**
     * 根據指定位置獲取元素
     *
     * @param index 索引
     * @return 數據元素
     */
    public abstract T get(int index);

    /**
     * 根據指定元素獲取匹配索引
     *
     * @param el 數據元素
     * @return 索引集
     */
    public abstract int[] getIndex(T el);

    /**
     * 集合是否包含某元素
     *
     * @param el 數據元素
     * @return 是否包含
     */
    public boolean contains(T el) {
        return getIndex(el).length != 0;
    }

    /**
     * 連接兩個集合
     *
     * @param group 插入集合
     * @return 合併後的集合
     */
    public Group<T> contact(Group<T> group) {
        return contact(size-1, group);
    }

    /**
     * 定點連接兩個集合
     *
     * @param index 索引
     * @param group 插入集合
     * @return 合併後的集合
     */
    public abstract Group<T> contact(int index, Group<T> group);

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

    /**
     * 返回集合大小
     *
     * @return 大小
     */
    public int size() {
        return size;
    }
}