ArrayList核心源码

最新推荐文章于 2022-08-23 21:38:20 发布
最新推荐文章于 2022-08-23 21:38:20 发布
阅读量80 收藏
点赞数
分类专栏： Java集合 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LJ5521/article/details/115403879
版权

ArrayList 扩容机制 性能优化 源码分析 Java集合
关键词由CSDN通过智能技术生成

#ArrayList核心源码

package java . util ;
import java . util . function . Consumer ;
import java . util . function . Predicate ;
import java . util . function . UnaryOperator ;
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 数据的数组
*/
transient Object [] elementData ; // non-private to simplify nested class
access
/**
* ArrayList 所包含的元素个数
*/
private int size ;
/**
* 带初始容量参数的构造函数。（用户自己指定容量）
*/
public ArrayList ( int initialCapacity ) {
if ( initialCapacity > 0 ) {
// 创建 initialCapacity 大小的数组
this . elementData = new Object [ initialCapacity ];
} else if ( initialCapacity == 0 ) {
// 创建空数组
this . elementData = EMPTY_ELEMENTDATA ;
} else {
throw new IllegalArgumentException ( "Illegal Capacity: " +
initialCapacity );
}
}
/**
* 默认构造函数， DEFAULTCAPACITY_EMPTY_ELEMENTDATA 为 0. 初始化为 10 ，也就是说初始其实
是空数组 当添加第一个元素的时候数组容量才变成 10
*/
public ArrayList () {
this . elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA ;
}
/**
* 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。
*/
public ArrayList ( Collection <? extends E > c ) {
//
elementData = c . toArray ();
// 如果指定集合元素个数不为 0
if (( size = elementData . length ) != 0 ) {
// c.toArray 可能返回的不是 Object 类型的数组所以加上下面的语句用于判断，
// 这里用到了反射里面的 getClass() 方法
if ( elementData . getClass () != Object []. class )
elementData = Arrays . copyOf ( elementData , size , Object []. class );
} else {
// 用空数组代替
this . elementData = EMPTY_ELEMENTDATA ;
}
}
/** * 修改这个 ArrayList 实例的容量是列表的当前大小。 应用程序可以使用此操作来最小化
ArrayList 实例的存储。
*/
public void trimToSize () {
modCount ++ ;
if ( size < elementData . length ) {
elementData = ( size == 0 )
? EMPTY_ELEMENTDATA
: Arrays . copyOf ( elementData , size );
}
}
// 下面是 ArrayList 的扩容机制
//ArrayList 的扩容机制提高了性能，如果每次只扩充一个，
// 那么频繁的插入会导致频繁的拷贝，降低性能，而 ArrayList 的扩容机制避免了这种情况。
/**
* 如有必要，增加此 ArrayList 实例的容量，以确保它至少能容纳元素的数量
* @param minCapacity 所需的最小容量
*/
public void ensureCapacity ( int minCapacity ) {
int minExpand = ( elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA )
// any size if not default element table
? 0
// larger than default for default empty table. It's already
// supposed to be at default size.
: DEFAULT_CAPACITY ;
if ( minCapacity > minExpand ) {
ensureExplicitCapacity ( minCapacity );
}
}
// 得到最小扩容量
private void ensureCapacityInternal ( int minCapacity ) {
if ( elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA ) {
// 获取默认的容量和传入参数的较大值
minCapacity = Math . max ( DEFAULT_CAPACITY , minCapacity );
}
ensureExplicitCapacity ( minCapacity );
}
// 判断是否需要扩容
private void ensureExplicitCapacity ( int minCapacity ) {
modCount ++ ;
// overflow-conscious code
if ( minCapacity - elementData . length > 0 )
// 调用 grow 方法进行扩容，调用此方法代表已经开始扩容了
grow ( minCapacity );
}
/**
* 要分配的最大数组大小
*/
private static final int MAX_ARRAY_SIZE = Integer . MAX_VALUE - 8 ;
/**
* ArrayList 扩容的核心方法。
*/
private void grow ( int minCapacity ) { // oldCapacity 为旧容量， newCapacity 为新容量
int oldCapacity = elementData . length ;
// 将 oldCapacity 右移一位，其效果相当于 oldCapacity /2 ，
// 我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的 1.5
倍，
int newCapacity = oldCapacity + ( oldCapacity >> 1 );
// 然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作
数组的新容量，
if ( newCapacity - minCapacity < 0 )
newCapacity = minCapacity ;
// 再检查新容量是否超出了 ArrayList 所定义的最大容量，
// 若超出了，则调用 hugeCapacity() 来比较 minCapacity 和 MAX_ARRAY_SIZE ，
// 如果 minCapacity 大于 MAX_ARRAY_SIZE ，则新容量则为 Interger.MAX_VALUE ，否则，新
容量大小则为 MAX_ARRAY_SIZE 。
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 );
}
// 比较 minCapacity 和 MAX_ARRAY_SIZE
private static int hugeCapacity ( int minCapacity ) {
if ( minCapacity < 0 ) // overflow
throw new OutOfMemoryError ();
return ( minCapacity > MAX_ARRAY_SIZE ) ?
Integer . MAX_VALUE :
MAX_ARRAY_SIZE ;
}
/**
* 返回此列表中的元素数。
*/
public int size () {
return size ;
}
/**
* 如果此列表不包含元素，则返回 true 。
*/
public boolean isEmpty () {
// 注意 = 和 == 的区别
return size == 0 ;
}
/**
* 如果此列表包含指定的元素，则返回 true 。
*/
public boolean contains ( Object o ) {
//indexOf() 方法：返回此列表中指定元素的首次出现的索引，如果此列表不包含此元素，则
为 -1
return indexOf ( o ) >= 0 ;
}
/**
* 返回此列表中指定元素的首次出现的索引，如果此列表不包含此元素，则为 -1
*/
public int indexOf ( Object o ) {
if ( o == null ) {
for ( int i = 0 ; i < size ; i ++ ) if ( elementData [ i ] == null )
return i ;
} else {
for ( int i = 0 ; i < size ; i ++ )
//equals() 方法比较
if ( o . equals ( elementData [ i ]))
return i ;
}
return - 1 ;
}
/**
* 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回 -1 。 .
*/
public int lastIndexOf ( Object o ) {
if ( o == null ) {
for ( int i = size - 1 ; i >= 0 ; i -- )
if ( elementData [ i ] == null )
return i ;
} else {
for ( int i = size - 1 ; i >= 0 ; i -- )
if ( o . equals ( elementData [ i ]))
return i ;
}
return - 1 ;
}
/**
* 返回此 ArrayList 实例的浅拷贝。 （元素本身不被复制。）
*/
public Object clone () {
try {
ArrayList <?> v = ( ArrayList <?> ) super . clone ();
//Arrays.copyOf 功能是实现数组的复制，返回复制后的数组。参数是被复制的数组和复制
的长度
v . elementData = Arrays . copyOf ( elementData , size );
v . modCount = 0 ;
return v ;
} catch ( CloneNotSupportedException e ) {
// 这不应该发生，因为我们是可以克隆的
throw new InternalError ( e );
}
}
/**
* 以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。
* 返回的数组将是 “ 安全的 ” ，因为该列表不保留对它的引用。 （换句话说，这个方法必须分配一个新的
数组）。
* 因此，调用者可以自由地修改返回的数组。 此方法充当基于阵列和基于集合的 API 之间的桥梁。
*/
public Object [] toArray () {
return Arrays . copyOf ( elementData , size );
}
/**
* 以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素） ;
* 返回的数组的运行时类型是指定数组的运行时类型。 如果列表适合指定的数组，则返回其中。
* 否则，将为指定数组的运行时类型和此列表的大小分配一个新数组。 * 如果列表适用于指定的数组，其余空间（即数组的列表数量多于此元素），则紧跟在集合结束后的数
组中的元素设置为 null 。
* （这仅在调用者知道列表不包含任何空元素的情况下才能确定列表的长度。）
*/
@SuppressWarnings ( "unchecked" )
public < T > T [] toArray ( T [] a ) {
if ( a . length < size )
// 新建一个运行时类型的数组，但是 ArrayList 数组的内容
return ( T []) Arrays . copyOf ( elementData , size , a . getClass ());
// 调用 System 提供的 arraycopy() 方法实现数组之间的复制
System . arraycopy ( elementData , 0 , a , 0 , size );
if ( a . length > size )
a [ size ] = null ;
return a ;
}
// Positional Access Operations
@SuppressWarnings ( "unchecked" )
E elementData ( int index ) {
return ( E ) elementData [ index ];
}
/**
* 返回此列表中指定位置的元素。
*/
public E get ( int index ) {
rangeCheck ( index );
return elementData ( index );
}
/**
* 用指定的元素替换此列表中指定位置的元素。
*/
public E set ( int index , E element ) {
// 对 index 进行界限检查
rangeCheck ( index );
E oldValue = elementData ( index );
elementData [ index ] = element ;
// 返回原来在这个位置的元素
return oldValue ;
}
/**
* 将指定的元素追加到此列表的末尾。
*/
public boolean add ( E e ) {
ensureCapacityInternal ( size + 1 ); // Increments modCount!!
// 这里看到 ArrayList 添加元素的实质就相当于为数组赋值
elementData [ size ++ ] = e ;
return true ;
}
/**
* 在此列表中的指定位置插入指定的元素。 * 先调用 rangeCheckForAdd 对 index 进行界限检查；然后调用 ensureCapacityInternal 方
法保证 capacity 足够大；
* 再将从 index 开始之后的所有成员后移一个位置；将 element 插入 index 位置；最后 size 加 1 。
*/
public void add ( int index , E element ) {
rangeCheckForAdd ( index );
ensureCapacityInternal ( size + 1 ); // Increments modCount!!
//arraycopy() 这个实现数组之间复制的方法一定要看一下，下面就用到了 arraycopy() 方法实
现数组自己复制自己
System . arraycopy ( elementData , index , elementData , index + 1 ,
size - index );
elementData [ index ] = element ;
size ++ ;
}
/**
* 删除该列表中指定位置的元素。 将任何后续元素移动到左侧（从其索引中减去一个元素）。
*/
public E remove ( int index ) {
rangeCheck ( index );
modCount ++ ;
E oldValue = elementData ( index );
int numMoved = size - index - 1 ;
if ( numMoved > 0 )
System . arraycopy ( elementData , index + 1 , elementData , index ,
numMoved );
elementData [ -- size ] = null ; // clear to let GC do its work
// 从列表中删除的元素
return oldValue ;
}
/**
* 从列表中删除指定元素的第一个出现（如果存在）。 如果列表不包含该元素，则它不会更改。
* 返回 true ，如果此列表包含指定的元素
*/
public boolean remove ( Object o ) {
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 remove method that skips bounds checking and does not
* return the value removed. */
private void fastRemove ( int index ) {
modCount ++ ;
int numMoved = size - index - 1 ;
if ( numMoved > 0 )
System . arraycopy ( elementData , index + 1 , elementData , index ,
numMoved );
elementData [ -- size ] = null ; // clear to let GC do its work
}
/**
* 从列表中删除所有元素。
*/
public void clear () {
modCount ++ ;
// 把数组中所有的元素的值设为 null
for ( int i = 0 ; i < size ; i ++ )
elementData [ i ] = null ;
size = 0 ;
}
/**
* 按指定集合的 Iterator 返回的顺序将指定集合中的所有元素追加到此列表的末尾。
*/
public boolean addAll ( Collection <? extends E > c ) {
Object [] a = c . toArray ();
int numNew = a . length ;
ensureCapacityInternal ( size + numNew ); // Increments modCount
System . arraycopy ( a , 0 , elementData , size , numNew );
size += numNew ;
return numNew != 0 ;
}
/**
* 将指定集合中的所有元素插入到此列表中，从指定的位置开始。
*/
public boolean addAll ( int index , Collection <? extends E > c ) {
rangeCheckForAdd ( index );
Object [] a = c . toArray ();
int numNew = a . length ;
ensureCapacityInternal ( size + numNew ); // Increments modCount
int numMoved = size - index ;
if ( numMoved > 0 )
System . arraycopy ( elementData , index , elementData , index + numNew ,
numMoved );
System . arraycopy ( a , 0 , elementData , index , numNew );
size += numNew ;
return numNew != 0 ;
}
/**
* 从此列表中删除所有索引为 fromIndex （含）和 toIndex 之间的元素。
* 将任何后续元素移动到左侧（减少其索引）。 */
protected void removeRange ( int fromIndex , int toIndex ) {
modCount ++ ;
int numMoved = size - toIndex ;
System . arraycopy ( elementData , toIndex , elementData , fromIndex ,
numMoved );
// clear to let GC do its work
int newSize = size - ( toIndex - fromIndex );
for ( int i = newSize ; i < size ; i ++ ) {
elementData [ i ] = null ;
}
size = newSize ;
}
/**
* 检查给定的索引是否在范围内。
*/
private void rangeCheck ( int index ) {
if ( index >= size )
throw new IndexOutOfBoundsException ( outOfBoundsMsg ( index ));
}
/**
* add 和 addAll 使用的 rangeCheck 的一个版本
*/
private void rangeCheckForAdd ( int index ) {
if ( index > size || index < 0 )
throw new IndexOutOfBoundsException ( outOfBoundsMsg ( index ));
}
/**
* 返回 IndexOutOfBoundsException 细节信息
*/
private String outOfBoundsMsg ( int index ) {
return "Index: " + index + ", Size: " + size ;
}
/**
* 从此列表中删除指定集合中包含的所有元素。
*/
public boolean removeAll ( Collection <?> c ) {
Objects . requireNonNull ( c );
// 如果此列表被修改则返回 true
return batchRemove ( c , false );
}
/**
* 仅保留此列表中包含在指定集合中的元素。
* 换句话说，从此列表中删除其中不包含在指定集合中的所有元素。
*/
public boolean retainAll ( Collection <?> c ) {
Objects . requireNonNull ( c );
return batchRemove ( c , true );
}
 
不如吃茶去（_）
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ArrayList源码.zip
03-13
ArrayList的核心实现是通过一个Object类型的数组来存储元素。当添加元素时，如果当前容量不足，ArrayList会自动扩容，通常扩容为原来的1.5倍。这种设计使得ArrayList在插入元素时有较好的性能表现，但删除元素特别是...
【Java】ArrayList底层源码分析
Zh0uKal1的博客
09-17 351
【Java】ArrayList底层源码分析
ArrayList 源码
ironmanoOOoo的博客
07-22 1711
集合类中，最基础也是最常用的，大概就是ArrayList了吧。ArrayList的本质，是一个可变长的数组。那有人可能就会问，哎呀这个数组老简单了，有什么好看的啊……但事实上，在面试时，有些人还是对源码的细节说不清楚，从而留下较差的印象。这里，我就带着大家，一点一点地梳理一下，ArrayList的底层源码吧。概览..ArrayList类继承自AbstractList类，且实现了List、RandomAccess、Cloneable和Serializable接口。...
ArrayList(源码分析概述)
m0_59031879的博客
08-23 289
####部分源码分析
java---ArrayList源码解析
m0_58196614的博客
08-23 1477
ArrayList 底层就是一个数组，依赖其扩容机制（后面会提到）它能够实现容量的动态增长，所以 ArrayList 就是数据结构中顺序表的一种具体实现。
java arraylist 底层_Java——ArrayList底层源码分析
weixin_29758513的博客
02-23 74
packagejava.util;importjava.util.function.Consumer;importjava.util.function.Predicate;importjava.util.function.UnaryOperator;public class ArrayList extends AbstractListimplements List, RandomAccess, C...
Java中ArrayList类的源码解析
08-31
Java中ArrayList类的源码解析 ArrayList是Java中最常用的集合类之一，它实现了List接口，继承自AbstractList...ArrayList的源码实现是通过elementData数组和size成员变量来实现的，它们都是ArrayList的核心成员变量。
深入Java集合ArrayList的源码解析
12-21
首先，ArrayList的核心数据结构是一个数组，它的默认容量是10，这个信息在源码的第115行有明确表示。默认容量的定义为`DEFAULT_CAPACITY`，值为10。当调用`size()`方法时，返回的是ArrayList中存储的元素数量，这在...
Java集合系列之ArrayList源码分析
08-27
本文将深入ArrayList的源码，探讨其内部实现、构造方法以及增删改查操作。 1. **内部结构与构造方法** ArrayList的核心成员变量是一个Object类型的数组`elementData`，用于存储元素。数组的初始容量默认为10，可以...
java核心技术源码
12-25
Java作为世界上最流行的编程语言之一，其核心技术源码的探索对于开发者来说至关重要。这些源码揭示了Java语言的核心机制，帮助我们理解如何实现高效、稳定和可扩展的软件系统。在这个压缩包中，我们看到一系列与Java...
Java ArrayList的底层实现方法
08-26
今天小编就为大家分享一篇Java ArrayList的底层实现方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
ArrayList 底层源码详解
y13672651519的博客
08-01 677
      我们先复习一下ArrayList：它封装了一系列操作，如增删改查，对比使用传统的数组方便了很多，因为java代码已经替我们写好了，我们直接用即可。       但是，面对即将走向工作岗位的你们，单单知道如何使用远远不够，首先面试官就是一个槛，大部分面试都会问集合的实现原理，这也是大部分面试者的薄弱点。       我们
ArrayList-1
qq_33282559的博客
02-07 239
1. ArrayList 简介 ArrayList的底层是数组队列，相当于动态数组。与 Java 中的数组相比，它的容量能动态增长。在添加大量元素前，应用程序可以使用ensureCapacity操作来增加ArrayList实例的容量。这可以减少递增式再分配的数量。 ArrayList继承于AbstractList，实现了List,RandomAccess,Cloneable,java.io.Serializable这些接口。 public class ArrayLis...
ArrayList底层源码解析
weixin_56777219的博客
05-25 378
ArrayList源码底层解析
ArrayList底层源码和原理详解
qq_41972358的博客
05-21 440
Java中并不是所有数据都能存到数组中去，只有像同数据才可以一起存储到数组中。 数组的查询速度快，增删比较慢。 原因：数组在存储数据时时按顺序存储的，存储数据的内存也是连续的，所以他们的特点就是寻址读取数据比较容易，插入和删除比较困难。 数组删除的时候，简单当数组某个下标位子数据删除后，后面的数据会自动填充上，那么就比较耗时。 ALT+7可以看到类中的方法。 JDK1.7的ArrayList内部的方法。 无参的构造方法： public ArrayList() { super(); this.elementD
JAVA——底层源码阅读——集合ArrayList的实现底层源码分析
weixin_56039103的博客
05-18 747
JAVA——底层源码阅读——集合ArrayList的实现底层源码分析一、提出问题二、查看ArrayList源码步骤1、新建java文件，把代码敲上去如下步骤2、查看源码。1、增add()2、删remove()3、改set()4、查get()步骤3、阅读和分析源码。三、尝试自定义ArrayList 当前 jdk版本：jdk1.8.0_74 一、提出问题 集合ArrayList的底层原理是什么，它的增删改查是怎么实现的，为什么它的长度是可变的？ 二、查看ArrayList源码 步骤1、新建java文件，把代
ArrayList和LinkedList中的get方法底层实现
yang505581644的博客
12-21 4178
1.ArrayList的get方法  因为底层是数组 直接通过下标获得 2.LinkedList的get方法  因为底层是链表,链表没有下标,需要迭代遍历: if (index > 1)) { Node x = first; for (int i = 0; i < index; i++) x =
集合深度学习03—ArrayList核心源码
niTaoTaoa的博客
08-23 222
JDK1.7时 底层是数组，在调用构造器的时候，数组长度初始化为10，扩容的时候为1.5倍。JDK1.8时 底层还是数组，在调用构造器的时候，底层数组为 { }，空数组，在调用add方法后，底层数组才重新赋值为新数组，新数组的长度为10好处是节省内存，在add后才创建长度为10的数组。
ArrayList简介+核心源码
Mrchai521的博客
07-07 186
ArrayList 的底层是数组队列，相当于动态数组。与 Java 中的数组相比，它的容量能动态增长。在添加大量元素前，应用程序可以使用ensureCapacity操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。 它继承于AbstractList，实现了List,RandomAccess,Cloneable,java.io.Serializable这些接口。...
arraylist源码
最新发布
08-04
在ArrayList源码中，我们可以看到它的核心组成部分是一个Object类型的数组elementData来存储元素。当我们向ArrayList中添加元素时，它会根据需要动态调整数组的大小，并将元素添加到数组的末尾。 除了存储元素的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值