Collection探究之ArrayList

最新推荐文章于 2024-09-14 18:46:05 发布
最新推荐文章于 2024-09-14 18:46:05 发布
阅读量262 收藏
点赞数 1
分类专栏： java集合 文章标签： 集合 arraylist java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/witness_mei/article/details/49384593
版权

ArrayList是我们在平时使用的最多的集合类之一，其本质原理为由数组组成的链表，也就是动态数组。由数组的特性我们可以得知在查找数据时，可以根据数组的下标来快速定位我们想查询的数据，效率非常高。但是也具有相应的缺点，由于数组是连续的，所以在插入数据时会牵扯到数组的复制与扩容且在多线程环境下是不安全的，因此ArrayList适合查询多，数据插入少的场合。下面我们来对ArrayList的源码进行探究，俗话说的好，知己知彼百战百胜，只有弄清楚其深层的原理，才能在使用时提高效率，不出差错。

public class ArrayList<E> 
extends AbstractList<E> 
implements List<E>, RandomAccess, Cloneable, java.io.Serializable

我们看到这是ArrayLsit的定义，它继承自AbstractList，实现了List，RandomAccess，Cloneable，java.o.Serializable类。
List：ArrayList类实现了List类中定义的基本方法。
RandomAccess：为标记接口，它表示ArrayList能够对其内部的数据进行快速访问，也就是通过下标访问。
Cloneable：它并没有类的定义，ArrayList类实现了Cloneable接口后，表示ArrayList是可以被复制的，在接下来的源码分析中我们可以看到Cloneable的真正作用。
Serializable：表明ArrayList能够进行序列化传输。

接下来我们看一下ArrayList中定义的属性：


//DEFAULT_CAPACITY表明了ArrayList容器的默认长度为10
    private static final int DEFAULT_CAPACITY = 10;


    private static final Object[] EMPTY_ELEMENTDATA = {};

    //表示默认初始化时为空
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    //elementData为ArrayList中存储的元素，而其类型为Object数组，transient表示在持久化时，elementData并不会被包含入Serializable中，也就是不会被持久化
    transient Object[] elementData; 

    //size为ArrayLsit容器的大小
    private int size;

接下来看一下ArrayList的构造函数，有以下三个

 public ArrayList(int initialCapacity) {
//initialCapacity为ArrayList容器初始化时的容量，若大于0则生成一个大小为initialCapacity的数组
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
//若initialCapacity为0则生成一个空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+                              initialCapacity);
        }
    }

    //无参构造函数
    public ArrayList() {
    //生成一个默认长度的数组
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    //若传入的是一个集合，则调用toArray()方法将该集合的元素转换成为数组返还给elementData
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
       // 若传入的集合长度不为空，且elementData中的元素不为Object
            if (elementData.getClass() != Object[].class)
       //将其元素转换成为Object
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {

            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

说完构造函数，我们在看一下ArrayList中的常用方法，以便对ArrayList内部原理有更好的理解。

   //size（）方法用于返回ArrayList的实际长度。
    public int size() {
        return size;
    }

   //判断Arraylist是否为空
    public boolean isEmpty() {
        return size == 0;
    }

   //判断元素o是否属于该Arraylist
    public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }


    public int indexOf(Object o) {
    //若元素为空，那么就查找出Arraylist中第一个为null的下标并返回
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
  //若不为null，那么就找出Arraylist中第一个与该元素相等的下标
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
   //没有找到就返回－1
        return -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();
         //浅复制，只复制对象的字段值。
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {

            throw new InternalError(e);
        }
    }

  //转换成为一个数组
  public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

下面，我们来看一下ArrayList中的各类操作方法。
1.增加元素

    //set方法是一种覆盖方法，它先确定该下标是否超出Arraylist的长度，若没有，则把index下标的元素用element覆盖掉，并返回原先Arraylist中index位置的元素。
public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

      //add（）方法是我们使用最多的方法，用它我们能向Arraylist中增加元素。
    public boolean add(E e) {
    //增加元素前先判断Arraylist的容量，并再此基础上扩容。
        ensureCapacityInternal(size + 1); 
        //在Arraylist的末尾添加元素e
        elementData[size++] = e;
        return true;
    }

    //向指定的下标index位置处，插入元素
    public void add(int index, E element) {
    //先确定该index是否超出Arraylist的容量
        rangeCheckForAdd(index);
    //用于增加Arraylist的容量
        ensureCapacityInternal(size + 1); 
        //将原来的元素从数组中的从index位置的元素复制到index＋1的位置，共移动size－index个元素，也就是说将index后的元素都向后移动一格。
        System.arraycopy(elementData, index, elementData, index + 1,size - index);
        elementData[index] = element;
        size++;
    }

下面看一下添加方法中用到的扩容方法：

 public void ensureCapacity(int minCapacity) {
     //先判断是否为数组是否为空。
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            ? 0
            : DEFAULT_CAPACITY;
    //若需要的最小容量大于arraylist本来的容量，则进行扩容
        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }
    //该方法用于确保内部容量。
    private void ensureCapacityInternal(int minCapacity) {
    //若数组为空，那么最小需求容量为默认容量与最小需求容量数大的值
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }
    //minCapacity为需求的容量最小值
  private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
    //用于判断是否需要扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    //grow方法用于扩容的真正方法。
 private void grow(int minCapacity) {
   //原数组的长度
        int oldCapacity = elementData.length;
   //新数组的长度为在原数组长度的基础上增加原数组长度上增加原数组长度的一半
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
   //若新数组长度超出了最大数组长度，则使用最大数组长度值
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);

        elementData = Arrays.copyOf(elementData, newCapacity);
    }

