ArrayList 详解

---

前言

Arraylist是Collection接口 下 List接口 的实现类
public class ArrayList<E> extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
特点：
	可添加重复元素
	并且添加的元素是有序的【可以通过数组访问】

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、ArrayList 使用

添加数据

	基本数据类型会先转成包装类在添加
		add()添加，返回boolean

<Object> 可以添加Java中所有的对象，因为Object是java中所有类的父类

		// 创建一个集合
		ArrayList<Object> arrayList = new ArrayList<>();
		// 给集合添加元素
		arrayList.add("String");
		arrayList.add(23);
		arrayList.add(13.5);
		arrayList.add("String");
		System.out.println(arrayList);[String, 23, 13.5, String]
		System.out.println(arrayList.get(0));// 返回下标为0的元素

遍历集合的方式

size() 返回集合的大小【长度】
get(index) 输入下标返回元素

• for

		for (int i = 0; i < arrayList.size(); i++) {
			System.out.print(arrayList.get(i) + "\t");
		}

• 迭代器Iterator

iterator() 返回一个集合的迭代器

		Iterator<Object> iterator = arrayList.iterator();
		while (iterator.hasNext()){ // 判断是否还有下一个元素
			Object next = iterator.next();
			// 将指针下移 将下移后集合位置的元素返回
			System.out.print(next + "\t"); //String	23	13.5
		}

• 增强for
  底层也是构造器

for (Object o : arrayList) {
			System.out.print(o + "\t");
		}

二、常用方法

addAll(Collection<? extends E> c) 将指定集合中的所有元素添加到此集合
clear() 从此集合中删除所有元素
contains(Object o) 如果此集合包含指定的元素，则返回 true
remove(Object o) 从该集合中删除指定元素的单个实例
toArray() 返回一个包含此集合中所有元素的数组。
lastIndexOf(Object o) 返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1。
set(int index, E element)用指定的元素替换此列表中指定位置的元素。

三、详解

创建机制分析

• 无参构造

ArrayList<Object> arrayList = new ArrayList<>();
//无参构造
public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
        //底层用Object[]做存储 this.elementData
        private static final Object[] EMPTY_ELEMENTDATA = {};// 用于空实例的共享空数组实例。
    }
初始化完成，初始Arraylist为null

第一次添加数据
才会对Object数组初始化大小

		ArrayList<Object> arrayList = new ArrayList<>();
		arrayList.add(1);// int ->Integer
		System.out.println(arrayList);
	

add()源码

		public boolean add(E e) {
		size第一次添加为0 
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e; //大小++，添加数据
        return true;
    }

ensureCapacityInternal(size + 1)

  确保容量
  private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
   transient Object[] elementData; 
   		数据存储																																																																																				
  calculateCapacity(elementData, minCapacity)
   private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        	private static final int DEFAULT_CAPACITY = 10;//默认初始容量。
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
 private void ensureExplicitCapacity(int minCapacity) { 此时minCapacity==DEFAULT_CAPACITY 
        modCount++;
		// protected transient int modCount = 0; 记录修改次数
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)//判断当前容量是否够用
            grow(minCapacity);
    }
    grow(minCapacity);
    增加容量，以确保它至少可以容纳最小容量参数指定的元素数。参数：minCapacity–所需的最小容量
      private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;//获取数组长度
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // oldCapacity/2+oldCapacity=新数组长度 每次扩容1.5倍
        if (newCapacity - minCapacity < 0)//新数组长度-最小容量<0说明容量够用
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
      // private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;最大容量
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
        //第一次：初始数组大小
        //扩容： 拷贝数据元素并且扩容1.5倍
        //返回add()添加数据 size++
         elementData[size++] = e; //大小++，添加数据
    } 

• 有参构造
  ArrayList(int initialCapacity) 传入一个初始容量

transient Object[] elementData;	 数据存储
 public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity]; //创建大小为传入大小的Object[]
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA; // Object[]
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
    //构造器初始化完成

第一次添加数据，对数组初始化

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { elementData 已经不为空
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity; 
    }
  private void ensureExplicitCapacity(int minCapacity) {
        modCount++; // 记录修改次数
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)//当前容量够用，不会进入grow(minCapacity);
            grow(minCapacity);
    }

• 扩容机制分析
  和无参构造器一样。每次扩容1.5倍

总结

Arraylist
		可添加重复数据
		底层用Object[]做存储
		使用无参构造
			初始化elementData容量为0
				第一次添加扩容elementData容量为10
				再次扩容elementData为1.5倍
		使用有参构造
			初始化elementData容量为指定大小，
			第一次添加elementData容量为指定大小
			需要直接扩容elementData为1.5倍