ArrayList集合的底层使用数组实现的
数组的特点是 :
读取快 ; 插入删除慢

链表的特点相反 ：
读取慢，因为需要内存不是连续的，需要找到头节点，顺序遍历;
但是插入删除会很快

package com.bjsxt.collection;

import java.util.ArrayList;
import java.util.List;

import sun.misc.SharedSecrets;

public class MyList {
    
    private Object[] installArr={};
    
    private Object[] elementData=null;
    
    private int size=0;//记录里面到底存储了几个元素
    
    private int installSize=10;
    public MyList(){
        //比较方便，这里我这么写
        this.elementData=new Object[installSize];
    }
    
    public MyList(int sizeParam) throws Exception{
        if(this.size<=0){
            throw new Exception("越界");
        }
        this.elementData=new Object[sizeParam];
    }
    
    public void add(Object obj){
        grow();//若有必要扩容，没必要的话自己玩
        elementData[size]=obj;
        size++;
    }
    
    //移除某个元素 此处不考虑obj为null的情况
    public void remove(Object obj){
        //需要遍历数组，找打他 干掉他
        for(int i=0;i<elementData.length; i++){
            Object ob=elementData[i];
            if(ob.equals(obj)){
                int numMoved = size - i - 1;
                if (numMoved > 0){
                    //这个函数的意思
                    //第一个elementData是原来的数组
                    //第二个elementData是新的数组，这里只不过是特殊，为了不再新建一个数组就用了他自己
                    //第二个参数 的意思是 要复制元素的的起始下标
                    //第四个传参数的意思是 覆盖到新数组的 起始下标
                    //第五个参数是从原数组复制的长度是多少
                    System.arraycopy(elementData, i+1, elementData, i,
                                     numMoved);
                    //此时size应该减少1个了
                    size--;
                    //到这完事了，没有，我们要把原来最后一个元素置为空才行啊 你说呢
                    //因为中间少了一个元素，最后一个元素的值没有被覆盖还在那儿呢
                    System.out.println("size的值为"+size);
                    elementData[size]=null;
                    
                }    
                break;
            }
        }
        
        
    }
    
    //扩容
    public void grow(){
        if(size==elementData.length){
            Object[] elementDataNew=new Object[size*2+10];//规则自己定义
            System.arraycopy(elementData, 0, elementDataNew, 0, size);
            elementData=elementDataNew;
            System.out.println("扩容成功，现在的数组大小为"+elementData.length);
        }
    }
    
    //遍历List
    public void whileMyList(){
        //相当于遍历数组
        for(Object obj:elementData){
            if(obj!=null){
                System.out.println(obj);
            }else{
                System.out.println("null");
            }
            
        }
    }

    public static void main(String[] args) throws Exception {
        
        MyList list=new MyList();
        
        for(int i=0;i<15;i++){
            list.add(i);
        }
        
        list.whileMyList();
        System.out.println("剔除一个元素");
        list.remove(10);
        System.out.println("剔除一个元素后，数组长度"+list.elementData.length);
        list.whileMyList();
        
        /***
         * list集合的底层使用数组实现的
         * 数组的特点是  读取快  插入删除慢
         * 
         * 链表的特点相反 ： 读取慢，因为需要内存不是连续的，需要找到头节点，顺序遍历。但是插入删除会很快
         */
        
        
        
    }

}

``
====================================================`
结束语：
宝剑锋从磨砺出，梅花香子寒苦来。

任何的付出都会有回报。

V : 18612372242 欢迎指正批评

本文分享 CSDN - wangyonglin1123。
如有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一起分享。