ArrayList相关方法介绍及源码分析

目录

• • ArrayList简介：
  • ArrayList 相关方法介绍
    • 代码表示
    • 相关方法源码分析

ArrayList简介：

java.util.ArrayList 是咱们最经常使用的一个类，ArrayList 底层是动态数组，读者能够把它理解为数组的实现

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

}

如上代码咱们能够看到 ArrayList 继承了 AbstractList() 抽象类，并实现了 List, RandomAccess, Cloneable, Serializable 接口

AbstractList :

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {}

能够看到AbstractList 继承了 AbstractCollection 接口, 并实现了List 接口

AbstractCollection :

public abstract class AbstractCollection<E> implements Collection<E> {}

AbstractCollection 是一个抽象类，实现了Collection 接口，并提供了某些方法的具体实现。

Collection：

Collection 是一个顶级接口，是不少集合类的顶级接口，继承了Iterable ，支持轻量级遍历其中元素

public interface Collection<E> extends Iterable<E> {}

List :

ArrayList 实现了List接口，List 也是一个和Collection 媲美的顶级接口，继承了Collection 接口

public interface List<E> extends Collection<E> {}

它是许多集合类的父类,

eg:

List list = new ArrayList();
List list2 = new LinkedList();

RandomAccess

RandomAccess 也是一个顶级接口，实现了此接口的类支持随机访问

Cloneable

Cloneable 接口是一个顶级接口，实现了此接口的类支持浅拷贝

Serializable

实现此接口的类支持序列化的功能

类之间的继承关系如图

ArrayList 相关方法介绍

trimToSize()

代码表示

实践才是检验真理最好的方式：

import java.util.*;

/**
 * 详述ArrayList 基本用法
 */
public class ArrayListTest {

    private static class SortList implements Comparator<String> {

        @Override
        public int compare(String o1, String o2) {
            Integer i1 = Integer.valueOf(o1);
            Integer i2 = Integer.valueOf(o2);
            if(i1 < i2){
                return -1;
            }else if(i1 == i2){
                return 0;
            }
            return 1;
        }
    }

    // 使用可变参数，可以接受任意个参数
    public Set<String> putSet(String...args){
        Set<String> sets = new HashSet<>();
        for(String str : args){
            sets.add(str);
        }
        return sets;
    }

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("111");
        list.add("222");

        // 在指定位置添加元素
        list.add(0,"333");
        System.out.println(list);

        // 进行外部排序
        list.sort(new SortList());
        System.out.println(list);

        list.clear();
        System.out.println(list.size());

        // 使用addAll添加元素
        ArrayListTest at = new ArrayListTest();
        list.addAll(at.putSet("1","2","3"));

        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
            // 移除全部元素
            it.remove();
        }

        System.out.println("list是否为空 ? " + list.isEmpty());

        list.add("111");
        // 在指定位置添加一个set集合
        list.addAll(0,at.putSet("1","2","3"));
        System.out.println(list);

        // 是否包含指定元素
        if(list.contains("111")) {
            list.remove("111");
        }
        System.out.println(list);

        System.out.println(list.indexOf("1"));
        // 注意subList()这个方法是左开右闭区间，Java 中不少都是相似的
        System.out.println(list.subList(0,3));

        // 扩大list的容量
        list.ensureCapacity(10);
        // 去掉list空闲的容量
        list.trimToSize();

        // 获取某个特定的元素
        System.out.println(list.get(1));

        // 建立一个list的双向链表
        ListIterator<String> listIterator = list.listIterator();
        while(listIterator.hasNext()){
            // 移到list的末端
            System.out.println(listIterator.next());
        }
        System.out.println("--------------------------");
        while (listIterator.hasPrevious()){
            // 移到list的首端
            System.out.println(listIterator.previous());
        }

        // 把list转换为数组
        Object[] objects = list.toArray();
        System.out.println("objects = " + objects);

    }
}

相关方法源码分析

源码的具体分析是根据上面的代码示例得出，由于只看源码好像并不能看懂什么，须要根据具体的代码一步一步debug 进行跟踪

add()方法

解释：添加指定的元素在list的末尾

