Java集合(四)--基于JDK1.8的ArrayList源码解读

最新推荐文章于 2025-01-17 10:07:05 发布
最新推荐文章于 2025-01-17 10:07:05 发布
阅读量105 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/huigelaile/p/11052997.html
版权 
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892189L;

    //默认初始容量
    private static final int DEFAULT_CAPACITY = 10;

    //空数组
    private static final Object[] EMPTY_ELEMENTDATA = {};

    //默认空数组，用来和EMPTY_ELEMENTDATA区分什么时候扩容多少
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    //存储ArrayList元素的数组缓冲区，ArrayList的容量是此数组缓冲区的长度，添加第一个元素时，*将扩展为DEFAULT_CAPACITY
    transient Object[] elementData;

    //ArrayList的大小，也就是包含的元素数
    private int size;

    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {	//初始容量大于0
            this.elementData = new Object[initialCapacity];	//生成一个新的存储数组
        } else if (initialCapacity == 0) {	//初始容量等于0
            this.elementData = EMPTY_ELEMENTDATA;	//设置为空数组
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * 构造一个包含指定元素的列表
     */
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }
}

从上述源码中，我们可以得到以下信息：源码基于JDK1.8

1、implements List<E>, RandomAccess（可以随机访问）, Cloneable, java.io.Serializable

2、初始容量10，有看过大佬博客说，默认创建ArrayList的时候，调用默认构造器this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA，此时初始容量为0，而不是10

我的理解：

elementData的英文注解如下：

　　The capacity of the ArrayList is the length of this array buffer. Any empty ArrayList with elementData ==

DEFAULTCAPACITY_EMPTY_ELEMENTDATA will be expanded to DEFAULT_CAPACITY when the first element is added

　　容量Capacity是数组缓存区elementData的长度，对于elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空ArrayList来说，第一次添

加元素，容量会变成DEFAULT_CAPACITY，也就是初始容量

　　所以，只是容量为0，初始容量DEFAULT_CAPACITY是final类型，永远为10，和elementData具体等于什么没关系，容量Capacity才会变

3、并且通过transient Object[] elementData保存数据

add()添加数据

public boolean add(E e) {
	ensureCapacityInternal(size + 1);  //确保容量
	elementData[size++] = e; //在数组尾部添加数据
	return true;
}

private void ensureCapacityInternal(int minCapacity) {
	if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
		minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
	}

	ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
	modCount++; //修改次数+1
	if (minCapacity - elementData.length > 0)　　//如果最小容量大于数组的长度，进行扩容
		grow(minCapacity);
}
grow()扩容

private void grow(int minCapacity) {
	int oldCapacity = elementData.length;　　//oldCapacity当前数组的长度
	int newCapacity = oldCapacity + (oldCapacity >> 1);　　//新容量=oldCapacity*1.5
	if (newCapacity - minCapacity < 0)　　//newCapacity < 最小容量，赋值
		newCapacity = minCapacity;
	if (newCapacity - MAX_ARRAY_SIZE > 0)　　//大于最大容量，newCapacity赋值为Integer最大值0x7fffffff
		newCapacity = hugeCapacity(minCapacity);
	elementData = Arrays.copyOf(elementData, newCapacity);　　//通过Arrays重新生成一个新容量的数组，包含之前数组的数据，赋值原数组
}
remove()删除数据

1、按照数组下标删除

public E remove(int index) {
	rangeCheck(index);　　//检查数组是否下标越界

	modCount++;
	E oldValue = elementData(index);　　//取出index位置的数据

	int numMoved = size - index - 1;　　//
	if (numMoved > 0)
　　　　　//将index后面的所有元素，都前移一位
	System.arraycopy(elementData, index+1, elementData, index, numMoved);
	elementData[--size] = null; //最后一位置为null

	return oldValue;　　//返回原来的老数据
}

2、按照元素删除

public boolean remove(Object o) {
	if (o == null) {
		for (int index = 0; index < size; index++)
			if (elementData[index] == null) {　　//删除第一个null
				fastRemove(index);
				return true;
			}
	} else {
		for (int index = 0; index < size; index++)
			if (o.equals(elementData[index])) {　　//删除第一个和object相同的数据
				fastRemove(index);
				return true;
			}
	}
	return false;
}

都是找个第一个和参数匹配的数据，然后执行的代码和第一种方式相同 

复制方法：public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

Object src : 原数组

int srcPos : 从元数据的起始位置开始

