集合---ArrayList

ArrayList

源码探究（JDK1.7）

• 存在包：
   集合存在于java.util包路径下 。
• 继承关系：

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

 ArrayList继承AbstractList，父类中对部分接口进行实现，实现了List接口提供的方法，Serializable说明该类能够被序列化 ，Cloneable能够被克隆，可以实现随机访问。

• 底层数据结构：
   ArrayList底层数据结构:========>数组。

ArrayList和数组的区别？？

1.初始化大小：ArrayList可以不用指定大小，数组必须要指定大小；
2.存储数据类型：ArrayList只能存储引用数据类型，数组可以存储引用数据类型和基本类型。

• 基本属性：

private static final int DEFAULT_CAPACITY = 10;		//默认容量大小
private static final Object[] EMPTY_ELEMENTDATA = {};	//默认数组大小
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() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
    }
  
//有参构造，通过集合来创建新的集合
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);
    } 

• 增长方式：
   按照原数组的1.5倍进行扩容。

 private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);//1.5倍，<<左移，乘以2的n次方、>>右移，除以2的n次方
        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);
    }

• CRUD方法研究（增删改查）：
  （1）add()添加元素：
  注意首先需要进行扩容考虑，如果要扩容（size+1 > table.length），按照1.5倍进行扩容，将元素插入数组尾部，并对计数size+1，size表示有效元素数据个数。

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}
private void ensureCapacityInternal(int minCapacity) {
    if (elementData == EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}
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);//除以2的1次方，即0.5
    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);
}    

（2）remove()删除元素：
注意先找到元素存储位置（null和非null的对象判断相等的不同），数组移动
注意：相同元素存在的情况下，只需找到从0号开始第一次出现的元素。

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
}  

（3）get()获取元素：

public E get(int index) {
    rangeCheck(index);
    return elementData(index);
}
//合法性校验：判断要查找的索引位置是否合法
 private void rangeCheck(int index) {
     if (index < 0 || index >= this.size)
         throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
 } 
E elementData(int index) {
    return (E) elementData[index];
} 

• ArrayList常用方法介绍：

1. int size()；集合中存储元素的个数
2. boolean isEmpty()；判断当前集合是否为空，返回值为boolean类型；false：集合不为空 true：集合为空
3. boolean contains(Object o)；判断当前集合是否包含该Object对象；
4. Iterator<E> iterator()；迭代器，返回iterator实例
5. Object[] toArray()；将集合转换为数组
6. <T> T[] toArray(T[],o)；将集合转化为数组
7. boolean remove(Object o)；删除元素
8. boolean add(E e)；添加元素
9. boolean containsAll(Collection<?> o);判断入参集合是否属于当前集合
10. boolean addAll(Collection<? extends E> c)；对该集合添加子集合形成新的集合
11. boolean addAll(int index,Collection<? extends  E> c)；在指定的位置添加子集合
12. void clear()； 将集合清除掉
13. boolean equals(Object o)；判断是否相等
14. E get(int index)；通过指定位置来获取元素
15. int indexof(Object o)；判断当前元素在集合中的位置(从集合头部往后查找)
16. int lastIndexOf(Object o)；判断当前元素在集合中的位置(从后往前查找)
17. List<E> subList(int fromIndex, int toIndex) ；查找当前集合的子集（前闭后开）

总结ArrayList特点：

1.重复性：数据可以重复；
2.有序性：可以保证数据插入有序；
3.NULL值：可以存储null值；

练习：求两个集合的交集，差集，并集。

public class ArraylistDemo {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        arrayList.add(10);
        arrayList.add(13);
        arrayList.add(2);
        arrayList.add(7);//数据插入有序
        arrayList.add(2);//元素可重复
        arrayList.add(null);//可以存储null值 [10, 13, 2, 7, 2, null]

        ArrayList<Integer> arrayList1 = new ArrayList<Integer>();
        arrayList1.add(10);
        arrayList1.add(3);
        arrayList1.add(6);
        arrayList1.add(5);
        arrayList1.add(7);
        
        //for循环实现两个集合并集
        for (int i = 0; i < arrayList.size() ; i++) {
            arrayList1.add(arrayList.get(i));
        }

        for (int i = 0; i < arrayList1.size(); i++) {
            System.out.print(arrayList1.get(i)+" ");
        }
        System.out.println();//10 3 6 5 7 10 13 2 7 2 null 
        //ArrayList 方法实现并集addAll()
        arrayList.addAll(arrayList1);
        System.out.println(arrayList);//10 3 6 5 7 10 13 2 7 2 null 

        //实现交集 contains()
        for (int i = 0; i < arrayList1.size() ; i++) {
            if (arrayList.contains(arrayList1.get(i))){
                System.out.print(arrayList1.get(i)+" ");//10 7
            }
        }
        System.out.println();
        //实现差集 removeAll()
        arrayList.removeAll(arrayList1);
        for (int i = 0; i < arrayList.size(); i++) {
            System.out.print(arrayList.get(i) + " ");//13 2 2 null 
        }
    }
}