ArrayList简介

ArrayList是基于数组实现的,是一个动态数组,其容量能自动增长,雷同于C语言中的动态申请内存,动态增长内存。

ArrayList不是线程安详的,只能用在单线程情况下,多线程情况下可以思量用Collections.synchronizedList(List l)函数返回一个线程安详的ArrayList类,也可以利用concurrent并发包下的CopyOnWriteArrayList类。

ArrayList实现了Serializable接口,因此它支持序列化,可以或许通过序列化传输,实现了RandomAccess接口,支持快速随时机见,实际上就是通过下标序号举办快速会见,实现了Cloneable接口,能被克隆。

ArrayList源码分解

ArrayList的源码如下(插手了较量具体的注释):

package java.util;    
       
public class ArrayListextends AbstractListimplements List, RandomAccess, Cloneable, java.io.Serializable    
{    
    // 序列版本号    
    private static final long serialVersionUID = 8683452581122892189L;    
       
    // ArrayList基于该数组实现,用该数组生存数据   
    private transient Object[] elementData;    
       
    // ArrayList中实际数据的数量    
    private int size;    
       
    // ArrayList带容量巨细的结构函数。    
    public ArrayList(int initialCapacity) {    
        super();    
        if (initialCapacity < 0)    
            throw new IllegalArgumentException("Illegal Capacity: "+    
                                               initialCapacity);    
        // 新建一个数组    
        this.elementData = new Object[initialCapacity];    
    }    
       
    // ArrayList无参结构函数。默认容量是10。    
    public ArrayList() {    
        this(10);    
    }    
       
    // 建设一个包括collection的ArrayList    
    public ArrayList(Collection c) {    
        elementData = c.toArray();    
        size = elementData.length;    
        if (elementData.getClass() != Object[].class)    
            elementData = Arrays.copyOf(elementData, size, Object[].class);    
    }    
       
       
    // 将当前容量值设为实际元素个数    
    public void trimToSize() {    
        modCount++;    
        int oldCapacity = elementData.length;    
        if (size < oldCapacity) {    
            elementData = Arrays.copyOf(elementData, size);    
        }    
    }    
       
       
    // 确定ArrarList的容量。    
    // 若ArrayList的容量不敷以容纳当前的全部元素,配置 新的容量=“(原始容量x3)/2 + 1”    
    public void ensureCapacity(int minCapacity) {    
        // 将“修改统计数”+1,该变量主要是用来实现fail-fast机制的    
        modCount++;    
        int oldCapacity = elementData.length;    
        // 若当前容量不敷以容纳当前的元素个数,配置 新的容量=“(原始容量x3)/2 + 1”    
        if (minCapacity > oldCapacity) {    
            Object oldData[] = elementData;    
            int newCapacity = (oldCapacity * 3)/2 + 1;    
            //假如还不足,则直接将minCapacity配置为当前容量  
            if (newCapacity < minCapacity)    
                newCapacity = minCapacity;    
            elementData = Arrays.copyOf(elementData, newCapacity);    
        }    
    }    
       
    // 添加元素e    
    public boolean add(E e) {    
        // 确定ArrayList的容量巨细    
        ensureCapacity(size + 1);  // Increments modCount!!    
        // 添加e到ArrayList中    
        elementData[size++] = e;    
        return true;    
    }    
       
    // 返回ArrayList的实际巨细    
    public int size() {    
        return size;    
    }    
       
    // ArrayList是否包括Object(o)    
    public boolean contains(Object o) {    
        return indexOf(o) >= 0;    
    }    
       
    //返回ArrayList是否为空    
    public boolean isEmpty() {    
        return size == 0;    
    }    
       
    // 正向查找,返回元素的索引值    
    public int indexOf(Object o) {    
        if (o == null) {    
            for (int i = 0; i < size; i++)    
            if (elementData[i]==null)    
                return i;    
            } else {    
                for (int i = 0; i < size; i++)    
                if (o.equals(elementData[i]))    
                    return i;    
            }    
            return -1;    
        }    
       
        // 反向查找,返回元素的索引值    
        public int lastIndexOf(Object o) {    
        if (o == null) {    
            for (int i = size-1; i >= 0; i--)    
            if (elementData[i]==null)    
                return i;    
        } else {    
            for (int i = size-1; i >= 0; i--)    
            if (o.equals(elementData[i]))    
                return i;    
        }    
        return -1;    
    }    
       
    // 反向查找(从数组末端向开始查找),返回元素(o)的索引值    
    public int lastIndexOf(Object o) {    
        if (o == null) {    
            for (int i = size-1; i >= 0; i--)    
            if (elementData[i]==null)    
                return i;    
        } else {    
            for (int i = size-1; i >= 0; i--)    
            if (o.equals(elementData[i]))    
                return i;    
        }    
        return -1;    
    }    
         
       
    // 返回ArrayList的Object数组    
    public Object[] toArray() {    
        return Arrays.copyOf(elementData, size);    
    }    
       
    // 返回ArrayList元素构成的数组  
    publicT[] toArray(T[] a) {    
        // 若数组a的巨细 < ArrayList的元素个数;    
        // 则新建一个T[]数组,数组巨细是“ArrayList的元素个数”,并将“ArrayList”全部拷贝到新数组中    
        if (a.length < size)    
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());    
       
        // 若数组a的巨细 >= ArrayList的元素个数;    
        // 则将ArrayList的全部元素都拷贝到数组a中。    
        System.arraycopy(elementData, 0, a, 0, size);    
        if (a.length > size)    
            a[size] = null;    
        return a;    
    }    
       
    // 获取index位置的元素值    
    public E get(int index) {    
        RangeCheck(index);    
       
        return (E) elementData[index];    
    }    
       
    // 配置index位置的值为element    
    public E set(int index, E element) {    
        RangeCheck(index);    
       
        E oldValue = (E) elementData[index];    
        elementData[index] = element;    
        return oldValue;    
    }    
       
    // 将e添加到ArrayList中    
    public boolean add(E e) {    
        ensureCapacity(size + 1);  // Increments modCount!!    
        elementData[size++] = e;    
        return true;    
    }    
       
    // 将e添加到ArrayList的指定位置    
    public void add(int index, E element) {    
        if (index > size || index < 0)    
            throw new IndexOutOfBoundsException(    
            "Index: "+index+", Size: "+size);    
       
        ensureCapacity(size+1);  // Increments modCount!!    
        System.arraycopy(elementData, index, elementData, index + 1,    
             size - index);    
        elementData[index] = element;    
        size++;    
    }    
       
    // 删除ArrayList指定位置的元素
//本栏目
		 

JAVA 教程

2017-12-28


ArrayList简介 ArrayList是基于数组实现的,是一个动态数组,其容量能自动增长,雷同于C语言中的动态申请内存,动态增长内存。 ArrayList不是线程安详的,只能