Java基础知识：Java集合——List接口之ArrayList_arrlist建立通讯录-优快云博客

本文深入解析Java集合框架，包括Collection接口的主要子接口List、Set、Queue及其实现类，如ArrayList、LinkedList、HashSet等。详细对比ArrayList与LinkedList在数据结构、性能特点及应用场景上的区别。

Java集合框架结构图

通过以上集合框架图我们可以发现，Collection接口主要有List接口，set接口，Queue接口，而list（元素按进入先后有序保存，可重复）下面经常使用的有：

LinkedList 接口实现类，链表，插入删除，没有同步，线程不安全
ArrayList 接口实现类，数组，随机访问，没有同步，线程不安全
Vector 接口实现类数组，同步，线程安全
Stack 是Vector类的实现类
而set（不可重复，并做内部排序）接口下面有：

HashSet 使用hash表（数组）存储元素，底层数据结构采用哈希表实现，元素无序且元素不可重复，线程不安全，效率高，可以存储null元素，元素的唯一性是靠所存储元素类型是否重写hashCode()和equals()方法来保证的，如果没有重写这两个方法，则无法保证元素的唯一性。
LinkedHashSet 链表维护元素的插入次序，底层数据结构采用链表和哈希表共同实现，链表保证了元素的顺序与存储顺序一致，哈希表保证了元素的唯一性。线程不安全，效率高。
TreeSet 底层实现为二叉树，元素排好序

ArrayList详解：

首先看下ArrayList的源码：

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

可以看出，ArrayList继承自AbstractList,实现了众多接口，ArrayList底层基于数组实现容量大小动态变化。所谓的动态变化就是指：当容量不够时，会重新申请一个数组，然后将现有的数组全部拷贝过去，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素，查询速度快，但是增删元素慢，因为在增删元素时需要前后的元素进行移动

允许 null 的存在，还实现了 RandomAccess、Cloneable、Serializable 接口，所以ArrayList 是支持快速访问、复制、序列化的。

它继承于AbstractList，实现了List,RandomAccess[随机访问],Cloneable[可克隆], java.io.Serializable[序列化]这些接口,
ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能
ArrayList 实现了RandmoAccess接口，即提供了随机访问功能。
ArrayList 实现了Cloneable接口，即覆盖了函数clone()，能被克隆
ArrayList 实现java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输

在多线程时使用：

如果多个线程同时访问实例，并且至少有一个线程在结构上修改列表，则必须在外部进行同步。（结构修改是添加或删除一个或多个元素的任何操作，或明确调整后台数组的大小;仅设置元素的值不是结构修改。）这通常是通过在一些自然地封装了列表。如果没有这样的对象存在，列表应该使用Collections.synchronizedList方法“包装”。这最好在创建时完成，以防止意外的不同步访问列表： List list = Collections.synchronizedList(new Arraylist(...));(源自JDK1.8中的方法)
和Vector不同，ArrayList中的操作不是线程安全的。所以，建议在单线程中才使用ArrayList，而在多线程中可以选择Vector或者CopyOnWriteArrayList。

RandomAccess的作用：RandomAccess是 List 实现所使用的标记接口，用来表明其支持快速（通常是固定时间）随机访问， 简单来说就是底层是数组实现的集合。LinkedList并没有实现该接口，所以不支持随机访问。

Cloneable接口的作用：它允许在堆中克隆出一块和原对象一样的对象，并将这个对象的地址赋予新的引用，这样显然新引用的操作，不会影响到原对象。

ArrayList的源码解析：

    private static final long serialVersionUID = 8683452581122892189L;

    private transient Object[] elementData;

    private int size;

    public ArrayList(int initialCapacity) {
	super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
	    this.elementData = new Object[initialCapacity];
    }

    public ArrayList() {
	    this(10);
    }

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

由以上可以看出，ArrayList初始化时会初始化一个默认容量为10的空的ArrayList,即便是调用不是空的构造方法，也会先调用空的构造方法创建初始容量为10的空的ArrayList.

扩容时观察源码可知：会扩容为原来的1.5倍

 public void ensureCapacity(int minCapacity) {
	modCount++;
	int oldCapacity = elementData.length;
	if (minCapacity > oldCapacity) {
	    Object oldData[] = elementData;
	    int newCapacity = (oldCapacity * 3)/2 + 1;
    	    if (newCapacity < minCapacity)
		newCapacity = minCapacity;
            // minCapacity is usually close to size, so this is a win:
            elementData = Arrays.copyOf(elementData, newCapacity);
	}
   }

