ArrayList详解

最新推荐文章于 2022-08-22 13:18:16 发布
最新推荐文章于 2022-08-22 13:18:16 发布
阅读量268 收藏 1
点赞数 1
分类专栏： JavaSE基础学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42414244/article/details/116706692
版权

简介

ArrayList 是 java 集合框架中比较常用的数据结构了。继承自 AbstractList，实现了 List 接口。底层基于数组实现容量大小动态变化。允许 null 的存在。同时还实现了 RandomAccess、Cloneable、Serializable 接口，所以ArrayList 是支持快速访问、复制、序列化的。

成员变量：

在这里插入图片描述
从上图我们可以看到，ArrayList的初始长度为10，我们要注意下ArrayList真实结构上的这段注释

/**
 * The array buffer into which the elements of the ArrayList are stored.
 * 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.
 */

这段注释讲了四点

1、这个Object[]elementData是ArrayList存储元素的数组缓冲区
2、ArrList的长度就是这个数组缓冲区的长度
3、任何初始的空ArrList的初始时默认使用Object[]DEFAULTCAPACITY_EMPTY_ELEMENTDATA这个空数组 
4、只有当第一个元素添加的时候才会被扩容至默认的10长度的数组

ArrayList的构造方法

/**
     * 构造具有指定初始容量的空列表。
     * @param  initialCapacity  列表的初始容量
     * @throws IllegalArgumentException
     */
    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);
        }
    }
 
    /**
     * 构造一个初始容量为10的空列表。
     * MARK:
     * 这里其实是赋值了一个共享的空数组，数组在第一次添加元素时会判断elementData是否等于DEFAULTCAPACITY_EMPTY_ELEMENTDATA，假如等于则会初始化容量为DEFAULT_CAPACITY 也就是10
     * 符合 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 的注释说明
     * private static int calculateCapacity(Object[] elementData, int minCapacity) 这个方法里可以看出
     *
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
 
    /**
     * 构造一个包含指定元素的列表集合
     * @param c 要将其元素放入此列表的集合
     * @throws NullPointerException if the specified collection is null
     */
    public ArrayList(Collection<? extends E> c) {
        //  这里说明所有的 Collection 都可以用数组来承载
        //  这个步骤可能会抛空指针 NullPointerException
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            //必须是Object数组
            if (elementData.getClass() != Object[].class)
                // 然后再copy一份到 elementData 并不是引用 所有改变不会影响到原先的Collection
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // 有参构造函数 当初始化为空数组时 赋值为 EMPTY_ELEMENTDATA
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }
 
    /**
     * 这里属于针对初始化时的扩容判断 当为DEFAULTCAPACITY_EMPTY_ELEMENTDATA 时说明是无参构造函数创建的，则可以直接扩容为DEFAULT_CAPACITY也就是10为初始容量
     */
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

ArrayList存在两种构造函数：

  • 无参构造，直接默认的空数组赋值给到了elementData
  • 有参构造，根据传入的容量大小来创建数组，不一样的是，这样初始化长度为0的时赋值的不是默认的空数组，而是另一个空数组
    这里有个小疑问，为什么两者都用空数组，为什么要用两个，大家都共享一个空数组不就行了，为什么要不同?我查阅了一些资料，下面来详解一下这个问题

从上面3个构造函数里可以看出，无参构造函数的空数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA赋值，有参构造函数的空数组会用EMPTY_ELEMENTDATA赋值，在增加元素时会先做扩容判断调用calculateCapacity方法，假如elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA就会直接扩容为默认容量10。

这个意思我理解，这是当使用无参构造创建实例，并且向这个实例中添加元素，会自动触发扩容到10的操作。如果构造函数都共享一个空数组时，就会全部触发扩容到10这个机制，但是这未必是我们想要的，也许我们只需要5个容量呢，所以这里使用了两个空数组来对应无参构造函数和有参构构造函数！下面用代码去验证一下，所以还是我想的太多，用两个不同的空数组还是有其道理的，可以有效应对不同的需求

import java.lang.reflect.Field;
import java.util.*;

public class Solution {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        ArrayList<Integer> list1 = new ArrayList<Integer>(0);
        list.add(1);//会触发自动扩容机制，扩容到10
        System.out.println(getArrayListCapacity(list));
        list1.add(1);//不会触发上面的扩容机制，容量应该为1
        System.out.println(getArrayListCapacity(list1));
        for(int i=0;i<10;i++){//当容量容纳不下元素，会自动扩容原数组长度的0.5倍，新数组长度为原来的1.5倍，将旧数组元素拷贝到新数组
            list.add(0);
        }
        System.out.println(getArrayListCapacity(list1));
    }
    //利用反射获取私有的element数组的长度，即ArrayList的容量
    public static int getArrayListCapacity(ArrayList<?> arrayList) {
        Class<ArrayList> arrayListClass = ArrayList.class;
        try {
            Field field = arrayListClass.getDeclaredField("elementData");
            field.setAccessible(true);
            Object[] objects = (Object[]) field.get(arrayList);
            return objects.length;
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
            return -1;
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            return -1;
        }
    }
}

