4.4 List 接口的实现类：ArrayList-Java语言基础10-Java中的集合

当前位置:　首页>> 技术小册>> Java语言基础10-Java中的集合

4.4.1 概述

-  ArrayList 具备了List接口的特性（有序、重复、索引）。 
-  ArrayList 集合底层的实现原理是数组，大小可变。 
-  ArrayList 的特点：查询速度快、增删慢。 
-  ArrayList 在 JDK8 前后的实现区别： 
  - JDK7 ：ArrayList 像饿汉式，直接创建了一个初始容量为 10 的数组，每次扩容是原来长度的 1.5 倍。
  - JDK8 ：ArrayList 像懒汉式，一开始创建一个长度为 0 的数组，当添加第一个元素的时候再创建一个容器为 10 的数组，每次扩容是原来长度的 1.5 倍。
-  ArrayList 是线程不安全的集合，运行速度快。

4.4.2 ArrayList 的类成员变量

- 默认容量：

```
private static final int DEFAULT_CAPACITY = 10;
```
- 空数组：

```
private static final Object[] EMPTY_ELEMENTDATA = {};
```
- 默认容量的空数组：

```
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
```
- ArrayList 集合中的核心数组：

```
transient Object[] elementData;
```
- 记录数组中存储个数：

```
private int size;
```
- 数组扩容的最大值：

```
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
```
4.4.3 ArrayList 类的构造方法

- 无参构造方法：

```
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_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);
    }
}
```
4.4.4 ArrayList 类的 add 方法

```
public boolean add(E e) {
    // 检查容量 size初始化的时候是0，那么size+1就是1
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 将元素添加到数组中，size计数器++
    elementData[size++] = e;
    return true;
}
```

```
// minCapacity此时是1
private void ensureCapacityInternal(int minCapacity) {
    // 如果存储元素的数据 == 默认的空的数组，无参构造器中赋值
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // 返回DEFAULT_CAPACITY=10和minCapacity=1的最大值，即10
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
	// 扩容
    ensureExplicitCapacity(minCapacity);
}

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

// overflow-conscious code
    // 10- 数组的长度0 > 0
    if (minCapacity - elementData.length > 0)
        // 传入10
        grow(minCapacity);
}

private void grow(int minCapacity) {
    // overflow-conscious code
    // 数组的原来长度 0 
    int oldCapacity = elementData.length;
    // 新容量 = 数组原来的长度 + 数组原来的长度 / 2
    int newCapacity = oldCapacity + (oldCapacity >> 1); // 0
    if (newCapacity - minCapacity < 0) // 0 -10 < 0
        newCapacity = minCapacity; // 新容量 = 10
    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); // 数组的复制
}

```

4.4.5 ArrayList 类的 get 方法

```
public E get(int index) {
    // 检查索引
    rangeCheck(index);
    // 返回数组中指定索引处的元素
    return elementData(index);
}
```

4.4.6 ArrayList 类的 set 方法

```
public E set(int index, E element) {
    // 检查索引
    rangeCheck(index);
	// 获取旧的元素
    E oldValue = elementData(index);
    // 将新的元素设置到指定的索引处
    elementData[index] = element;
    // 返回旧的元素
    return oldValue;
}
```

4.4.7 ArrayList 类的 remove 方法

```
public E remove(int index) {
    // 检查索引
    rangeCheck(index);

modCount++;
    // 获取旧的元素
    E oldValue = elementData(index);
  
    int numMoved = size - index - 1;
    if (numMoved > 0)
        // 将index后面的元素依次复制到前面
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // 最后一个元素设置为null
    elementData[--size] = null; // clear to let GC do its work
    // 返回旧的元素
    return oldValue;
}
```

该分类下的相关小册推荐：

Java语言基础8-Java多线程

java源码学习笔记

Java语言基础6-面向对象高级

手把手带你学习SpringBoot-零基础到实战

Java面试指南

SpringBoot合辑-高级篇

Java语言基础11-Java中的泛型

Java高并发秒杀入门与实战

Java语言基础15-单元测试和日志技术

Java语言基础2-运算符

Java语言基础12-网络编程

深入拆解 Java 虚拟机