ArrayList和LinkedList的区别

从线程安全的方面来说，这两个都不能线程安全的
ArrayList 的底层使用的是数组，而LinkedList底层是双向链表数据结构。
ArrayList是底层是数组，可以快速随机访问，通过坐标就可以快速定位，LinkedList 底层数据结构是双向链表，只能遍历一个个查找
ArrayList 是数组结构，如果添加/删除的是第i个数据，那么数组中的i之后的所有数据都会向前后移动。而链表结构则不会。所以LinkedList做添加删除快速。
ArrayList会在尾部预留一定的容量空间，因为如果做添加操作的时候，超出当前数组最大值时，会添加50%的空间，LinkedList的空间花费则体现在它的每一个元素都需要消耗比ArrayList更多的空间（因为要存放直接后继和直接前驱以及数据
ArrayList容量不够时，由于底层采用的是数组，所以当容量不够时，采用的是动态数组扩容，动态数组的意思就是指底层的数组大小并不是固定的，而是根据添加的元素大小进行一个判断，不够的话就动态扩容方法是，重新创建一个容量比原有数组容量更大的数组，然后将原有数组拷贝至新数组。
LinkedList没有固定容量，不需要扩容；
一般ArrayList优先使用普通for循环。而LinkedList优先选择iterator遍历（foreach遍历底层也是通过iterator实现的），大size的数据，千万不要使用普通for循环

ArrayList常用方法

`boolean`	`add(E e)` 将指定的元素追加到此列表的末尾。
`void`	`add(int index, E element)` 在此列表中的指定位置插入指定的元素。
`boolean`	`addAll(Collection<? extends E> c)` 按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。
`boolean`	`addAll(int index, Collection<? extends E> c)` 将指定集合中的所有元素插入到此列表中，从指定的位置开始。
`void`	`clear()` 从列表中删除所有元素。
`Object`	`clone()` 返回此 ArrayList实例的浅拷贝。
`boolean`	`contains(Object o)` 如果此列表包含指定的元素，则返回 true 。
`void`	`ensureCapacity(int minCapacity)` 如果需要，增加此 ArrayList实例的容量，以确保它可以至少保存最小容量参数指定的元素数。
`void`	`forEach(Consumer<? super E> action)` 对 `Iterable`的每个元素执行给定的操作，直到所有元素都被处理或动作引发异常。
`E`	`get(int index)` 返回此列表中指定位置的元素。
`int`	`indexOf(Object o)` 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
`boolean`	`isEmpty()` 如果此列表不包含元素，则返回 true 。
`Iterator<E>`	`iterator()` 以正确的顺序返回该列表中的元素的迭代器。
`int`	`lastIndexOf(Object o)` 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
`ListIterator<E>`	`listIterator()` 返回列表中的列表迭代器（按适当的顺序）。
`ListIterator<E>`	`listIterator(int index)` 从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。
`E`	`remove(int index)` 删除该列表中指定位置的元素。
`boolean`	`remove(Object o)` 从列表中删除指定元素的第一个出现（如果存在）。
`boolean`	`removeAll(Collection<?> c)` 从此列表中删除指定集合中包含的所有元素。
`boolean`	`removeIf(Predicate<? super E> filter)` 删除满足给定谓词的此集合的所有元素。
`protected void`	`removeRange(int fromIndex, int toIndex)` 从这个列表中删除所有索引在 `fromIndex` （含）和 `toIndex`之间的元素。
`void`	`replaceAll(UnaryOperator<E> operator)` 将该列表的每个元素替换为将该运算符应用于该元素的结果。
`boolean`	`retainAll(Collection<?> c)` 仅保留此列表中包含在指定集合中的元素。
`E`	`set(int index, E element)` 用指定的元素替换此列表中指定位置的元素。
`int`	`size()` 返回此列表中的元素数。
`void`	`sort(Comparator<? super E> c)` 使用提供的 `Comparator`对此列表进行排序以比较元素。
`Spliterator<E>`	`spliterator()` 在此列表中的元素上创建late-binding和故障快速 `Spliterator` 。
`List<E>`	`subList(int fromIndex, int toIndex)` 返回此列表中指定的 `fromIndex` （包括）和 `toIndex`之间的独占视图。
`Object[]`	`toArray()` 以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。
`<T> T[]`	`toArray(T[] a)` 以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 返回的数组的运行时类型是指定数组的运行时类型。
`void`	`trimToSize()` 修改这个ArrayList实例的容量是列表的当前大小。