Object dest : 目标数组

int destPos : 目标数组的开始起始位置

int length : 要copy的数组的长度

set()：
public E set(int index, E element) {
	rangeCheck(index);　　//检查是否下标越界

	E oldValue = elementData(index);　　//获取原值
	elementData[index] = element;　　//覆盖原值
	return oldValue;　　//返回原值
}
get()：
public E get(int index) {
	rangeCheck(index);

	return elementData(index);
}
indexOf()：
public int indexOf(Object o) {　　//和contain()一样，整体就是遍历是否包含该元素，然后返回下标，如果不包含，返回-1
	if (o == null) {
		for (int i = 0; i < size; i++)
			if (elementData[i]==null)
				return i;
	} else {
		for (int i = 0; i < size; i++)
			if (o.equals(elementData[i]))
				return i;
	}
	return -1;
}
size()：和elementData的长度没有关系，指的是实际包含元素的个数
public int size() {
	return size;
}
isEmpty()：是否为空
public boolean isEmpty() {
	return size == 0;
}
trimToSize()：缩减集合的容量为size，也就是剔除空节点
public void trimToSize() {
	modCount++;
	if (size < elementData.length) {
		elementData = (size == 0)
		  ? EMPTY_ELEMENTDATA
		  : Arrays.copyOf(elementData, size);
	}
}
ArrayList的for循环：　

　　for、foreach、Iterator，for效率最好，Iterator效率最差

　　只有for循环中调用add()和remove()，才不会发生java.util.ConcurrentModificationException异常，其他两种都会，set()不会出现异常。

　　因为add() remove()都会执行modCount++

　　ConcurrentModificationException主要为了防止线程并发修改的，因为ArrayList是线程不安全的，做了实现fast-fail机制

public static void main(String[] args) throws IOException {
	ArrayList<String> list = new ArrayList<>();
	list.add("abc");
	list.add("def");
	list.forEach(s -> {
		list.add(s);
		list.remove(s);
	});
	Iterator iterator = list.iterator();
	while (iterator.hasNext()) {
		String s = (String)iterator.next();
		list.remove(iterator.next());
	}
}

输出结果：java.util.ConcurrentModificationException
Itr：
public Iterator<E> iterator() {
	return new Itr();
}

ArrayList实现了自定义的迭代器

private class Itr implements Iterator<E> {
	int cursor;       //游标，下个元素的索引
	int lastRet = -1; //最后一个元素的索引，如果没有返回-1
	int expectedModCount = modCount;//期望修改的次数

	public boolean hasNext() {　　//是否有下个元素
		return cursor != size;
	}

	@SuppressWarnings("unchecked")
	public E next() {　　//得到下个元素
		checkForComodification();
		int i = cursor;
		if (i >= size)
			throw new NoSuchElementException();
		Object[] elementData = ArrayList.this.elementData;
		if (i >= elementData.length)
			throw new ConcurrentModificationException();
		cursor = i + 1;　　//后移一位
		return (E) elementData[lastRet = i];　　
	}

	public void remove() {
		if (lastRet < 0)
			throw new IllegalStateException();
		checkForComodification();

		try {
			ArrayList.this.remove(lastRet);　　//删除当前元素
			cursor = lastRet;　　//cursor指的是下个元素的索引，由于删除一个元素，所以还是等于当前位置
			lastRet = -1;　　
			expectedModCount = modCount;
		} catch (IndexOutOfBoundsException ex) {
			throw new ConcurrentModificationException();
		}
	}

	@Override
	@SuppressWarnings("unchecked")
	public void forEachRemaining(Consumer<? super E> consumer) {
		Objects.requireNonNull(consumer);
		final int size = ArrayList.this.size;
		int i = cursor;
		if (i >= size) {
			return;
		}
		final Object[] elementData = ArrayList.this.elementData;
		if (i >= elementData.length) {
			throw new ConcurrentModificationException();
		}
		while (i != size && modCount == expectedModCount) {
			consumer.accept((E) elementData[i++]);
		}
		// update once at end of iteration to reduce heap write traffic
		cursor = i;
		lastRet = i - 1;
		checkForComodification();
	}

	final void checkForComodification() {　　//检查是否发生过并发修改
		if (modCount != expectedModCount)
			throw new ConcurrentModificationException();
	}
}
ListIterator：

在之前对比Iterator和Iterable有讲过，支持双向遍历，既可以向前，又可以向后

序列化：

　　ArrayList本身实现了序列化，transient Object[] elementData，用来保存数据的数组确实用transient修饰的，意味着不能该字段不能实现

序列化，那ArrayList到底如何实现的序列化的呢？

　　通过重写writeObject()和readObject()，因为数组中容量Capacity一般都是大于size的，意味着有很多空节点，ArrayList为了节省网络资源

，自定义了序列化，只序列化非空的部分

　　如果对序列化不够了解的话，可以参考：Java基础(十一)--Serializable和Externalizable接口实现序列化

到目前为止，我们对ArrayList有了基本的了解：

1、通过数组保存数据，可以随机访问数据，无论是get(i)、add(Object)还是set(int index, E element)效率都是比较高的

2、remove()和add(int index, Object object)，都会发生System.arraycopy()，如果index后面的元素比较多的情况下，效率降低很多

3、线程不安全，如果需要保证安全性的话，建议使用CopyOnWriteArrayList

4、初始容量10，发生扩容为原来的1.5倍

 

总结：ArrayList适合顺序插入，按下标访问/修改，不适合删除，按下标插入

转载于:https://www.cnblogs.com/huigelaile/p/11052997.html

Java 集合框架：ArrayList 的介绍、使用、原理与源码解析
栗筝i的博客
06-17 6183
本文将从介绍 ArrayList 开始，详细探讨其使用方法、工作原理以及背后的源码实现，帮助读者深入理解并灵活运用 ArrayList，以提升编程效率和代码质量。 在接下来的部分中，我们将首先概述 ArrayList 的基本特性及其在 Java 集合框架中的地位。随后，通过实际代码示例展示如何创建、操作和管理 ArrayList。接着，我们会揭示 ArrayList 的内部工作机制，包括其底层数据结构、扩容策略和性能优化等方面的内容。最后，我们将深入分析 ArrayList 的源码，探讨其设计思想和实现细
ArrayList 带参数（Collection<? extends E> c）构造器的一点见解
qq_22083043的博客
08-23 2716
先贴上源码： public class ArrayList extends AbstractList         implements List, RandomAccess, Cloneable, java.io.Serializable {       private static final Object[] EMPTY_ELEMENTDATA = {};     priv
ArrayList源码分析
bigbigChopper的博客
06-06 231
ArrayList ArrayList是基于动态数组实现的，支持随机访问，它继承自AbstractiList，RandomAccess标识着它支持随机访问 public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, j...
ArrayList 解析
达达的博客
04-18 257
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable 基本属性 基于数组实现 支持快速随机访问 数组默认大小为10 private static fina...
关于ArrayList类的疑惑!
boiled water 的专栏
10-27 718
在JAVA原代码中可以看到ArrayList类的实现.其中定义ArrayList类的时候,如下        public class ArrayList extends AbstractList            implements List, RandomAccess, Cloneable, java.io.Serializable                在这里我有个疑惑,Arr
Java集合框架：ArrayList
weixin_33860147的博客
03-17 289
ArrayList定义 package java.util; public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serial...
【JDK1.8源码阅读】ArrayList.class（完）
大猴子
03-24 284
//List.java public interface List<E> extends Collection<E> //Collection.java public interface Collection<E> extends Iterable<E> //Iterable.java public interface Iterable<T...
18：ArrayList 集合 JDK1.7 及 JDK1.8 版本的 扩容机制 、Vector 扩容机制 解读 及它们之间的区别总结：
随手记记，加深印象。
06-17 1400
JDK1.7 、JDK1.8 的ArrayList 和 Vector 区别总结： JDK1.7的ArrayList的 扩容机制源码。JDK1.7的源码是 ，在实例化这个 ArrayList 集合对象的时候。不管 调用者初始化完ArrayList对象后 继不继续 使不使用，在初始化对象的时候，都会创建一个长度为 10 的 Object 的数组（elementData），当调用者继续使用时 添加元素 到集合中的容量 达到 elementData的当前最大容量时。 就会进行 对 elementData
Java1.8 ArrayList ConcurrentModificationException源码分析
GD_2014的博客
03-25 759
序言 本文主要从JDK（1.7，1.8）源码角度分析ArrayList操作及ConcurrentModificationException异常产生的原因和解决方案 文章内容安排 JDK1.7 ArrayList操作**（补充中）** JDK1.7 ConcurrentModificationException**（补充中）** JDK1.8 ArrayList操作**（补充中）** JDK1.8...
深入理解Java集合框架源码—JDK1.8采集技术
资源的标题为‘collectionJava源码-javacollection:学习jdk1.8采集框架源代码’，以及描述‘集合Java源码java集合学习jdk1.8采集框架源代码’，标签为‘系统开源’。通过资源名称，我们可以推断出这是一套针对Java...
HashMap 源码详细分析(JDK1.8)
windy杨树的博客
03-16 486
目录 1. 概述 本篇文章我们来聊聊大家日常开发中常用的一个集合类 -HashMap。HashMap 最早出现在 JDK 1.2中，底层基于散列算法实现。HashMap 允许 null 键和 null 值，在计算哈键的哈希值时，null 键哈希值为 0。HashMap 并不保证键值对的顺序，这意味着在进行某些操作后，键值对的顺序可能会发生变化。另外，需要注意的是，HashMap 是...
用大白话告诉你ArrayList的底层原理
热门推荐
王喆峰的博客
08-18 5万+
一、ArrayList的数据结构 ArrayList的底层数据结构就是一个数组，数组元素的类型为Object类型，对ArrayList的所有操作底层都是基于数组的。 二、ArrayList的线程安全性 对ArrayList进行添加元素的操作的时候是分两个步骤进行的，即第一步先在object[size]的位置上存放需要添加的元素；第二步将size的值增加1。由于这个过程在多线程的环境下是不...
【Java源码分析】Vector源码分析
流动的城市的博客
07-16 636
类的声明public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {} 仔细对比ArrayList的类的定义就可以看出，Vector实现的接口以及父类和ArrayList是一样的。实际上从继承体系上也可以看出两者很类似，同属于List
ArrayList实现原理（JDK1.8）
Simple_Yangger的博客
11-30 1148
ArrayList实现原理（JDK1.8） public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable ArrayList 继承于AbstractList，实现了List...
面试题之---ArrayList实现原理
qq_38859786的博客
05-10 8311
单列集合图   1. ArrayList是一个动态数组,实现了List&lt;E&gt;, RandomAccess, Cloneable, java.io.Serializable，并允许包括null在内的所有元素。 1.1,实现了RandomAccess接口标识着其支持随机快速访问,实际上,我们查看RandomAccess源码可以看到,其实里面什么都没有定义.因为ArrayList底...
Java源码分析 - ArrayList
BlueLzy的个人博客
07-03 3394
ArrayList是什么 public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{ // ... } 继承AbstractList - 说明本身数据结构是列表 实现List, RandomAccess, Cloneable, Serializable 这几个接口
看完这个文章就可以对 ArrayList 有自己的见解了
qq_24251607的博客
05-05 565
ArrayList 也是我们在写代码的过程中很常使用的一种集合类。让大家从使用易操作的数组变成使用 ArrayList 的缘由我想应该是 add 方法，能够“无忧无虑”的向 ArrayList 里存放数据，还能像数组一样用“下标”和 get 方法获得数据。那么这篇文章就对 ArrayList 这个集合类做一次简单的理解吧。 一、定义 先来看看这个类的作者 Josh Bloch 和 Neal Gafter 是怎么描述他们的作品的： Resizable-array implementation of the
tomcat项目运行后报500
m0_73232151的博客
01-16 497
错误，确保项目正常运行。同时，需要注意 Tomcat 版本和 Servlet API 版本的兼容性，以避免类似问题的再次发生。这里使用了 Jakarta Servlet API 5.0.0 版本，它与 Tomcat 10.1.19 相匹配。同样使用 Jakarta Servlet API 5.0.0 版本。通过上述步骤，你可以解决因 Servlet API 类缺失导致的。tomcat项目运行后，浏览器端显示500，这将更新项目的依赖并重新打包。
Spring AOP 详解
最新发布
web13765607643的博客
01-17 511
Aspect Oriented Programming（面向切面编程）。切面就是指某一类特定问题，所以 AOP 也可以理解为面向特定方法编程。**AOP 是一种思想，是对某一类事情的集中处理。**Spring AOP 是其中的一种实现方式。AOP 的作用：在程序运行期间，在不修改源代码的基础上，对已有方法进行增强（无侵入性：解耦）。
深入解析JDK1.8 ArrayList源码
在JDK1.8中，ArrayList是一个基于数组实现的列表类，它是Java集合框架的重要组成部分。ArrayList的主要优点是随机访问快速，因为其底层基于数组，可以通过索引来直接访问元素。然而，由于其动态增长的特性，插入和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值