JDK1.8 ArrayList源码浅析

最新推荐文章于 2023-03-28 13:40:41 发布

weixin_30808253

最新推荐文章于 2023-03-28 13:40:41 发布

阅读量91

点赞数

原文链接：http://www.cnblogs.com/dougest/p/7058258.html

版权

我的jdk版本

拆开源码,我们从头道来,不足或误解,请指正

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

ArrayList是一个泛型类,继承自AbstractList,重写了IndexOf(Object o)等方法,

 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;
}

实现了get(index),size()抽象方法

    public T get(int index) {
        rangeCheck(index);
        return elementData(index);
    }

    public int size() {
        return size;
    }

实际上,ArrayList底层是这个玩意

transient Object[] elementData;//没有被私有化是为了简化内部类访问

当然还有其他的几个属性:

private static final int DEFAULT_CAPACITY = 10;

private static final Object[] EMPTY_ELEMENTDATA = {};

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

private int size;

在ArrayList中有三个构造器,分别为

//初始化容量的构造器
    public ArrayList(int initCapacity){
        if(initCapacity > 0) 
            this.elementData = new Object[initCapacity];
        else if(initCapacity == 0) 
            this.elementData = EMPTY_ELEMENTDATA;
        else 
            throw new IllegalArgumentException("cant init ArrayList for this initCapacity:"+initCapacity);
    }
    /*默认构造器*/
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    /**
     * 传入继承集合类的实例
     * @param c
     */
    public ArrayList(Collection<? extends T> 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;
        }
    }

注意的是,默认构造器中,

this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;

是一个默认的空Object数组

/**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

并没有设置初始值,对于网上一片文章说ArrayList初始化长度为10,我又翻了一下jdk1.7源码

   /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
    }

    /**
     * Shared empty array instance used for empty instances.
　　　* 这里是用final 和 static 修饰的
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

也是空数组,所以下面这种构造器最起码不会出现在jdk1.7和jdk1.8中,也就是说两个版本中的实例化ArrayList的时候没有给他设置默认容量

public ArrayList() {
        this(10);
}

那么,什么时候这个空数组才会真正的扩容呢,也就是大家说的容量为10的时候

在源码中,ArrayList提供了这样几个方法,也就是关于ArrayList容量的关键的几个方法

/*方法名直译为:确认容量*/
    public void ensureCapacity(int minCapacity) {
        //最小扩展
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) ? 0: DEFAULT_CAPACITY;
        
        if(minCapacity > minExpand) 
            ensureExplicitCapacity(minCapacity);
    }

上面的这个方法我是看了一阵子,脑回路差点跑偏,换种思路可能会更直观一些

int minExpand = (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) ? DEFAULT_CAPACITY : 0 ;

我对这个方法的大概理解就是如果elementData是空的,返回一个默认容量(DEFAULT_CAPACITY),长度在上面已经定义好了,是10,如果传入的参数大于这个最小扩展(10),

进入ensureExplicitCapacity()方法,

/*方法名直译为:确认内部容量*/
    public void ensureCapacityInternal(int minCapacity) {
        if(elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) 
            //取值 10 - 传入最小值之间最大
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
            
        ensureExplicitCapacity(minCapacity);
    }

判断elementData是否为空数组,是则返回默认长度(10)和传入参数中大的那一个

进入ensureExplicitCapacity()方法,

/* 明确容量*/
    public void ensureExplicitCapacity(int minCapacity){
        modCount++;
        //意识到长度溢出时,增长长度
        if(minCapacity - elementData.length > 0)
            grow(minCapacity);
    };

以上两个方法结束时调用本方法

在ArrayList,LinkedList,HashMap等等的内部实现增，删，改中我们总能看到modCount的身影，modCount字面意思就是修改次数,而拥有这个参数的方法都是线程不安全的