/**
     * 添加指定的元素在list的末尾
     */
    // 假设第一次添加的是 "111"
    public boolean add(E e) {
        // size是0，因此size + 1 传的是1
        ensureCapacityInternal(size + 1); 
        // elementData[0] = 111 , size++ = 1
        elementData[size++] = e;
        return true;
    }
    
    // 此方法用来进行list 扩容
    private void ensureCapacityInternal(int minCapacity) {
        // 此时elementData 并无存储元素，为0
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            // 则minCapacity 取默认初始容量和minCapacity 的最大值 (取1 和 10的最大值)
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        // 确保清晰的容量(最小容量与List元素的比较)
        ensureExplicitCapacity(minCapacity);
    }

    // 在list中添加了一个元素，因此会致使结构化的修改，"结构化的修改"见下面解释
    // 此时minCapacity 为 10
    private void ensureExplicitCapacity(int minCapacity) {
        // 次数 + 1 
        // 这个列表被修改结构的次数(好比添加和删除元素)会用modCount表示. 结构化修改是指的是可以
        // 改变列表容量的操做，或者其余方式改变它，致使遍历的过程会产生错误的结果。
        modCount++;

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

    /**
     * 增长容量确保容纳足够的元素
     * 
     * 参数传过来的是10
     */
    private void grow(int minCapacity) {
        // overflow-conscious code
        // oldCapacity = 0
        int oldCapacity = elementData.length;
        // newCapacity = 0
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // newCapacity - minCapacity = -10
        if (newCapacity - minCapacity < 0)
            // newCapacity = 10
            newCapacity = minCapacity;
        
        // MAX_ARRAY_SIZE = 数组分配的最大空间 = 2147483639
        // 通常状况下不会比 MAX_ARRAY_SIZE 还要大
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        // 底层仍是用的System.arraycopy(), 关于System.arrayCopy() 读者能够参考个人另外一篇博客
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

相关经常使用的基本数据类型包装类的值： Java基本数据类型包装类经常使用的值

add(int index, E element)

解释：在list中指定位置插入指定的元素，若是当前位置有元素，就移动当前位置的元素

/**
     * 在list中指定位置插入指定的元素，若是当前位置有元素，就移动当前位置的元素
     * 要插入的位置的后面全部元素的位置向前 + 1
     *
     */
    public void add(int index, E element) {
        // 检查 0 这个位置是否越界
        rangeCheckForAdd(index);

        // 再也不赘述，读者能够自行debug
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        // 由于从当前位置插入元素，因此当前位置及后面的元素都会向后移动
        // 使用System.arraycopy 进行数组复制
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        // 为当前元素赋值
        elementData[index] = element;
        size++;
    }

    /**
     * 为add 和 addall 提供的范围检查, 不符合条件，抛出IndexOutOfBoundsException 异常
     */
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

Clear()

解释：移除列表中的全部元素

/**
     * 移除list列表中全部的元素，列表会变为空列表在调用此方法后
     *
     */
    public void clear() {
        // 修改次数 + 1
        modCount++;

        // clear to let GC do its work
        // 把每一个变量置空，GC进行回收
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        // 列表的长度变为0
        size = 0;
    }

这个方法的源码理解起来仍是比较简单的

addAll(Collection<? extends E> c)

解释： 把一个Collection集合添加到list末尾

/**
     * 把一个Collection集合(实现了此接口的类)添加到list的末尾，按着迭代的顺序返回。
     * 此操做的行为是若是在此方法调用的过程当中修改了Collection(实现了此接口的类)的话，
     * 那么这个操做不会成功
     */
    public boolean addAll(Collection<? extends E> c) {
        // 把Collection 转换为 Object[] 数组
        Object[] a = c.toArray();
        // 数组中有三个元素
        int numNew = a.length;
        // 由于上面的操做调用了一次list.clear()方法，因此list.size = 0
        ensureCapacityInternal(size + numNew);  // Increments modCount
        // 一句话解释： 把a 数组中0个位置的元素 复制到 elementData数组中 第size个位置的元素，
        // 复制的长度为 numNew
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

    // toArray()方法： 

    /**
     * 返回一个数组，包含了全部的元素(从第一个元素到最后一个元素)
     * 返回的数组是很"安全的"由于列表没有引用能够维持(换句话说，这个方法必须分配一个新数组)
     * 调用者所以能够任意修改返回的数组
     * 这个方法是数组 和 集合之间的桥梁
     */
    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

iterator(), hasNext(), next()

解释：Iterator方法用于遍历list中的元素，返回一个Itr 的内部类，hasNext()方法用于判断list 中是否还有未遍历的元素，next()方法用于获取下一个元素

/**
     * 以适当的顺序返回此列表中元素的迭代器
     * 返回的iterator 支持fail-fast 机制
     */
    public Iterator<E> iterator() {
        return new Itr();
    }

    /**
     * Itr 是一个内部类，实现了Iterator接口，可支持快速遍历
     */
    private class Itr implements Iterator<E> {
        // 下一个元素返回的下标
        int cursor;       // index of next element to return
        // 最后一个元素返回的下标， 若是没有返回-1
        int lastRet = -1; // index of last element returned; -1 if no such
        // expectedModCount 指望的修改次数，默认是和modCount(修改次数相同，用于iterator判断fail-fast机制)
        int expectedModCount = modCount;

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            // 判断遍历的过程当中是否触发fail-fast机制
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        public void remove() {
            // 若是lastRet < 0，说明 lastRet 没有被改变，
            // 因此应该是没有调用next()就调用了remove()
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        @Override
        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer<? super E> consumer) {
            Objects.requireNonNull(consumer);
            final int size = ArrayList.this.size;
            int i = cursor;
            if (i >= size) {
                return;
            }
            final Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
            while (i != size && modCount == expectedModCount) {
                consumer.accept((E) elementData[i++]);
            }
            cursor = i;
            lastRet = i - 1;
            checkForComodification();
        }

        // 若是修改次数不知足预期修改次数的话，抛出异常
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

addAll(int index,Collection<? extends E> c)

解释：在某个位置添加Collection集合

/**
     * 在指定的位置下标插入一个Collection集合
     */
    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)
            // 第一次数组复制，从elementData中的index位置开始，复制到index + numNew位置上，复制numMoved个元素
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);

        // 第二次数组复制,从a 数组中的第0个位置开始，复制到elementData第index位置上你，复制numNew个元素
        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }

contains(Object o)

解释：判断list列表是否包含某个元素

/**
     * 返回true，若是这个列表包含指定的元素
     * 更进一步来讲，当且仅当list包含至少一个元素的状况下，返回true
     */
    public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

    /**
     * 返回列表中第一次出现指定元素的下标值，若是不包含指定元素，则返回-1。
     * 更进一步来讲，返回最小的索引当(o == null ? get(i) == null : o.equals(get(i)))的时候
     * 或者返回-1 没有此下标值
     *
     */
    public int indexOf(Object o) {
        // 若是o这个对象等于null，就判断elementData中是否有空元素，若是有，返回
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            // 若是不为null，返回这个值的存储位置
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

remove(Object o)

解释：移除list中的某个元素

/**
     * 若是存在，则移除list中某个第一次出现的元素。若是这个list不包含指定元素，就不会改变
     *
     */
    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;
    }

    /*
     * 私有的移除方法，而且不返回被移除的元素,这个源码比较简单
     */
    private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }

