集合Collection学习（随时更新）

一、三种遍历方法

List list=new ArrayList();
//List list=new LinkedList();
//List list=new Vector();


list.add("...");
list.add("...");
list.add("...");
//1.迭代器
Iterator iterator=list.iterator();
while(iterator.hasNaxt){
    Object obj=iterator.next();
    System.out.println(obj);
}

//2.增强for
for(Object obj:list){
    System.out.println("list"+ obj);
}

//普通for循环
for(int i=0;i<list.size();i++){
    System.out.println(" "+ list.get(i));
}

二、ArrayList

底层是由数组来实现数据存储的，ArrayList基本等同于Vector，ArrayList是线程不安全的（执行效率高），多线程下不建议使用ArrayList，多线程建议使用Vector；

ArrayList线程不安全的原因：（看源码）没有synchronized关键字来修饰

public boolean add(E e){
    ensureCapacityInternal(size+1);
    elementData[size++] = e;
    return true;
}

ArrayList底层结构和源码分析：（transient:表示该属性不会被序列化）

1)ArrayList中维护一个Object类型的数组elementData。

2)当创建ArrayList对象时，如果使用的是无参构造器，，则初始elementData容量为0，第1次添加，则扩容elementData为10，如需要再次扩容，则扩容elementData为1.5倍。

3)如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，则直接扩容elementData为1.5倍。

源码一：

创建了一个空的emementData数组={}

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

执行添加list.add 

1.先确定是否要扩容
2.然后在执行赋值的操作
public boolean add(E e){
    ensureCapacityInternal(size+1);//确保容量足够
    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;
    }

//modCount记录当前集合被修改的次数
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

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

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }