Java中Arraylist动态扩容方法详解

前言

本文主要给大家介绍了关于java中arraylist动态扩容的相关内容，分享出来供大家参考学习，下面话不多说了，来一起看看详细的介绍吧。

arraylist 概述

arraylist是基于数组实现的，是一个动态数组，其容量能自动增长。arraylist不是线程安全的，只能用在单线程环境下。实现了serializable接口，因此它支持序列化，能够通过序列化传输；实现了randomaccess接口，支持快速随机访问，实际上就是通过下标序号进行快速访问；实现了cloneable接口，能被克隆。

动态扩容

一 初始化

首先有三种方式来初始化：

public arraylist();

默认的构造器，将会以默认的大小来初始化内部的数组

public arraylist(collection<? extends e> c)

用一个icollection对象来构造，并将该集合的元素添加到arraylist

public arraylist(int initialcapacity) 

用指定的大小来初始化内部的数组

后两种方式都可以理解，通过创造对象，或指定大小来初始化内部数据即可。

那我们来重点关注一下无参数构造器的实现过程：

/**
  * constructs an empty list with an initial capacity of ten.
  */
 public arraylist() {
  // defaultcapacity_empty_elementdata是空数组
  this.elementdata = defaultcapacity_empty_elementdata;
 }

 private static final object[] defaultcapacity_empty_elementdata = {};

可以看出它的默认数组为长度为0。而在之前jdk1,6中，无参数构造器代码是初始长度为10。

jdk6代码这样的：

public arraylist() {
 this(10);
 }
 public arraylist(int initialcapacity) {
 super();
  if (initialcapacity < 0)
   throw new illegalargumentexception("illegal capacity: "+
            initialcapacity);
 this.elementdata = new object[initialcapacity];
 }

接下来，要扩容的话，肯定是在arraylist.add 方法中。我们来看一下具体实现。

二  确保内部容量

我们以无参数构造为例， 初始化时，数组长度为0. 那我现在要添加数据了，数组的长度是怎么变化的？

 public boolean add(e e) {
  //确保内部容量(通过判断，如果够则不进行操作；容量不够就扩容来确保内部容量)
  ensurecapacityinternal(size + 1); // ①increments modcount!!
  elementdata[size++] = e;//②
  return true;
 }

① ensurecapacityinternal方法名的英文大致是“确保内部容量”，size表示的是执行添加之前的元素个数，并非arraylist的容量，容量应该是数组elementdata的长度。ensurecapacityinternal该方法通过将现有的元素个数数组的容量比较。看如果需要扩容，则扩容。

②是将要添加的元素放置到相应的数组中。

下面具体看 ensurecapacityinternal(size + 1);

// ① 是如何判断和扩容的。private void ensurecapacityinternal(int mincapacity) {
  //如果实际存储数组 是空数组，则最小需要容量就是默认容量
  if (elementdata == defaultcapacity_empty_elementdata) {
   mincapacity = math.max(default_capacity, mincapacity);
  }

  ensureexplicitcapacity(mincapacity);
 }

 private void ensureexplicitcapacity(int mincapacity) {
  modcount++;
  //如果数组（elementdata)的长度小于最小需要的容量（mincapacity）就扩容
  if (mincapacity - elementdata.length > 0)
   grow(mincapacity);
 }
 /**
  * default initial capacity.
  */
 private static final int default_capacity = 10;

以上，elementdata是用来存储实际内容的数组。minexpand 是最小扩充容量。defaultcapacity_empty_elementdata共享的空数组实例用于默认大小的空实例。根据传入的最小需要容量mincapacity来和数组的容量长度对比，若mincapactity大于或等于数组容量，则需要进行扩容。

三 扩容

/*
 *增加容量，以确保它至少能容纳
 *由最小容量参数指定的元素数。
 * @param mincapacity所需的最小容量
 */
 private void grow(int mincapacity) {
  // overflow-conscious code
  int oldcapacity = elementdata.length;
  //>>位运算，右移动一位。 整体相当于newcapacity =oldcapacity + 0.5 * oldcapacity 
  // jdk1.7采用位运算比以前的计算方式更快
  int newcapacity = oldcapacity + (oldcapacity >> 1);
  if (newcapacity - mincapacity < 0)
   newcapacity = mincapacity;
  //jdk1.7这里增加了对元素个数的最大个数判断,jdk1.7以前是没有最大值判断的，max_array_size 为int最大值减去8（不清楚为什么用这个值做比较）
  if (newcapacity - max_array_size > 0)
   newcapacity = hugecapacity(mincapacity);
  // 最重要的复制元素方法
  elementdata = arrays.copyof(elementdata, newcapacity);
 }

综上所述，arraylist相当于在没指定initialcapacity时就是会使用延迟分配对象数组空间，当第一次插入元素时才分配10（默认）个对象空间。假如有20个数据需要添加，那么会分别在第一次的时候，将arraylist的容量变为10 (如下图一)；之后扩容会按照1.5倍增长。也就是当添加第11个数据的时候，arraylist继续扩容变为10*1.5=15(如下图二)；当添加第16个数据时，继续扩容变为15 * 1.5 =22个(如下图四)。：

向数组中添加第一个元素时，数组容量为10.

向数组中添加到第10个元素时，数组容量仍为10.

向数组中添加到第11个元素时，数组容量扩为15.

向数组中添加到第16个元素时，数组容量扩为22.

每次扩容都是通过arrays.copyof(elementdata, newcapacity) 这样的方式实现的。

对比和总结：

本文介绍了 arraylist动态扩容的全过程。如果通过无参构造的话，初始数组容量为0，当真正对数组进行添加时，才真正分配容量。每次按照1.5倍（位运算）的比率通过copeof的方式扩容。 在jkd1.6中实现是，如果通过无参构造的话，初始数组容量为10，每次通过copeof的方式扩容后容量为原来的1.5倍，以上就是动态扩容的原理。

好了，以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作能带来一定的帮助，如果有疑问大家可以留言交流，谢谢大家对的支持。

参考资料：http://blog.csdn.net/u010176014/article/details/52073339