java集合之ArrayList详解

ArrayList 是一个数组队列，相当于动态数组。

与Java中的数组相比，它的容量能动态增长。

它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。

一、所在包

集合存在于java.util包路径下

二、特点

• 重复性：数据可以重复
• null值：可以有null值存在
• 有序性：能保证插入的数据有序

三、常用方法介绍

int size()： // 集合中存储元素的个数

boolean isEmpty()  //判断当前集合是否为空，返回值是Boolean类型
//false：集合不为空   true:集合为空

boolean contains(Object o) //判断当前集合是否包含该Object对象

Iterator<E> iterator() //迭代器，返回iterator实例

Object[] toArray() //将集合转化为数组

<T> T[] toArray(T[] a) //将集合转化为数组

 boolean add(E e) //添加元素
 
 boolean remove(Object o)  //删除元素
 
 boolean containsAll(Collection<?> c) //判断入参集合是否属于当前集合
 
 boolean addAll(Collection<? extends E> c) // 对该集合添加子集合形成新的集合
 
 boolean addAll(int index, Collection<? extends E> c) //在指定的位置添加子集合
 
void clear() //将集合清除掉

boolean equals(Object o) //判断是否相等

E get(int index) //通过指定位置来获取元素

int indexOf(Object o) //判断当前元素在集合中的位置（从集合头部往后查找）

int lastIndexOf(Object o) //判断当前元素在集合中的位置(从集合尾部往前查找)

List<E> subList(int fromIndex, int toIndex) //找当前集合的子集

boolean retainAll(Collection<?> c) //移除此 collection 中未包含在指定 collection 中的所有元素。
//假设有两个集合A,B，retainAll相当于对A，B做交集，最终结果存在A中，B不要
//返回值表示的是A是否发生改变
           

四、继承关系

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
        
ArrayList继承AbstractList，父类中对部分接口进行实现
实现了List接口提供的方法，Serializable说明该类能够被序列化 ，能够被克隆、序列化
           

五、底层数据结构

ArrayList底层数据结构是————数组

六、基本属性

//默认容量大小
private static final int DEFAULT_CAPACITY = 10;
//默认数组大小
private static final Object[] EMPTY_ELEMENTDATA = {};
//存储元素的数组
private transient Object[] elementData;
//集合存储元素的个数
private int size;
           

七、构造函数

1.有参构造，指定集合初始化大小

public ArrayList(int initialCapacity) {
    super();
    //指定大小不合法，则直接抛出异常
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity]; //初始化数组大小
}
           

2.无参构造

public ArrayList() {
    super();
    this.elementData = EMPTY_ELEMENTDATA;
}
           

3.有参构造，通过集合来创建新的集合

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);
}
           

八、CRUD方法研究

• add()：添加元素

  首先需要进行扩容考虑，如果要扩容（size+1 > table.lengrh），按照1.5倍进行扩容

  将元素插入数组尾部，并对计数size+1

源码分析

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);  //1.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);  //将新数组复制到elementData中
}    
           

• remove()：删除元素
  • 先找到元素存储位置

  • 然后判断

    注意： null和非null的对象判断相等的不同：一个是== ，一个是equals

  • 数组移动

    注意： 相同元素存在的情况下，只需找到从0号开始第一次出现的元素删除

源码

public boolean remove(Object o) {
    if (o == null) { //如果删除的元素为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])) { //如果不为null，比较用equals
                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的index+1处开始复制，放置到elementData的index开始numMoved长度
    elementData[--size] = null; 
}  
           

• 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];
}          
           

数组和集合的区别

1. 长度区别

   数组的长度固定

   集合长度可变

2. 内容不同

   数组存储的是同一种类型的元素

   集合可以存储不同类型的元素

3. 元素的数据类型不同

   数组可以存储基本数据类型，也可以存储引用数据类型数据

   集合只能存储引用类型