手写一个简单版的ArrayList

一、设计一个简单的ArrayList[需要包含构造函数(有参和无参),add(obj),扩容 机制,remove方法]

1.      import java.io.Serializable;
   
2. 
   
3. public class MyArrayList  implements Serializable {
   
4.    //第一次扩容的容量
   
5.    public static final  int  DEFAULT_CAPACITY=10;
   
6.    //用于初始化空的list
   
7.    public static final  Object[] EMPTY_ELEMENT_DTAA={};
   
8.    //实际存储的元素,transient:避免序列化的
   
9.    transient Object[] elementData;
   
10.    //实际存储list集合的大小
    
11.    public int size=0;
    
12.    //使用这个字段，来判断当前集合类是否被并发修改，即迭代器并发修改的fail-fast机制
    
13.    private static int modCount=0;
    
14.    //新版得jdk不会给创建一个对象
    
15.    public MyArrayList(){
    
16.         this.elementData=EMPTY_ELEMENT_DTAA;
    
17.    }
    
18.    public MyArrayList(int initialCapcity){
    
19.         if(initialCapcity>0){
    
20.             this.elementData=new Object[initialCapcity];
    
21.         }else if(initialCapcity==0){
    
22.             this.elementData=EMPTY_ELEMENT_DTAA;
    
23.         }else{
    
24.             throw new IllegalArgumentException("参数异常");
    
25.         }
    
26.    }
    
27.    public boolean add(Object e){
    
28.        //判断容量
    
29.        ensureCapacityInternal(size+1);
    
30.        //使用下标赋值
    
31.        elementData[size++]=e;
    
32.        return true;
    
33.    }
    
34.    private void ensureCapacityInternal(int minCapacity){
    
35.           //用于并发判断
    
36.           modCount++;
    
37.           if(elementData==EMPTY_ELEMENT_DTAA){
    
38.               minCapacity=Math.max(DEFAULT_CAPACITY,minCapacity);
    
39.           }
    
40.           //是否需要扩容，需要的最少容量大于现在的数组的容量，需要扩容
    
41.           if(minCapacity-elementData.length>0){
    
42.               int oldCapacity=elementData.length;
    
43.               int newCapacity=oldCapacity+(oldCapacity>>1);
    
44.               //如果新容量<最小容量，则将最新的容量赋值给新的容量
    
45.               if(newCapacity-minCapacity<0){
    
46.                   newCapacity=minCapacity;
    
47.               }
    
48.               //创建新数组
    
49.               Object[] objects=new Object[newCapacity];
    
50.               System.arraycopy(elementData,0,objects,0,elementData.length);
    
51.               //修改引用
    
52.               elementData=objects;
    
53.           }
    
54. 
    
55.    }
    
56.    //通过下标获取元素
    
57.    public Object get(int index){
    
58.        rangeCheck(index);
    
59.        return elementData[index];
    
60. 
    
61.    }
    
62.    private void rangeCheck( int  index){
    
63.        if(index>size||size<0){
    
64.            throw new IndexOutOfBoundsException("数组越界");
    
65.        }
    
66.    }
    
67.    /**
    
68.     * 判断对象所在的位置
    
69.     */
    
70.    public  int indexOf(Object o){
    
71.        if(o==null){
    
72.            for(int i=0;i<size;i++){
    
73.                if(elementData[i]==null){
    
74.                    return i;
    
75.                }
    
76.            }
    
77.        }else{
    
78.            for(int i=0;i<size;i++){
    
79.                if(o.equals(elementData[i])){
    
80.                    return i;
    
81.                }
    
82.            }
    
83.        }
    
84.        return -1;
    
85.    }
    
86.    //更新
    
87.    public Object set(int index,Object obj){
    
88.        rangeCheck(index);
    
89.        Object oldValue=elementData[index];
    
90.        elementData[index]=obj;
    
91.        return oldValue;
    
92.    }
    
93.    //根据索引删除元素
    
94.    public Object  remove(int index){
    
95.        rangeCheck(index);
    
96.        //用于并发判断
    
97.        modCount++;
    
98.        Object oldValue=elementData[index];
    
99.        //计算要删除的位置后面有几个元素
    
100.        int numMoved=size-index-1;
     
101.        if(numMoved>0){
     
102.            System.arraycopy(elementData,index+1,elementData,index,numMoved);
     
103.        }
     
104.        //将多出的位置为空，没有引用对象，垃圾收集器就可以回收，如果不置空，将会保存一个引用，可能会造成内存泄漏。
     
105.        elementData[--size]=null;
     
106.        return oldValue;
     
107.    }
     
108.    //获取数组实际大小
     
109.    public  int  size(){
     
110.        return this.size;
     
111.    }
     
112. }
     

测试下：

1. public class Main {
   
2.       public static void main(String[] args) {
   
3.          MyArrayList  myArrayList=new MyArrayList();
   
4.          for(int i=0;i<10;i++){
   
5.              myArrayList.add("i"+i);
   
6.              System.out.println(myArrayList.get(i));
   
7.          }
   
8.           System.out.println("----------------------------------");
   
9.           Object remove = myArrayList.remove(0);
   
10.           System.out.println(remove);
    
11.       }
    
12. }
    

明天关于Map的一些列的分享，敬请关注。