Java集合框架详解-优快云博客

接口

Collection 容器类根接口定义了存取一组对象的方法

int size()

boolean isEmpty()

boolean contains(Object o)

Iterator<E> iterator

Boolean add(E e)

boolean remove(Object o)

void clear()

Set 无序不重复定义了存储方式

接口中的方法基本与collection一致

List 有序可重复定义了存储方式

List是有序的，所以加入了许多可根据索引进行的操作的方法

get (int ) 返回该索引位置对象

set(int，E ) 将元素放入该位置，会覆盖当前位置的对象

add(int , E) 增加元素到该位置，之后的元素依次向后移动一位

remove（int）移除该位置对象

Map 键值对定义了键值映射方法

实现类ArrayList

底层是数组实现 所以特性很明显查询效率高，增删效率低不是线程安全的

贴上部分源码（基于JDK1.8）

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892189L;

    /**
     * 默认初始化容量
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 用于空实例的共享空数组实例
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 用于缺省大小的空实例的共享空数组实例。我们将其与EMPTY_ELEMENTDATA区别开来，以便知道当添               
     * 加第一个元素时扩容多少
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * 简单来说就是数据存放在这个object数组中
     * 任何空的arrayList当第一个元素插入时，如果elementData ==     
     * DEFAULTCAPACITY_EMPTY_ELEMENTDATA  此时扩容到DEFAULT_CAPACITY(10)
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     *该list中存放的元素的个数，不是容量
     */
    private int size;

    /**
     * 构造函数， 构造时指定参数大小容量
     * 如果指定参数大小为0  即构造一个容量为0的arraylist
     * 此时elementData = 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);
        }
    }

    /**
     * 构造一个空list，elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
}

当我们插入第一个元素时扩容

插入第一个元素时  调用的部分函数
public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

 private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

 private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

由上述代码分析可知

如果使用无参构造定义空数组 elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA

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

使用有参构造定义空数组即 new ArrayList(0) 可知 elementData = 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);
}
}

通过最后一个函数可知elementData = EMPTY_ELEMENTDATA 时返回的是 DEFAULT_CAPACITY 即扩容到10 还有些源码有兴趣的可以自己去看看

所以在JDK1.8中使用new ArrayList()时，插入第一个元素时才会扩容到10

而在JDK1.6中

public ArrayList() {
    this(10);
    }

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

通过源码可以知道初始容量即为10