2.删除方法

    //删除传入的index下标的元素
 public E remove(int index) {

        rangeCheck(index);

        modCount++;
        //先保存index下标的元素值
        E oldValue = elementData(index);
        //把index+1位置之后的元素都复制到index位置，也就是index＋1之后的numMoved都向前移动一位
        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
        //返回原index位置的值
        return oldValue;
    }

     //用于删除指定元素o
  public boolean remove(Object o) {
     //array中允许放入null元素。若元素为null，则把第一个null给移除
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
    //若o不为null，那么就把第一个与o相等的元素移除
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

    //是Arraylist中的内部删除方法，无需检查是否超出arraylist容量，直接删除index位置的元素
 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
    }
    //用于清除将Arraylist中的元素都置为null
 public void clear() {
        modCount++;

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

3.获取元素

//该方法比较简单，返回index位置的值
 public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }

4.一些特殊方法

    //用于向array list中添加集合
  public boolean addAll(Collection<? extends E> c) {
         //先把需要添加的集合转变为数组
        Object[] a = c.toArray();
        //获取数组长度
        int numNew = a.length;
        //对arraylist进行扩容
        ensureCapacityInternal(size + numNew); 
        //将集合元素追加到需要添加入的arraylist尾部
        System.arraycopy(a, 0, elementData, size, numNew);
        //更新arraylist长度
        size += numNew;
        return numNew != 0;
    }

    //用于判断index是否超出array list的容量
  private void rangeCheck(int index) {
        if (index >= size)
            throw new         IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    //用于移除一定范围内的元素
    protected void removeRange(int fromIndex, int toIndex) {
        modCount++;
    //获取需要移除的部分数组的长度，并将toindex之后的元素按次序移动到fromIndex位置。
        int numMoved = size - toIndex;
        System.arraycopy(elementData, toIndex, elementData, fromIndex,numMoved);

        int newSize = size - (toIndex-fromIndex);
        for (int i = newSize; i < size; i++) {
            elementData[i] = null;
        }
        size = newSize;
    }

以上为Arraylist中的一些主要方法，还有一些比较不常用的方法就不列举出来了，在学习collection的过程中最好还是阅读源码，这能够从源码中了解到该集合方法所表达的思想。本文中都为作者自身的理解，如果有误的地方也请大家指正。

Alvin-M
关注
专栏目录
Collection集合---ArrayList （java）
weixin_45873089的博客
08-06 768
基本知识 1超级父类：Collection–以单个方式存储单元 2.List存储的特点：有序（存入和取出顺序一样），可重复(集合中可以存储多个相同内容的地址)，有下标。 3.ArrayList:底层采用数组进行储存，非限制安全。 4.包含关系 Collection(父类接口)–List(子类接口)–ArrayList(List接口下的类)。 具体功能 实现 public class CollectionTest01 { public static void main(String[] args) { //
数据存储核心之ArrayList源码探究
qibulemingzi的博客
12-08 259
从ArrayList类图结构到源码分析，从源码角度学习ArrayList。探究扩容机制实现原理及深入学习各方法的实现！
Collection探究之Vector
witness_mei的博客
10-31 402
Vector与ArrayList一样内部是由数组组成的，它也是一个动态数组，但是由于其内部实现了线程安全机制，所以在性能方面较差，使用的次数也没有ArrayList那样频繁，下面我们来看一看Vector的源码。1.Vector的定义public class Vector<E> extends AbstractList<E> implements List<E>, RandomAcce
Java之ArrayList源码解读
qq_62592925的博客
12-23 901
ArrayList的底层是数组队列，相当于动态数组。与 Java 中的数组相比，它的容量能动态增长。在添加大量元素前，应用程序可以使用操作来增加ArrayList实例的容量。这可以减少递增式再分配的数量。ArrayList继承于，实现了ListCloneable这些接口。: 表明它是一个列表，支持添加、删除、查找等操作，并且可以通过下标进行访问。：这是一个标志接口，表明实现这个接口的List集合是支持的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象，这就是快速随机访问。
Collection探究之LinkedList
witness_mei的博客
10-25 431
LinkedList与ArrayList一样都是List的实现类，但是它内部结构与ArrayList有着极大的不同。LinkedList内部是由一个双向的链表组成，由链表的特征我们可以知道，LinkedList它插入元素的效率非常高而要查找元素的话因为需要遍历整个链表所以性能比较差。1.LinkedList类定义public class LinkedList<E> extends Abstr
java1.8源码之ArrayList源码解读
热门推荐
技术探求
05-02 1万+
一、ArrayList概述 1.1 ArrayList简介 ArrayList经常用，今天对它的源码探究一二。 一上来顶部有一大串注释，顶部注释参考了这篇博客内容如下： List接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括null在内的所有元素。除了实现List接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于Vector类，除了此类是不同步的。） ...
ArrayLIst源码探究
cstlrx的博客
04-12 265
ArrayList源码
Collection 源码探究
知易行难
06-09 209
ArrayList注意事项: 可以加入null值，并且可以加入多个 底层是有数组来实现数据存储的。 ArrayList基本等同于Vector，处理ArrayList是线程不安全（执行效率高），多线程情况下，不建议使用ArrayList. 源码分析: ArrayList 1. ArrayList维护了一个Object类型的数组 elementData。 transient Object[] elementData。 transient 表示短暂、瞬间的意思，修饰属性时，表示不会被序..
ArrayList源码分析
lisa2017_的博客
09-15 54
#ArrayList源码分析 https://www.cnblogs.com/zhangyinhua/p/7687377.html https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/collection/ArrayList-Grow.md https://www.jianshu.com/p/2cd7be850540 1、ArrayList定义 public class ArrayList<E> extends Abstra
Java List 扩容机制探究（ArrayList 、Vector、LinkedList）
流楚丶格念的博客
10-16 3058
ensureExplicitCapacity方法会调用grow方法，扩容1.5倍，就是在此发生的。ensureCapacityInternal方法会调用ensureExplicitCapacity方法来确保空间，modCount用来多线程的判断，此处不赘述。调试下我们可以发现，虽然elementData进行了扩容，但是实际大小还是元素的个数，别被唬住了。方法，capacityIncrement默认是0，所以等价。初始化会默认调用无参，再调用有参数构造器，空间默认10。这是第二次扩容为，扩容为15。
ArrayList 和 顺序表
TheDevice的博客
04-13 677
ArrayList 和 顺序表 ArrayList的使用 1.ArrayList的构造 2. ArrayList常见的方法 3. ArrayList的遍历 ArrayList的扩容机制
Java基础16 集合（ArrayList、LinkedList
qdwd888的博客
04-27 184
如何保存数据？Object类型的一维数组 transient Object[] elementData; 数组初始长度是多少？10 private static final int DEFAULT_CAPACITY = 10; ArrayList是如何动态扩容的？如果数据的个数超过原来的容量，就将容量扩展为原来的1.5倍，然后复制数据到新数组中。 private void grow(int minCapacity) { // overflow-conscious code int oldCapacity =
Java中ArrayList的扩容机制
qq_38248609的博客
05-21 406
在java开发工作中经常会用到List、Set、Map这三种集合类型，其中List又有ArrayList和LinkedList，其中ArrayList底层是实现采用的是可变的Object[]数组实现，LinkedList底层采用双向链表实现（JDK1.6之前为循环链表，JDK1.7取消了循环，有兴趣的同学可以去查询一下相关资料，这里不做论述）。众所周知，JAVA中是集合与数组最重要...
List<String> list=new ArrayList<String>();与ArrayList<String> list=new ArrayList<String>();
IWTSAMY的博客
04-26 3395
如何理解:List list=new ArrayList();为甚麼要声明为List 而不是ArrayList? ArrayList LinkedList 都是List 的子类，就像 Set 也是Collection 的子接口。 首先我们探究一下类的继承 对于java的对象，从类的继承关系来说，父类为上，子类为下，所以向上转型就是从子类型转换成父类型，而想下转型就是从父类型转化成子类型。 publ...
Java-网络
最新发布
2301_81543552的博客
09-14 468
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
上传文件到钉盘流程详解
jspyth的博客
09-14 502
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Java集合：Stack详解
yang_brother的博客
09-10 609
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
C++位图的实现与详解
2301_80468112的博客
09-09 667
在讲解位图之前我们先来看一道很经典的面试题。给40亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在这40亿个数中。我们有以下两种种解决方法：1. 遍历，时间复杂度O(N)。（太慢）2. 排序(O(NlogN))，利用二分查找: logN。深入分析:解题思路2是否可行，我们先算算40亿个数据大概需要多少内存。
Collection接口与ArrayList的使用
06-09
而ArrayList是Collection接口的一个实现类，它是一个可调整大小的数组实现，可以存储任意类型的对象。 使用ArrayList时，首先需要创建一个ArrayList对象，例如： ``` ArrayList<String> list = new ArrayList(); `...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值