ArrayList源码分析

时间 2019-12-04

原文原文链接

ArrayList源码分析

类的实现接口及继承父类

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

AbstractList 和 List

ArrayList 和AbstractList 都实现了List接口。
而且AbstractList是ArrayList的父类。java

RandomAccess

RandomAccess接口里没有方法须要实现。这是一个很特别的空接口。这个接口的做用是：数据库

List实现它可以支持快速随机访问。主要能提升随机访问的性能。
 for (int i=0, n=list.size(); i &lt; n; i++)
    list.get(i);
比下面这种快。
for (Iterator i=list.iterator();i.hasNext(); )
    i.next();

Cloneable

此接口也是一个空接口，实现次接口，须要重写object对象的clone()方法，而且方法是访问权限是public的。数组

clone()是值拷贝，即为浅拷贝。微信

测试是否为浅拷贝：框架

拷贝对象：dom

package xuelongjiang.ArrayListCloneTest;

/**
 * @author xuelongjiang
 */
public class User {

private String name ;

private Integer sex;

public User() {
}

public User(String name, Integer sex) {
    this.name = name;
    this.sex = sex;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public Integer getSex() {
    return sex;
}

public void setSex(Integer sex) {
    this.sex = sex;
}


@Override
public String toString() {
    return "User{" +
            "name='" + name + '\'' +
            ", sex=" + sex +
                    "//\n" +
            getClass().getName() + "@" + Integer.toHexString(hashCode())+
            '}';
}

}ide

测试类：源码分析

package xuelongjiang.ArrayListCloneTest;


import java.util.ArrayList;
import java.util.List;

/**
 *
 * 结论： clone 是浅拷贝 值相同，对象的引用相同
 * @author xuelongjiang
 */
public class CloneObject {


public static void main(String[] args) {


    ArrayList<User> userList = new ArrayList<>();
    userList.add(new User("xue",1));
    userList.add(new User("lisi",2));

    System.out.println("------------原始值-------------");
    for(User user : userList){
        System.out.println(user);
    }


    List<User> cloneList  = (List<User>) userList.clone();
    System.out.println("------------拷贝值-------------");
    for(User user : cloneList){
        System.out.println(user);
    }


}

}

输出：性能

------------原始值-------------
User{name='xue', sex=1//
xuelongjiang.ArrayListCloneTest.User@2d98a335}
User{name='lisi', sex=2//
xuelongjiang.ArrayListCloneTest.User@16b98e56}
------------拷贝值-------------
User{name='xue', sex=1//
xuelongjiang.ArrayListCloneTest.User@2d98a335}
User{name='lisi', sex=2//
xuelongjiang.ArrayListCloneTest.User@16b98e56}

实现ArrayList的容器

ArrayList的底层实现为数组。测试

transient Object[] elementData;

从上面咱们能够看出数组为obejct。在取出值的时候利用范型转为声明的类型。

构造方法

ArrayList 有三个构造方法

第一种构造方法：

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

若是使用无参的构造方法，则初始化的数组为空（注意不为null）。

第二种构造方法

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

若是初始化的容器值大于0，则初始化为这个值。若是等于0 则初始化为空

private static final Object[] EMPTY_ELEMENTDATA = {};

若是小于0则抛出异常。

第三种构造方法：

public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
    // c.toArray might (incorrectly) not return Object[] (see 6260652)
    if (elementData.getClass() != Object[].class)
        elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
    // replace with empty array.
    this.elementData = EMPTY_ELEMENTDATA;
}
}

因为ArrayList的底层实现是Object[] 须要把Collection转为Object[]。而且设置size为传入的Collection大小。

经常使用方法解析

size() list的元素数

size方法很简单直接返回size值的大小。

private int size;

public int size() {
    return size;
}

add()

在add方法中会对elemenrData进行扩容，若是不须要扩容或者扩容完成了，就把须要添加的元素放入elementData中，而且size自增。

public boolean add(E e) {
      ensureCapacityInternal(size + 1);  // Increments modCount!!
elementData[size++] = e;
return true;
}

在ensureCapacityInternal中若是容器为空，比较须要扩容的大小和DEFAULT_CAPACITY(= 10)
若是大于DEFAULT_CAPACITY，则使用本次传入的不然设置容量为DEFAULT_CAPACITY。

private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
    minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}

ensureExplicitCapacity(minCapacity);
}

ensureExplicitCapacity方法:

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

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

若是本次须要的扩容大于elementData的长度，则调用grow方法扩容。

private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;//1
int newCapacity = oldCapacity + (oldCapacity >> 1);//2
if (newCapacity - minCapacity < 0)
    newCapacity = minCapacity;//3
if (newCapacity - MAX_ARRAY_SIZE > 0)
    newCapacity = hugeCapacity(minCapacity);//4
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);//5
}

获取当前容器的大小
计算新的扩容大小：扩容1.5倍
若是默认扩容小于本次须要扩容的大小，则设置为本次须要的扩容大小，不然设为默认扩容
```
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
```

public static final int   MAX_VALUE = 0x7fffffff;//2的31次方，大于20多亿

若是本次须要的扩容大于MAX_ARRAY_SIZE，则容器设置为Integer.MAX_VALUE，若是等于MAX_ARRAY_SIZE则设为MAX_ARRAY_SIZE。
拷贝生成扩容后的容器

remove()

public E remove(int index) {
    rangeCheck(index);//1
       modCount++;
       E oldValue = elementData(index);//2

            int numMoved = size - index - 1;//3
        if (numMoved > 0)
    System.arraycopy(elementData, index+1, elementData, index,
                     numMoved);//4
    elementData[--size] = null; // clear to let GC do its work
    return oldValue;
    }

移除元素后，须要把它以后的虽有元素向前移动1位。

检查索引是否超出范围
返回被移除的元素
须要向前移动的元素数
移动元素：拷贝

contains() 是否包含某元素

public boolean contains(Object o) {
return indexOf(o) >= 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;
}

循环容器判断每个元素是否和目标值相等。
**注意：若是是对象的话这里比较的对象的引用，在开发中不少时候咱们要比较的实体，实体映射的是数据库里的一条记录，比较的实际上是主键是否相等，因此若是
是这种状况须要重写equal方法及hashCode方法**

clear()

public void clear() {
modCount++;

// clear to let GC do its work
for (int i = 0; i < size; i++)
    elementData[i] = null;

size = 0;
}

把容器中的每一个元素的值设为null，以后垃圾回收机制会收回被使用的内存。

迭代器

java5以后，集合框架可使用迭代器，而且提供了foreach语法糖。

public Iterator<E> iterator() {
return new Itr();
}

public E next()
public boolean hasNext()

迭代器模式：https://blog.csdn.net/u013565...

开发中的易犯错误

https://blog.csdn.net/u013565...

关注个人公众号第一时间阅读有趣的技术故事
扫码关注：
也能够在微信搜索公众号便可关注我：codexiulian 渴望与你一块儿成长进步！