Arraylist使用_添加到arraylist中的数据顺序

Arraylist集合使用

一、 特点：
1、ArrayList可以存放重复数据
2、ArrayList中元素存放和插入顺序一致
3、ArrayList中存放的数据是可以为null
4、ArrayList集合底层采用的是数组来存储数据
二、构造函数：

//无参构造
ArrayList <Integer> list = new ArrayList <>();
//通过指定集合容量大小来实例化
ArrayList <Integer> list1 = new ArrayList <>(100);
//通过Collection集合实例来实例化一个新集合
ArrayList <Integer> list2 = new ArrayList <>(list);

1
2
3
4
5
6
7

三、Arraylist的基本使用
ArrayList底层存储元素是使用数组
数组 elementData.length:表示当前数组容量，最大存储的数据个数 size：实际存放的数据个数
Arraylist的继承关系：
ArrayList继承自AbstractList，AbstractList是抽象类，实现了List结构，它是一个数组队列，提供了相关的添加、删除、修改、遍历等基本功能实现，方法子类对方法复用，如果子类有特有功能可以重写父类的方法
ArrayList实现了List接口，List接口继承自Collection接口，在Collection接口提供的方法基础上，有一些新的方法提供，比如get、set、add等特有方法
ArrayList实现了RandomAccess接口，即提供了随机访问功能，为List提供快速访问的功能
ArrayList实现了Cloneable接口，即包含了函数clone(),能被克隆
ArrayList实现了Serializable接口，意味着ArrayList支持序列化，能通过序列化去传输（IO）
四、Arraylist的方法使用及源码分析
add方法：添加元素

public boolean add(E e) {
        //考虑扩容
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //将数据通过数组坐标插入到数据尾部，并对size+1
        elementData[size++] = e;
        return true;
    }

   private void ensureCapacityInternal(int minCapacity) {
        if (elementData == EMPTY_ELEMENTDATA) {
            //在添加第一个元素时，如果集合是通过无参构造实例时，会进入到if
            //在未指定集合容量时，默认情况下数组初始化大小为10
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        //minCapacity（size+1） > elementData.length,意味着数组空间不足，扩容时机
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

  //扩容点
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        //扩容为原大小的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);//oldCapacity >> 1 => oldCapacity/2
        //对newCapacity进行边界的校正（不能小于minCapacity，不能大于MAX_ARRAY_SIZE）
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 将原有的集合数据拷贝到新容量为newCapacity的数组中
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

ArrayList在未指定容量时，初始容量时10
modCount属性是版本控制器，也是ArrayList中的属性（继承自AbstractList中属性），和业务无关，仅仅是做版本控制，在集合进行变更时（修改、删除、添加）会自增1
扩容时机和扩容机制：当要插入数据的个数大于了数组容量，需要进行扩容，将容量大小变更为原大小的1.5倍，需要将原集合数据拷贝到新数组中
get():获取元素

public E get(int index) {
        //检查查询位置的合法性 index <size
        rangeCheck(index);

        return elementData(index);
    }

    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

	 E elementData(int index) {
        return (E) elementData[index];
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

remove：删除元素

public boolean remove(Object o) {
        //删除操作判断区分是否为null值，如果为null，判断相等使用==  如果不为null，判断相等使用equals
        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)
            //将index位置之后的数据全部前移一位
            System.arraycopy(elementData, index+1, elementData, index,numMoved);
          //Arrays.copyof() 拷贝和System.arraycopy 异同点、效率？？？？
        //将最后一个位置置为null，并将size-1
        elementData[--size] = null; // clear to let GC do its work
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30