八百年没写博客了 最近在读java源码就 先看下ArrayList

于 2019-05-16 20:20:20 发布
阅读量189 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Struggl_ing/article/details/90244289
本文详细解析了Java中的ArrayList类，包括其实现原理、类层次结构、核心方法及操作特性。介绍了ArrayList如何通过动态数组实现高效的数据存储与访问，以及其在多线程环境下的使用注意事项。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

    ArrayList是java.util包下的一个类，继承了AbstractList类实现了List接口，RandomAccess接口，Cloneable接口和Serializable接口，但是AbstractList接口也实现了List接口  就有点搞不懂了。

   按照源码上的顶部注释

翻译过来就是：

List接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括null在内的所有元素。除了实现List接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于Vector类，除了此类是不同步的。）

size、isEmpty、get、set、iterator和listIterator操作都以固定时间运行。add操作以分摊的固定时间运行，也就是说，添加n个元素需要O(n)时间。其他所有操作都以线性时间运行（大体上讲）。与用于LinkedList实现的常数因子相比，此实现的常数因子较低。

每个ArrayList实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向ArrayList中不断添加元素，其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。

在添加大量元素前，应用程序可以使用ensureCapacity操作来增加ArrayList实例的容量。这可以减少递增式再分配的数量。

注意，此实现不是同步的。如果多个线程同时访问一个ArrayList实例，而其中至少一个线程从结构上修改了列表，那么它必须保持外部同步。（结构上的修改是指任何添加或删除一个或多个元素的操作，或者显式调整底层数组的大小；仅仅设置元素的值不是结构上的修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用Collections.synchronizedList方法将该列表“包装”起来。这最好在创建时完成，以防止意外对列表进行不同步的访问： 
List list = Collections.synchronizedList(new ArrayList(…));

此类的iterator和listIterator方法返回的迭代器是快速失败的：在创建迭代器之后，除非通过迭代器自身的remove或add方法从结构上对列表进行修改，否则在任何时间以任何方式对列表进行修改，迭代器都会抛出ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。

注意，迭代器的快速失败行为无法得到保证，因为一般来说，不可能对是否出现不同步并发修改做出任何硬性保证。快速失败迭代器会尽最大努力抛出ConcurrentModificationException。因此，为提高这类迭代器的正确性而编写一个依赖于此异常的程序是错误的做法：迭代器的快速失败行为应该仅用于检测bug。

此类是Java Collections Framework的成员。

ArrayList是通过动态数组实现的     其中 元素可以为空      但ArrayList不是线程安全的  

 

ArrayList的类层次结构图

 

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

1.ArrayList 支持泛型

2.extends AbstractList<E> 继承AbstractList 提供了 ArrayList功能的基本骨架

3.implements List<E>  实现对表的操作

4. implements RamdonAccess 来实现持快速随机访问

5.implements Clonea 表明其可以调用clone()方法

6. implements java.io.Serializable 来实现序列化

 

ArrayList的变量

// 反序列化的编号
private static final long serialVersionUID = 8683452581122892189L;

 

// 缺省数组长度

 private static final int DEFAULT_CAPACITY = 10;

 

// 用于返回数组长度已知且为0是的空数组

private static final Object[] EMPTY_ELEMENTDATA = {};

 

// 用于返回用无参构造器创建ArrayList对象时的空数组 区别于 DEFULT_EMPTY_ELEMENTDAT

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

 

//  实际ArrayList的数组   用transient支持序列化    当第一次执行add方法时  会扩充容量为DAFULT_CAPACITY 

transient Object[] elementData;

 

// 实际数组中存储的数目的多少
private int size;

 

// 数组最大长度

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

 

构造方法

1.   构造具有指定初始容量的空列表   长度不为零 就创建指定长度的数组，  等于0就把EMPTY_ELEMENTDATA赋给elementData  

public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

 2. 构造一个初始容量为10的空列表。

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

 3. 按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表。

public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

 核心方法

add(E e)  添加元素

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  //  判断添加元素后， 数组大小是否达到上限 达到上限就给数组扩容
    elementData[size++] = e;           //  把元素添加进数组  真实长度加1
    return true;
}
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

 //  如果elementData是 默认长度的数组，且添加元素后的长度小于10 就不需要扩容  如果大于10 就返回最小容量需求后的值

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