indexOf(Object o)

解释：检索某个元素的位置

此源码和contains(Object o)中调用的indexOf 源码相同

subList(int fromIndex, int toIndex)

解释：返回list列表的一个片断

/**
     * 返回list列表中的一部分视图(至关于list片断),[fromIndex,toIndex)，若是fromIndex 和
     * toIndex 相同的话，代表这个list为空，这个返回的list被返回，因此在list中并无结构的改变
     * 这个返回的list片断支持全部的list操做
     */
    public List<E> subList(int fromIndex, int toIndex) {
        // subList 范围检查
        subListRangeCheck(fromIndex, toIndex, size);
        return new SubList(this, 0, fromIndex, toIndex);
    }

    static void subListRangeCheck(int fromIndex, int toIndex, int size) {
        if (fromIndex < 0)
            throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
        if (toIndex > size)
            throw new IndexOutOfBoundsException("toIndex = " + toIndex);
        if (fromIndex > toIndex)
            throw new IllegalArgumentException("fromIndex(" + fromIndex +
                                               ") > toIndex(" + toIndex + ")");
    }

    private class SubList extends AbstractList<E> implements RandomAccess {
        
        private final AbstractList<E> parent;
        private final int parentOffset;
        private final int offset;
        int size;

        SubList(AbstractList<E> parent,
                int offset, int fromIndex, int toIndex) {
            this.parent = parent;
            this.parentOffset = fromIndex;
            this.offset = offset + fromIndex;
            this.size = toIndex - fromIndex;
            this.modCount = ArrayList.this.modCount;
        }
    }

ensureCapacity(int minCapacity)

解释：扩大list的容量

/**
     * 增长ArrayList实例的容量，若是必须的话，确保它能持有最小容量的元素
     */
    public void ensureCapacity(int minCapacity) {
        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;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }

trimToSize()

解释：去掉list空闲的容量

/**
     * 去掉ArrayList中的多余空间
     */
    public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

sort(Comparator<? super E> c)

sort 方法接收一个自定义比较器进行自定义比较，下面来看具体的源码

@Override
    @SuppressWarnings("unchecked")
    public void sort(Comparator<? super E> c) {
        // 根据上面代码分析，此时modCounnt 已经被修改过三次(添加了三个元素)
        final int expectedModCount = modCount;
        // 数组外部排序
        Arrays.sort((E[]) elementData, 0, size, c);
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }