线性表-顺序表动态扩容

public class App {


    public static void main( String[] args ){
        //扩容
        SequenceList<String> list =  new SequenceList<>(3);
        System.out.println(list.capacity());
        list.insert("aaa");
        list.insert("bbb");
        list.insert("ccc");
        list.insert("ddd");
        list.remove(3);
        System.out.println(list.capacity());

        System.out.println("--------------------------------------");

        //缩容
        SequenceList<String> list2 =  new SequenceList<>(20);
        System.out.println(list2.capacity());
        list2.insert("aaa");
        list2.insert("bbb");

        list.remove(0);
        System.out.println(list.capacity());
    }

    //顺序表
   static class SequenceList<T> implements  Iterable<T>{
        //存放元素的数组,为了方便测试，定义为public
        T[] elements;
        //下一个待插入元素的索引，同时也表示元素个数
        int size;

        public SequenceList(int capacity){
            elements = (T[]) new Object[capacity];
            size = 0;
        }

        public void insert(T t){
            if (size==elements.length){
                reSize(elements.length*2);
            }
            elements[size++] = t;
        }

        //往指定索引位置插入元素
        public void insert(int index,T t){
            if (size==elements.length){
                reSize(elements.length*2);
            }

            //把index索引处及后面所有元素往后移一个位置
            for (int i = size; i>index;i--){
                elements[i] = elements[i-1];
            }
            elements[index] = t;
            size++;
        }

        public void reSize(int newSize){
            T[] temp = elements;
            elements = (T[]) new Object[newSize];
            for (int i=0;i<size;i++){
                elements[i] = temp[i];
            }
        }

        //为了方便测试，增加容量查询方法
        public int capacity(){
            return elements.length;
        }

        public T get(int index){
            return elements[index];
        }


        public T remove(int index){
            if (size<elements.length/4){
                reSize(elements.length/2);
            }

           T current = elements[index];
            //把指定索引处及后面的元素往前移一个位置
            for (int i = index;i<size-1;i++){
                elements[i] = elements[i+1];
            }
            size--;
            return current;
        }

        //清空所有元素
        public void clear(){
            size =0;
        }

        public int size(){
            return size;
        }

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


        @Override
        public String toString() {
            return Arrays.toString(Arrays.copyOf(elements,size));
        }

        @Override
        public Iterator<T> iterator() {
            return new SIterator();
        }

        private class SIterator implements Iterator{

            private int cursor = 0;

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

            @Override
            public Object next() {
                return elements[cursor++];
            }
        }

    }

}