输出：

10
1
15

这里还学习了ArrayList的扩容机制！！！

常用方法解析

  • add()方法，向容器中插入元素
public class Solution {
    public static void main(String[] args) {
        ArrayList<Integer> list=new ArrayList<>();
        for(int i=0;i<10;i++){
            list.add(i);
        }
        System.out.println(list);
    }
}

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  • get(int index)：ArrayList无法直接使用下标来访问对应的元素，通过get()方法，来获取下标对应的元素
public class Solution {
    public static void main(String[] args) {
        ArrayList<Integer> list=new ArrayList<>();
        for(int i=0;i<10;i++){
            list.add(i);
        }
        System.out.println(list);
        System.out.println(list.get(0));
    }
}

输出：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0
  • size()方法：容器中元素个数
public class Solution {
    public static void main(String[] args) {
        ArrayList<Integer> list=new ArrayList<>();
        for(int i=0;i<10;i++){
            list.add(i);
        }
        System.out.println(list.size());
    }
}

输出：

10
  • clear()：清空容器中所有元素
public class Solution {
    public static void main(String[] args) {
        ArrayList<Integer> list=new ArrayList<>();
        for(int i=0;i<10;i++){
            list.add(i);
        }
        System.out.println(list);
        list.clear();
        System.out.println(list);
    }
}

输出：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[]
  • contains()方法，判断容器中是否含有某个元素
public class Solution {
    public static void main(String[] args) {
        ArrayList<Integer> list=new ArrayList<>();
        for(int i=0;i<10;i++){
            list.add(i);
        }
        boolean isExist=list.contains(1);
        boolean isExist1=list.contains(100);
        System.out.println(isExist);
        System.out.println(isExist1);
    }
}

输出：

true
false
  • remove()方法：移除某个元素
remove方法有两种重载的方式：①移除某个元素值，②移除下标为index的元素
public class Solution {
    public static void main(String[] args) {
        ArrayList<Integer> list=new ArrayList<>();
        for(int i=0;i<10;i++){
            list.add(i);
        }
        boolean success=list.remove((Integer)1);
        System.out.println(list);
        Integer removeNumber=list.remove(1);
        System.out.println(list);
        System.out.println(success);
        System.out.println(removeNumber);
    }
}

输出：

[0, 1, 2, 3, 4, 5, 6, 7, 8]
[0, 2, 3, 4, 5, 6, 7, 8]
true
1

重点：

  • ArrayList底层是基于数组实现容量大小动态可变。当触发扩容机制时候，新数组的容量为原数组的1.5倍，再将原数组拷贝到新数组。

总结平常遇到的问题和知识，如果有什么不对的地方请指赐教！

文章内容参考了一下博客：

