ArrayList常用方法及原理实现

为什么要用ArrayList

为了解决数组的局限性，引入了容器类概念。ArrayList的容量capacity会随着对象的增加自动增加，从而解决了数组出现的越界问题。

ArrayList常用方法

ArrayList<String>res=new ArrayList<>();
res.add("zrf"); //添加
res.add("zxf");
res.get(1);//获取指定位置的对象
res.indexOf("zrf"); //获取指定对象的位置
res.size(); // 获取大小
res.contains("zrf"); //判断是否有某对象
res.remove(1); //移除对象
String []ch=(String[])res.toArray(new String[]{});//转换成数组~

实现一个简单的ArrayList

package middle.Collections;

import javax.xml.bind.Element;
import java.util.Arrays;

public class ArrayList<E> {
    private static int capacity=0;
    private Object[] elementData={};
    private int size;
    private static final int DEFAULT_CAPACITY=10;
    public ArrayList(int initCapacity){
        if(initCapacity<0)
            throw new IllegalArgumentException("数组大小不为0");
        else{
            this.elementData=new Object[initCapacity];
        }

    }
    public ArrayList(){
        this.elementData=new Object[DEFAULT_CAPACITY];
    }
    /*
    首先检查容量，是否需要扩容
    插入
     */
    public boolean add(E e){
        ensureCapacityInterval(size+1);
        elementData[size++]=e;
        return true;
    }
    /*
    先检查是否数组越界
    */
    public void add(int index,E e){
        if(index>size||size<0) {
            throw new IndexOutOfBoundsException("插入的数组越界");
        }
        ensureCapacityInterval(size+1);
        System.arraycopy(elementData,index,elementData,index+1,size-index);
        elementData[index]=e;
        size++;

    }
    public int size(){
        return size;
    }
    public E get(int index){
        return (E)this.elementData[index];
    }
    public int indexOf(E e){
        if(e==null){
            for(int i=0;i<size;i++){
                if(elementData[i]==null)
                    return i;
            }
        }else {
            for(int i=0;i<size;i++){
                if(e.equals(elementData[i]))
                    return i;
            }
        }
        return -1;
    }
    public boolean contains(E e){
        return indexOf(e)>0;
    }
    public E remove(int index){
        if(index>elementData.length-1) {
            throw new IndexOutOfBoundsException("插入的数组越界");
        }
        E oldValue=(E)elementData[index];
        int numMoved=size-index-1;
        System.arraycopy(elementData,index+1,elementData,index,numMoved);
        elementData[--size]=null;
        return oldValue;

    }


    public void ensureCapacityInterval(int miniCapacity){
        if(miniCapacity>0){
            miniCapacity=Math.max(miniCapacity,DEFAULT_CAPACITY);
        }
        ensureExplicitCapacity(miniCapacity);

    }
    /*
    扩容时先扩1.5倍
    */
    private void ensureExplicitCapacity(int minCapacity) {
        if(minCapacity-elementData.length>0){
            int oldCapacity=elementData.length;
            int newCapacity=oldCapacity+(oldCapacity>>1);
            if(newCapacity-minCapacity<0)newCapacity=minCapacity;
            elementData=Arrays.copyOf(elementData,newCapacity);

        }

    }
    public static void main(String[]args) {
        ArrayList <Integer>arr = new ArrayList<>();
        for (int i = 0; i < 50; i++) {
            arr.add(i);
        }
        arr.remove(5);
        System.out.println("-----------");
        System.out.println(arr.indexOf(4));
        System.out.println("-----------");
        System.out.println(arr.size());
        System.out.println("-----------");
        arr.add(5,100);
        for (int i = 0; i < arr.size; i++)
            System.out.println(arr.get(i));
    }

}
~

ArrayList、LinkList、Vector的区别

ArrayList的底层数据结构是数组，线程不安全
LinkList的底层数据结构是链表，线程安全
Vector的底层数据结构是数组，线程安全