ArrayList 冷门方法

以下代码片都是 jdk1.8 ArrayList中的官方代码

/**
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
     *
     * @param c the collection whose elements are to be placed into this list
     * @throws NullPointerException if the specified collection is null
     */
    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的构造方法，用得比较少，至少我用得比较少。参数是Collection的实现类都行，

　　   由此我想到了一个好玩的东西，如果要将两个集合想加，那么可以试试这个方法，虽然官方提供了

        public boolean addAll(int index, Collection<? extends E> c) 和public boolean addAll(Collection<? extends E> c) 这两个方法。

 /**
     * Trims the capacity of this <tt>ArrayList</tt> instance to be the
     * list's current size.  An application can use this operation to minimize
     * the storage of an <tt>ArrayList</tt> instance.
     */
    public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

 解读：这是个好东西。
 　　　ArrayList所说没有用的值并不是null，而是ArrayList每次容量不够用时申请的存储空间会稍稍多一些，1.5倍+1，
 　　  这样就会出现当size() = 1000的时候，ArrayList已经申请了1200空间的情况  此时trimToSize
 　　  的作用只是去掉预留元素位置，就是删除多余的200,官方指导的是可以用来优化存储

  /**
     * Increases the capacity of this <tt>ArrayList</tt> instance, if
     * necessary, to ensure that it can hold at least the number of elements
     * specified by the minimum capacity argument.
     *
     * @param   minCapacity   the desired minimum capacity
     */
    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);
        }
    }

 解读：这更是个好东西。因为官方都建议使用了，

　　　 * <p>An application can increase the capacity of an <tt>ArrayList</tt> instance
　　　 * before adding a large number of elements using the <tt>ensureCapacity</tt>
　　　 * operation.  This may reduce the amount of incremental reallocation.

　　　简单来说就是业务情况预先设置集合的容量，这样能够大大提高初始化速度。可能有人说直接指定容量呢，实际情况中你哪会知道容量会多大，就算知道，那效率更是不敢看

　　　下面是测试代码，运行看看就知道了

package sourceCode.ArrayList;

import java.util.ArrayList;

/**
 * ArrayList.ensureCapacity(N)性能测试
 *
 */
public class entureCapacityTest {

	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static void main(String[] args) {

		final int N = 100000000;
		Object obj = new Object();

		// 1.没用调用ensureCapacity()方法初始化ArrayList对象
		ArrayList list = new ArrayList();
		long startTime = System.currentTimeMillis();
		for (int i = 0; i <= N; i++) {
			list.add(obj);
		}
		long endTime = System.currentTimeMillis();
		System.out.println("没有调用ensureCapacity()方法所用时间：" + (endTime - startTime) + "ms");

		// 2.调用ensureCapacity()方法初始化ArrayList对象
		list = new ArrayList();
		startTime = System.currentTimeMillis();
		// 预先设置list的大小
		list.ensureCapacity(N);
		for (int i = 0; i <= N; i++) {
			list.add(obj);
		}
		endTime = System.currentTimeMillis();
		System.out.println("调用ensureCapacity()方法所用时间：" + (endTime - startTime) + "ms");

		// 3.直接指定容量
		list = new ArrayList(N);
		startTime = System.currentTimeMillis();
		for (int i = 0; i <= N; i++) {
			list.add(obj);
		}
		endTime = System.currentTimeMillis();
		System.out.println("直接设置容量所用时间：" + (endTime - startTime) + "ms");

	}
}

  /**
     * Retains only the elements in this list that are contained in the
     * specified collection.  In other words, removes from this list all
     * of its elements that are not contained in the specified collection.
     *
     * @param c collection containing elements to be retained in this list
     * @return {@code true} if this list changed as a result of the call
     * @throws ClassCastException if the class of an element of this list
     *         is incompatible with the specified collection
     * (<a href="Collection.html#optional-restrictions">optional</a>)
     * @throws NullPointerException if this list contains a null element and the
     *         specified collection does not permit null elements
     * (<a href="Collection.html#optional-restrictions">optional</a>),
     *         or if the specified collection is null
     * @see Collection#contains(Object)
     */
    public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, true);
    }

 解读：取两个集合的交集