https://blog.csdn.net/m0_53121042/article/details/110464378
https://blog.csdn.net/lucky1521/article/details/79966743
https://blog.csdn.net/jy317358306/article/details/111633841
城边小河
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
ArrayList解读
gongdy的博客
11-03 256
文章目录ArrayList构造函数ArrayList 重要的成员变量ArrayList 扩容机制ArrayList modCountArrayList Sizearraycopy(Object src, int srcPos,Object dest, int destPos,int length)ArrayList 为什么不能遍历删除ArrayList foreach 删除ArrayList ...
这可能是最细的ArrayList详解了！
weixin_44028058的博客
09-11 649
手撕ArrayList源码 文章首发于GitHub开源项目: Java超神之路 ArrayList 简介 ArrayList 是一个数组列表。它的主要底层实现是Object数组，但与 Java 中的数组相比，它的容量能动态变化，可看作是一个动态数组结构。特别注意的是，当我们装载的是基本类型的数据 int，long，boolean，short，byte… 的时候，我们只能存储他们对应的包装类。 ArrayList 特点 元素有序，可重复 增删元素的速度慢，每次增加删除元素，都需要更改数组长度、拷贝
ArrayList源码深度解析
ch98000的博客
08-22 231
ArrayList是一个顺序的容器，底层实际上是一个数组，可以动态扩容，所以使用起来非常方便，也是程序员非常爱用的一个容器，那它底层的扩容机制是怎么样的呢？是如何添加元素的呢？那我们基于jdk8来一探究竟。ArrayList的基本使用可以参考ArrayList使用详解增删改查中， 增导致扩容，则会修改modCount, 删除也会修改modCount。改和查一定不会修改modCount。扩容操作会导致数组复制，批量删除会导致找出两个集合的交集，以及数组复制操作，因此，增、删都相对低效。
java关键字ArrayList详解
最新发布
07-04
ArrayList是Java集合框架中的一种重要实现，它是List接口的一个具体类，主要特点是基于数组实现，提供了灵活的元素存储和操作。ArrayList支持动态扩容，可以根据需要自动增加数组的大小，这使得在不知道确切元素数量...
ArrayList详解和使用示例_动力节点Java学院整理
08-30
"ArrayList详解和使用示例" ArrayList是Java中的一种动态数组，相比于传统数组，它的容量可以动态增长。在本文中，我们将对ArrayList进行详细的介绍，并提供相关的使用示例代码。 ArrayList简介 ArrayList是一个...
Java 集合系列（二）ArrayList详解
08-26
Java 集合系列（二）ArrayList详解 在 Java 集合系列中，ArrayList 是一个非常重要的部分，它通过一个数组来实现，因此它是在连续的存储位置存放对象的引用，只不过它比 Array 更智能，能够根据集合长度进行自动扩...
C# 中 Array和 ArrayList详解及区别
12-31
C# 中 Array和 ArrayList详解及区别 一、Array 的用法 type[] typename=new type[size];  或者  type[] typename=new type[]{ };  Array类型的变量在声明的同时必须进行实例化(如果初始化至少得初始化数组...
ArrayList中elementData为什么被transient修饰？
try to do
06-25 553
转自 https://blog.csdn.net/zero__007/article/details/52166306 Java的ArrayList中,定义了一个数组elementData用来装载对象的，具体定义如下： /** * The array buffer into which the elements of the ArrayList are stored. ...
ArrayList 详解
祈祷之手
07-03 1021
目录 构造简介 创建对象 第一种 空构造 第二种 默认初始化容量 第三种 复制目标集合 核心价值 add 添加 add 总结 remove 删除 删除对象 删除索引 低价值 get 获取对象 set 设置指定位置的值 contains indexOf 拓展 序列化 写入 最大容量判断 modCount 遍历细节详解 构造简介 创建对象 通过ne...
ArrayList详解（快来看看叭～）
m0_52083255的博客
10-26 179
**List 的实现类之一--------ArrayList ** ArrayListArrayList 介绍ArrayList 使用ArrayList 的 3 种构造方式ArrayList 的常见方法ArrayList 的遍历ArrayList 扩容机制模拟实现 ArrayList ArrayList 介绍 ArrayList 是一个普通的类，底层是一段连续的空间，还可以动态扩容，是一个动态类型的顺序表。它继承自 AbstractList, 实现了 List 接口，同时实现了 RandomA.
我们通过源码来聊一下Java中的多种List
06-25 487
【干货预警，强烈建议关注收藏阅读】 【干货预警，强烈建议关注收藏阅读】      本篇是Java基础中最重要的知识点集合。Java集合是java提供的工具包，包含了常用的数据结构：集合、链表、队列、栈、数组、映射等。Java集合工具包位置是java.util.*，Java集合主要可以划分为4个部分：List列表、Set集合、Map映射、工具类(Iterator迭代器、Enumeration枚举类、Arrays和Collections)。接下来我们一起学习
ArrayList解析
zgsxhdzxl的博客
02-20 180
ArrayList 内部存储结构是Object类型的数组。构造ArrayList时，如果传入初始大小，那它将新建一个指定大小的数组，否则建空数组。查找、修改速度快，增加、删除速度慢，ArrayList是非线程安全的。 增(添加)：仅是将这个元素添加到末尾。操作快速。 增(插入)：由于需要移动插入位置后面的元素，并且涉及数组的复制，所以操作较慢。 删：由于需要将删除位置后面的元素向前挪...
Java进阶--深入理解ArrayList实现原理
热门推荐
有图有真相
05-19 3万+
ArrayList简介ArrayList就是动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了动态的增加和减少元素，实现了Collection和List接口，可以灵活的设置数组的大小。要注意的是ArrayList并不是线程安全的，因此一般建议在单线程中使用ArrayList。ArrayList的继承关系public class ArrayList<E> extends Abstract
java集合之ArrayList详解
sspudding
02-23 532
ArrayList 是一个数组队列，相当于动态数组。 与Java中的数组相比，它的容量能动态增长。 它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。 一、所在包 集合存在于java.util包路径下 二、特点 重复性：数据可以重复 null值：可以有null值存在 有序性：能保证插入的数据有序...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值