// 判断是否需要对数组进行扩容  判断数组的长度和最小需求容量  如果最小需求容量大于数组的当前长度 对数组进行扩容

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

// 扩容方法    

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;                   // 记录原来的数组长度
    int newCapacity = oldCapacity + (oldCapacity >> 1);     // >> 表示求这个数一半  新的容量是原本容量的1.5倍
    if (newCapacity - minCapacity < 0)         //  若果增长后的容量还是小于最小需求容量 让新的容量等于最小需求容量
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)       // 如果新的容量比最大的数组容量大   是容量变为最大的Integer值
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);   //对元素组记性拷贝 实现动态增长
}
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

 

 

add (int index, Element)  在指定索引位置添加元素

 

public void add(int index, E element) {
    rangeCheckForAdd(index);            // 检查索引是否越界

    ensureCapacityInternal(size + 1);  // Increments modCount!!    // 这个方法和add(E e)一样
    System.arraycopy(elementData, index, elementData, index + 1,  
                     size - index);   // 把从index的元素到末尾拷贝到index+1   长度为size-index
    elementData[index] = element;     // 把指定索引处的设置为element
    size++;                         //  真实长度加1
｝

 get(int index) 返回指定索引处的值 

public E get(int index) {
    rangeCheck(index);                      // 先检查是否越界

    return elementData(index);           // 返回eletmentData(index)  因为ArrayList是用数组实现的  get方法速度很快
}

set(int index, E element)

public E set(int index, E element) {
    rangeCheck(index);                      // 检查是是否越界

    E oldValue = elementData(index);        // 记录被替换前的元素
    elementData[index] = element;           // 替换成元素
    return oldValue;                        // 返回替换前的元素                      
}              // 因为ArrayList是数组实现的  set方法的实现也是很快的

 remove(int index)   删除制定索引位置的元素  返回被删除的元素

public E remove(int index) {
    rangeCheck(index);         // 检查是否越界

    modCount++;               // 这个 没怎么搞明白干什么用的
    E oldValue = elementData(index);          // 记录被删除的元素

    int numMoved = size - index - 1;          // 记录需要移动的元素数目
    if (numMoved > 0)                         //  若果移动端长度有实际意义 就把从index+1d到size元素前移
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work    // 把末尾元素置为null 等待gc回收

    return oldValue;
}

remove(Object 0)  // 删除指定元素 

public boolean remove(Object o) {
    if (o == null) {
        for (int index = 0; index < size; index++)    // 如果object为null  就把数组中的null元素全部删除
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)   // 不为空就删除可以进行equals匹配的元素
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

// 快速删除

private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;            // 和reomve(int index)方法相似 只是不需要越界检查
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work
}

doClear()  //清空

public void clear() {
    modCount++;

    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;               // 把数组中的元素全部置为null  等待gc执行 回收

    size = 0;
}

addAll(Collection<? extends E> c)    把集合添加到该ArrayList

public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();   // 把集合转化成数组
    int numNew = a.length;      // 记录要添加的元素的长度 
    ensureCapacityInternal(size + numNew);  // Increments modCount    // 扩容
    System.arraycopy(a, 0, elementData, size, numNew);      // 把object数组中的内容添加到ElementData
    size += numNew;                                         // 现在的长度 等于添加签的长度加上添加的数组长度
    return numNew != 0;
}
addAll(int index, Collection<? extends E> c)  在指定索引出添加指定集合中的元素
public boolean addAll(int index, Collection<? extends E> c) {
    rangeCheckForAdd(index);

    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount

    int numMoved = size - index;
    if (numMoved > 0)
        System.arraycopy(elementData, index, elementData, index + numNew,
                         numMoved);         // 这一步是吧从所引出到末尾的元素复制到增长指定结合集合长度后

    System.arraycopy(a, 0, elementData, index, numNew); // 把集合拷贝到制定index  移动基本和addAll(Collection c) 相似
    size += numNew;
    return numNew != 0;
}

  

 

 别的就先不写了   ArrayList比较简单

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值