数组

ArrayList.class

package com.czz;

/**
 * 动态数组的设计
 *动态数组可能会造成内存空间的大量浪费
 * @param <E>
 */
public class ArrayList<E> {
	
	    //元素的数量
        private int size;
        private E[] elements;
        //默认数组个数
        private static final int DEFALULT_CAPACITY=4;

        
        public ArrayList(int capacity){
            capacity= (capacity<DEFALULT_CAPACITY) ? DEFALULT_CAPACITY: capacity;
            elements =(E[])new Object[capacity];
        }
        public ArrayList(){
            // elements=new int[DEFALULT_CAPACITY];
            this(DEFALULT_CAPACITY);
        }
        //获取元素数量
        public int size() {
            return size;
        }

        //是否为空
        public boolean isEmpty() {
            for (int i = 0; i <size ; i++) {
               elements[i] =null;
               return true;
            }
            return false;
        }

        //是否包含某个元素
        public boolean contains(E element) {
        	//元素存在则不返回-1
            return indexOf(element)!=-1;
        }

        //添加元素到最后面
        //最好：O（1）
        //最坏：扩容情况下：O（n）
        //平均：(1+1+1+....+n)/n,O(1);最后一次扩容后才会为n,其余时候都只加在后面
        //均摊复杂度也为O(1)
        /**
         * 均摊复杂度使用场合：经过连续低的复杂度，出现个别高的复杂度，
         * 一般最好和均摊相等
         */
        public void add(E element) {
            add(size,element);
        }

        //返回index位置对应的元素
        public E get(int index) {
            if(index<0||index>=size){
                throw new IndexOutOfBoundsException("索引异常");
            }
            return elements[index];//O(1),因为与size数据规模无关，所以最好、最坏、平均情况复杂度都为O(1)
        }

        //设置index位置的元素
        public E set(int index, E element) {//O(1)
            if(index<0||index>=size){
                throw new IndexOutOfBoundsException("索引异常");
            }
            else {
                elements[index] = element;
            }
            return elements[index];
        }

        //在index位置添加元素
        public void add(int index, E element) {

            if(index<0||index>size){
                throw new IndexOutOfBoundsException("index"+index+"  "+"size"+size);
            }
            //扩容
            ensureCapacity(size+1);
            for (int i = size-1; i >=index ; i--) {
                elements[i+1]=elements[i];
            }
            elements[index]=element;
            size++;
        }/**
        size是数据规模，O(size),因为add方法复杂度跟index有关
                    当index为size时不存在移动元素，所以是最好复杂度为O(1)
                    当index为0时要将数组整体往后挪，所以size有多大复杂度就有多大，为O(n)
                    当index为每个数的概率相同，则传入的(1+2+3+....+n)/n;所以平均复杂度还是为O(n)
       */
        
          

        //删除index位置的元素
        
        public E remove(int index) {
            E old=elements[index];
            //缩容
            trim();
            for (int i = index+1; i <=size-1 ; i++) {
                elements[i-1]=elements[i];
            }
            size--;
            //最后一个元素处理为null
            elements[size]=null;
            return old;
        }

        //查看元素位置
        public int indexOf(E element) {
        	//如果element为null
            if(element==null){
                for (int i = 0; i <size() ; i++) {
                    if( elements[i]==null)
                        return i;
                }
            }else {//如果element不为null
                for (int i = 0; i <size() ; i++) {
                    if( element.equals(elements[i]))
                        return i;
                }
            }
            return -1;
        }

       /**
        * 在不是泛型数据时，不需要将元素置为null,应为控制住size别人访问不到之前残留的数据，
        * 而垃圾处理会自动清空
        */
        public void clear() {
            for (int i = 0; i <size ; i++) {
                elements[i]=null;
            }
            
            size=0;
        }

        @Override
        public String toString() {

            //size=3, [11,22,33]
            StringBuilder sb =new StringBuilder();
            sb.append("size=").append(size).append(", ");
            sb.append("[");
            for (int i = 0; i <size ; i++) {
                if(i!=0){
                    sb.append(", ");
                }
                sb.append(elements[i]);
            }
            sb.append("]");
            return sb.toString();
        }
        //扩容
        private void ensureCapacity(int capacity){
            int oldelements=elements.length;
            if(oldelements>capacity) return;
            int newcapacity=oldelements+(oldelements>>1);
            E[] newelements=(E[]) new Object[newcapacity];
            for (int i = 0; i <size ; i++) {
                newelements[i]=elements[i];
            }
            elements=newelements;
            System.out.println(oldelements+"扩容为"+newcapacity);
        }
        //缩容
        public void trim() {
        	int capacity=elements.length;
        	if(size>=capacity>>1||size<DEFALULT_CAPACITY) {
        		return;
        	}else {
        		int newcapacity=capacity>>1;
                E[] newelements=(E[]) new Object[newcapacity];
                for (int i = 0; i <size ; i++) {
                    newelements[i]=elements[i];
                }
                elements=newelements;
                System.out.println(capacity+"缩容为"+newcapacity);
        	}
        	
        }
    }

Test.class

package com.czz;

public class Test {

	public static void main(String[] args) {
		
	ArrayList<Integer> list=new ArrayList<>();
	
	for (int i = 0; i <20; i++) {
	list.add(i);
	}
	for (int i = 0; i <20; i++) {
		list.remove(0);
	}
	}
}