ArrayList源码解读(JDK 8)

最新推荐文章于 2024-07-21 22:27:18 发布

晋向阳

最新推荐文章于 2024-07-21 22:27:18 发布

阅读量109

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_52058662/article/details/131522296

版权

ArrayList源码解读(JDK 8)

ArrayList作为数组型链表，它继承于AbstractList类，并实现于RandomAccess、Serializable、Cloneable、List接口，从继承实现关系来看，他实现了Serializable、Cloneable使其具有了可序列化和可克隆的机制;它实现了RandomAccess接口使其具有快速随机访问的机制;而List接口他又实现了Collection使其具有了集合的特性。对于Collection接口又实现了Iterable使集合具有了迭代遍历、for-each的特性。对于AbstractList他是对List的一个抽象在其中完成了对List以最大程度地减少实现由“随机访问”数据存储（如数组）支持的此接口所需的工作量。以及对像LinkedList这样的链表式结构采用顺序读的方式。对源码进行查看时，ArrayList的任意方法上均没有加synchronized以及相关的锁机制，所以他是线程不安全的。
在这里插入图片描述

源码之旅

属性解释

 //无参创建的默认容量
 private static final int DEFAULT_CAPACITY = 10;
 //一个空的元素数组
 private static final Object[] EMPTY_ELEMENTDATA = {};
 //用无参构造创建时默认为该对象
 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
 //元素数组 
 transient Object[] elementData;
 //元素个数
 private int size;
 //最大数组长度 减8的目的为了数据的正确性
 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

注:transient关键字表示不希望该属性被序列化

构造方法

//无参构造直接将DEFAULTCAPACITY_EMPTY_ELEMENTDATA赋给elementData
//此时的elementData长度还未0，并不为10,这是jdk7后期版本的一个改变，当他在第一次给其添加元素时才会被扩容为10
 public ArrayList() {
     this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
 }
 /**
  * 入参: 初始化容量大小
  * 大于0时直接创建一个指定大小的Object数组并赋给elementData
  * 等于零时就将EMPTY_ELEMENTDATA的成员赋给它
  * 小于0时直接报错
  */
 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);
     }
 }
 /**
  *入参: 继承于E的任意类型(包含E)的Collection集合
  * 将c转为数组对象
  * 将a.length 的长度赋给size 
  * 如果为0则将空数组赋给elementData
  * 如果不为零就判断c个字节码是不是ArrayList的字节码对象一致，如果一致直接赋* 值，
  * 如果不是调用Arrays.copyof方法将数组a中的元素size大小后a中的元素复制到新的数组中并返回，赋给elementData
  */
 public ArrayList(Collection<? extends E> c) {
     Object[] a = c.toArray();
     if ((size = a.length) != 0) {
         if (c.getClass() == ArrayList.class) {
             elementData = a;
         } else {
             elementData = Arrays.copyOf(a, size, Object[].class);
         }
     } else {
         elementData = EMPTY_ELEMENTDATA;
     }
 }

注:

<?> 支持任意类型
<? extends A> 继承于A的任意类型(包含A),规定上限
<? super A> A类以及A的父类,规定下限

