ArrayList源码分析

最新推荐文章于 2022-10-01 10:00:00 发布

漠翊歌

最新推荐文章于 2022-10-01 10:00:00 发布

阅读量131

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/qq_34839150/article/details/105994578

版权

Java 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

ArrayList

ArrayList简介

ArrayList就是动态数组，是Array的复杂版本。List 接口的大小可变数组的实现，位于API文档的java.util.ArrayList。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector 类，除了此类是不同步的）。

ArrayList 变量

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

ArrayList继承了AbstractList类，并且实现了一系列的接口。

DEFAULT_CAPACITY

private static final int DEFAULT_CAPACITY = 10;

数组初始默认容量

EMPTY_ELEMENTDATA

private static final Object[] EMPTY_ELEMENTDATA = {};

用于空实例的共享空数组实例。

DEFAULTCAPACITY_EMPTY_ELEMENTDATA

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

默认数组初始化状态。

elementData

transient Object[] elementData; // non-private to simplify nested class access

数据的存储数组

size

private int size;

列表中实际存在的元素个数

ArrayList方法

构造方法

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

默认的构造方法，把存放数据的数组初始华为默认的数组，DEFAULTCAPACITY_EMPTY_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);
    }
}

此构造方法中，若传入的值合法，则将存放数据的数组长度设置为传入的值。

public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // defend against c.toArray (incorrectly) not returning Object[]
        // (see e.g. https://bugs.openjdk.java.net/browse/JDK-6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

传入一个集合，把集合中的所有数据都拷贝到ArrayList的存储数组中。

contains(Object o)

public boolean contains(Object o) {
    return indexOf(o) >= 0;
}

判断List中是否包含某个对象，本质上是调用了indexOf方法

indexOf(Object o)

public int indexOf(Object o) {
    return indexOfRange(o, 0, size);
}

int indexOfRange(Object o, int start, int end) {
    Object[] es = elementData;
    if (o == null) {
        for (int i = start; i < end; i++) {
            if (es[i] == null) {
                return i;
            }
        }
    } else {
        for (int i = start; i < end; i++) {//对象不为空，遍历存储数组，找到返回索引，否则-1
            if (o.equals(es[i])) {
                return i;
            }
        }
    }
    return -1;
}

lastIndexOf(Object o)

public int lastIndexOf(Object o) {
    return lastIndexOfRange(o, 0, size);
}

从后往前寻找第一次出现的元素，本质上是反向遍历存储数组

int lastIndexOfRange(Object o, int start, int end) {
    Object[] es = elementData;
    if (o == null) {
        for (int i = end - 1; i >= start; i--) {
            if (es[i] == null) {
                return i;
            }
        }
    } else {
        for (int i = end - 1; i >= start; i--) {
            if (o.equals(es[i])) {
                return i;
            }
        }
    }
    return -1;
}

clone()

public Object clone() {
    try {
        ArrayList<?> v = (ArrayList<?>) super.clone();
        v.elementData = Arrays.copyOf(elementData, size);
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError(e);
    }
}

获得一个与当前链表一样的副本，深拷贝。

toArray()

public Object[] toArray() {
    return Arrays.copyOf(elementData, size);
}

将list转化为Object类型的数组

public <T> T[] toArray(T[] a) {
    if (a.length < size)
        // Make a new array of a's runtime type, but my contents:
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

将list转化为传入类型的数组，当传入的数组长度小于链表数据长度时候，会返回一个新的数组，a不发生改变，当传入的数组长度大于等于链表数据长度时候，会直接将数据拷贝到a中并返回a。

System.arraycopy和Arrays.copyOf的区别：

System.arraycopy()需要目标数组，将原数组拷贝到你自己定义的数组里，而且可以选择拷贝的起点和长度以及放入新数组中的位置
Arrays.copyOf()是系统自动在内部新建一个数组，调用arraycopy()将original内容复制到copy中去，并且长度为newLength。返回copy; 即将原数组拷贝到一个长度为newLength的新数组中，并返回该数组。

Array.copyOf()可以看作是受限的System.arraycopy(),它主要是用来将原数组全部拷贝到一个新长度的数组，适用于数组扩容。

get(int index)

public E get(int index) {
    Objects.checkIndex(index, size); //判断index 是否越界
    return elementData(index);

set(int index, E element)

public E set(int index, E element) {
    Objects.checkIndex(index, size);
    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

Set 方法将index位置的对象设置为传入的对象，并且返回原来的对象

add(E e)

public boolean add(E e) {
    modCount++;//增加修改次数
    add(e, elementData, size);
    return true;
}

private void add(E e, Object[] elementData, int s) {
    if (s == elementData.length)
        elementData = grow(); //数组空间满了 进行扩容
    elementData[s] = e;
    size = s + 1;
}

扩容函数如下：

private Object[] grow(int minCapacity) {
    int oldCapacity = elementData.length;
    if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        int newCapacity = ArraysSupport.newLength(oldCapacity,
                minCapacity - oldCapacity, /* minimum growth */
                oldCapacity >> 1           /* preferred growth */);
        return elementData = Arrays.copyOf(elementData, newCapacity);
    } else {
        return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
    }
}

remove(int index)

public E remove(int index) {
    Objects.checkIndex(index, size);//判断是否越界
    final Object[] es = elementData;

    @SuppressWarnings("unchecked") E oldValue = (E) es[index];
    fastRemove(es, index);
    return oldValue;

private void fastRemove(Object[] es, int i) {
    modCount++;
    final int newSize;
    if ((newSize = size - 1) > i)
        System.arraycopy(es, i + 1, es, i, newSize - i);//把i+1后的元素全部向前覆盖一个位置
    es[size = newSize] = null;
}

size()

public int size() {
    return size;
}

获得List的长度

isEmpty()

public boolean isEmpty() {
    return size == 0;
}

判断List是否为空

trimToSize()

public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0)
          ? EMPTY_ELEMENTDATA
          : Arrays.copyOf(elementData, size);
    }
}

把数组长度改变为当前实际存在数据的大小。

ArrayList遍历

private static void method04(ArrayList<Integer> arrayList) {
    arrayList.forEach((i)->{
        System.out.println(i);
    });
}


private static void method03(ArrayList<Integer> arrayList) {
    for (Integer integer : arrayList){
        System.out.println(integer);
    }
}

private static void method02(ArrayList<Integer> arrayList) {

    Iterator<Integer> iterator = arrayList.iterator();
    while (iterator.hasNext()){
        Integer next = iterator.next();
        System.out.println(next);
    }
}

private static void method01(ArrayList<Integer> arrayList) {
    for(int i = 0; i < arrayList.size(); i++){
        System.out.println(arrayList.get(i));
    }
}

漠翊歌

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ArrayList源码分析

ArrayListArrayList简介ArrayList就是动态数组，是Array的复杂版本。List 接口的大小可变数组的实现，位于API文档的java.util.ArrayList。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector 类，除了此类是不同步的）。A...
复制链接

扫一扫

专栏目录