在一个迭代器初始的时候会赋予它调用这个迭代器的对象的mCount，如何在迭代器遍历的过程中，一旦发现这个对象的mcount和迭代器中存储的mcount不一样那就抛异常

这里涉及到了一个机制叫做:

fail-fast机制:

它是Java集合的一种错误检测机制。当多个线程对集合进行结构上的改变的操作时，有可能会产生fail-fast机制。记住是有可能，而不是一定。例如：假设存在两个线程（线程1、线程2），线程1通过Iterator在遍历集合A中的元素，在某个时候线程2修改了集合A的结构（是结构上面的修改，而不是简单的修改集合元素的内容），那么这个时候程序就会抛出 ConcurrentModificationException 异常，从而产生fail-fast机制。

/*有人说int最大减8是尽可能的避免一些错误 */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**
     * 长度增长
     * @param minCapacity
     */
    public void grow(int minCapacity) {
        //原数组长度
        int oldCapacity = elementData.length;
        //位运算 右位移1位
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if(newCapacity - minCapacity < 0) //小于传入长度时
            newCapacity = minCapacity;
        if(newCapacity - MAX_ARRAY_SIZE > 0) //大于上方自定义的最大数组长度
            newCapacity = hugeCapacity(minCapacity);
        
         elementData = Arrays.copyOf(elementData, newCapacity);
    };

数组长度在增长时,有位移1并代表增加0.5倍,具体增长的数值,可自行百度java位运算

private static int hugeCapacity(int minCapacity) {
            if (minCapacity < 0) // overflow 超出int整数范围变负数
                throw new OutOfMemoryError();
            return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE :  MAX_ARRAY_SIZE;
     }

了解到这几个方法之后,我们来看一下常用的增/删/改/查操作

查:

 @SuppressWarnings("unchecked")
 T elementData(int index){
         return (T) elementData[index];
 }

 //范围检测
     public void rangeCheck(int index) {
         if(index >= size) {
             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
         }
     }

/*来自父类的抽象方法*/
    public T get(int index) {
        rangeCheck(index);//检测传入参数范围,超过范围数组下标越界
        return elementData(index);
    }

没什么好说的,只是代码抽象化了一点

增

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

public boolean add(T t) {
        ensureCapacityInternal(size + 1);
        elementData[size++] = t;
        return true;
    }

public void add(int index, T element) {
        rangeCheckForAdd(index);
        ensureCapacityInternal(size + 1);  // 增加容量
        
        System.arraycopy(elementData, index, elementData, index + 1, size - index);
        elementData[index] = element;
        size++;//??为什么又加了
    }

改:

public T set(int index, T element) {
         rangeCheck(index);
         
         T oldValue = elementData(index);//这里的elementData是方法
         elementData[index] = element;//这里的elementData是数组
         return oldValue;
 }
//这里的返回值是被替换的元素

删:

public T remove(int index) {
        rangeCheck(index);
        
        modCount++;
        T oldValue = elementData(index);//方法
        
        int numMoved = size - index -1;//是否超长
        if(numMoved > 0)
             System.arraycopy(elementData, index+1, elementData, index, numMoved);
        
        elementData[--size] = null;//最后一个设置为null 数组
        
        return oldValue;
    }

到这里ArrayList一些基础内容也讲的差不多了,更为深入的一些机制现在就不提了,以后再深入研究吧

学习是一种态度,不管是jdk源码还是spring或者tomcat源码,抱着借鉴和模仿的心态,努力提高自己.

写代码应该是一件很快乐的事情,过程中也许会有些痛苦,但是往往快乐最后远大于痛苦

不要因为别人一句看这玩意有什么用而放弃自己的追求,不要被外界干扰,自己要坚定

转载于:https://www.cnblogs.com/dougest/p/7058258.html

weixin_30808253

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JDK1.8 ArrayList源码浅析

我的jdk版本拆开源码,我们从头道来,不足或误解,请指正public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.SerializableArrayList是一个泛型类,继承...
复制链接

扫一扫