扩容方法

  public void ensureCapacity(int minCapacity) {
     //如果elementData与DEFAULTCAPACITY_EMPTY_ELEMENTDATA相等就将DEFAULT_CAPACITY 10 给minExpand,不等就为0
     int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
         // any size if not default element table
         ? 0
         // larger than default for default empty table. It's already
         // supposed to be at default size.
         : DEFAULT_CAPACITY;
     /**
      * 如果minExpand不能满足需要就进行再次扩容
      */
     if (minCapacity > minExpand) {
         ensureExplicitCapacity(minCapacity);
     }
 }

 private static int calculateCapacity(Object[] elementData, int minCapacity) {
     if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
         //在需要的容量在和DEFAULT_CAPACITY的比较取大的
         return Math.max(DEFAULT_CAPACITY, minCapacity);
     }
     //如果不相等，取需要的容量
     return minCapacity;
 }

 private void ensureCapacityInternal(int minCapacity) {
     ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
 }

 private void ensureExplicitCapacity(int minCapacity) {
     modCount++;
     /**
      * 需要的容量和elementData长度比较如果大于0则需要扩容
      */
     if (minCapacity - elementData.length > 0)
         grow(minCapacity);
 }


 private static int hugeCapacity(int minCapacity) {
     //超出int 的范围溢出 minCapacity小于0 直接OOM
     if (minCapacity < 0) 
         throw new OutOfMemoryError();
     //如果大于MAX_ARRAY_SIZE就用Integer.MAX_VALUE为容量，如果小于就用规定的最大容量，即Integer.MAX_VALUE-8
     return (minCapacity > MAX_ARRAY_SIZE) ?
         Integer.MAX_VALUE :
         MAX_ARRAY_SIZE;
 }

 private void grow(int minCapacity) {
     /**
      * 原来的数组长度
      */
     int oldCapacity = elementData.length;
     //将新容量扩大到原来的i.5倍
     //(oldCapacity >> 1)使容量的大小缩小一半  即 6 --> 0b0110 计算后 0b0011
     int newCapacity = oldCapacity + (oldCapacity >> 1);
     //如果扩容之后的仍然小于它要求的，就将要求的赋给新的容量
     if (newCapacity - minCapacity < 0) 
         newCapacity = minCapacity;
     //如果newCapacity大于最大ArrayList最大的容量
     if (newCapacity - MAX_ARRAY_SIZE > 0)
         newCapacity = hugeCapacity(minCapacity);
     //将新的容量赋给elementData
     elementData = Arrays.copyOf(elementData, newCapacity);
 }

 public boolean add(E e) {
     //扩容并修改modCount
     ensureCapacityInternal(size + 1);  // Increments modCount!!
     elementData[size++] = e;
     return true;
 }
 /**
  *入参:添加元素的位置索引,元素
  */
 public void add(int index, E element) {
     rangeCheckForAdd(index);  //检查是否越界 越界报错
     //修改modCount
     ensureCapacityInternal(size + 1);  // Increments modCount!!
     System.arraycopy(elementData, index, elementData, index + 1,
                      size - index);//将元素的0~index-1 和 index+1到size-index进行复制,也就是说将index这个位置给空出来 
     elementData[index] = element;//将index位置的数组赋值
     size++; //增加数组中的元素个数
 }

private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); 
}

/**
 * 入参:对象
 */
 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 E remove(int index) {
    rangeCheck(index); //检查index是否越界
    modCount++; //标记修改
    E oldValue = elementData(index); 
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; //让gc销毁

    return oldValue; //放回移除对象
}
public boolean remove(Object o) {
    if (o == null) { 
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++){
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true; //删除成功
            }
        }
            
    }
    return false;//未找到删除失败 
}

清空

    public void clear() {
        modCount++;
        for (int i = 0; i < size; i++)
            elementData[i] = null; //将所有的elementData元素置空
        size = 0;
    }

批量删除

    private boolean batchRemove(Collection<?> c, boolean complement) {
     final Object[] elementData = this.elementData;
     int r = 0, w = 0;
     boolean modified = false;
     //存在即删除
     try {
         for (; r < size; r++)
             if (c.contains(elementData[r]) == complement)
                 elementData[w++] = elementData[r];
     } finally {
         if (r != size) {
             System.arraycopy(elementData, r,
                              elementData, w,
                              size - r);
             w += size - r;
         }
         if (w != size) {
             for (int i = w; i < size; i++)
                 elementData[i] = null;
             modCount += size - w;
             size = w;
             modified = true;
         }
     }
     return modified;
 }

排序

 /**
  * 本质调用的Arrays.sort的方法
  */
 public void sort(Comparator<? super E> c) {
     final int expectedModCount = modCount;
     Arrays.sort((E[]) elementData, 0, size, c);
     if (modCount != expectedModCount) {
         throw new ConcurrentModificationException();
     }
     modCount++;
 }

mparator<? super E> c) {
final int expectedModCount = modCount;
Arrays.sort((E[]) elementData, 0, size, c);
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
modCount++;
}

晋向阳

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
ArrayList源码解读(JDK 8)

ArrayList作为数组型链表，它继承于AbstractList类，并实现于RandomAccess、Serializable、Cloneable、List接口，从继承实现关系来看，他实现了Serializable、Cloneable使其具有了可序列化和可克隆的机制;它实现了RandomAccess接口使其具有快速随机访问的机制;而List接口他又实现了Collection使其具有了集合的特性。对于Collection接口又实现了Iterable使集合具有了迭代遍历、for-each的特性。
复制链接

扫一扫