ArrayList源码分析

最新推荐文章于 2023-04-11 20:56:00 发布
最新推荐文章于 2023-04-11 20:56:00 发布
阅读量203 收藏 1
点赞数
分类专栏： java集合 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/canimeicaca/article/details/125629826
版权

1.概述

ArrayList实现了List接口，元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现，支持自动扩容。

2.类图

List类图

由类图可知ArrayList实现了4个接口，分别是：

  • List接口，提供数组的添加、删除、修改、迭代遍历等操作
  • RandomAccess 接口，表示 ArrayList 支持快速的随机访问
  • Serializabel接口，支持序列化功能
  • Cloneable接口，支持克隆

3.属性

//无参构造添加第一个元素时会默认初始化容量
private static final int DEFAULT_CAPACITY = 10;
//空的数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//无参构造默认的数组地址
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//元素数组，当初始化无参构造数组时，会默认this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA,目的是节省空间，因为不确定是否使用该集合，当第一次添加元素后，会将容量大小设置为10
//当添加第一个元素时，会将数组扩大至DEFAULT_CAPACITY容量
transient Object[] elementData; 
//数组时机大小
private int size;

ArrayList

  • elementData属性

    元素数组，构造一个空ArrayList时，该属性被初始化DEFAULTCAPACITY_EMPTY_ELEMENTDATA；图中红色空格代表我们已经添加元素，白色空格代表我们并未使用。

  • size属性

    数组大小。注意，size 代表的是 ArrayList 已使用 elementData 的元素的数量，对于开发者看到的 #size() 也是该大小。并且，当我们添加新的元素时，恰好其就是元素添加到 elementData 的位置（下标）。当然，我们知道 ArrayList真正的大小是 elementData 的大小。

4.构造方法

4.1无参构造
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
4.2有参构造-初始化数组大小
private static final Object[] EMPTY_ELEMENTDATA = {};
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);
    }
}
4.3有参构造-传入集合
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;
    }
}

5.添加元素

5.1添加单个元素
/**
 * 添加单个元素
 */
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}
private void ensureCapacityInternal(int minCapacity) {
    //当无参构造初始化集合时，第一次添加元素初始化数组容量为10
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
    //记录修改次数
    modCount++;
	//扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
5.2指定位置添加一个元素
public void add(int index, E element) {
    //校验索引是否非法
    rangeCheckForAdd(index);
	//修改modcount次数，增加容量
    ensureCapacityInternal(size + 1); 
    //从index+1位置复制数组
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}

ArrayList_add

6.数组容量

6.1数组扩容
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        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);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

ArrayList_grow

6.2数组缩容
public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0)
            ? EMPTY_ELEMENTDATA
            : Arrays.copyOf(elementData, size);
    }
}

7.移除元素

7.1移除元素
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 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
}
7.2移除多个元素
public boolean removeAll(Collection<?> c) {
    Objects.requireNonNull(c);
    return batchRemove(c, false);
}
private boolean batchRemove(Collection<?> c, boolean complement) {
    final Object[] elementData = this.elementData;
    int r = 0, w = 0;
    boolean modified = false;
    try {
        for (; r < size; r++)
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
    } finally {
        // Preserve behavioral compatibility with AbstractCollection,
        // even if c.contains() throws.
        //如果 contains 方法发生异常执行该方法
        if (r != size) {
            //elementData就是数组前r+1个元素不变，后面的元素从第w个元素开始替换到size-r长度结束，其中[w-size-r]元素的值分别对应着[elementData[r+1]-elementData[size-r]]的值
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;
        }
        if (w != size) {
            // clear to let GC do its work
            for (int i = w; i < size; i++)
                elementData[i] = null;
            modCount += size - w;
            size = w;
            modified = true;
        }
    }
    return modified;
}

8.查找元素

8.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++)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}
8.2获取指定位置的元素
public E get(int index) {
    rangeCheck(index);

    return elementData(index);
}

9.序列化

为什么ArrayList会自定义序列化方法？因为ArrayList数组elementData中有未使用的空间，如果没有使用的空间也序列化，势必会影响性能。

序列化集合
//transient阻止序列化
transient Object[] elementData; 

/**
 * writeObject方法将其示例序列化
 */
private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException{
    // Write out element count, and any hidden stuff
    int expectedModCount = modCount;
    s.defaultWriteObject();

    // Write out size as capacity for behavioural compatibility with clone()
    s.writeInt(size);

    // Write out all elements in the proper order.
    for (int i=0; i<size; i++) {
        s.writeObject(elementData[i]);
    }

    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}
反序列化
private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    elementData = EMPTY_ELEMENTDATA;

    // Read in size, and any hidden stuff
    s.defaultReadObject();

    // Read in capacity
    s.readInt(); // ignored

    if (size > 0) {
        ensureCapacityInternal(size);

        Object[] a = elementData;
        // Read in all elements in the proper order.
        for (int i=0; i<size; i++) {
            a[i] = s.readObject();
        }
    }
}

10.创建 Iterator 迭代器

public Iterator<E> iterator() {
    return new Itr();
}
/**
 * 迭代器代码
 */
private class Itr implements Iterator<E> {
    //游标
    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    //每修改一次list集合，modCount+1
    int expectedModCount = modCount;

    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        //<1> 校验expectedModCount = modCount是否相等
        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;
            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();
    }
}
  • checkForComodification比较modCount != expectedModCount值不相等抛出ConcurrentModificationException异常
  • #hasNext方法判断游标有没有达到最后位置
  • #next方法，每次移动一次，游标cursor+1
  • #remove方法，会重新调用集合的remove方法，并且重新初始化expectedModCount = modCount，所以用迭代器遍历删除元素不会抛出ConcurrentModificationException异常

11.三种for循环移除元素结果对比

  • fori

    //结果输出 1和3
public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("1");
    list.add("2");
    list.add("3");

    for (int i = 0; i < list.size(); i++) {
        if (list.get(i).equals("2")) {
            list.remove("2");
        }
        System.out.println(list.get(i));
    }
}

  • 增强for组合remove

    增强for本质上是利用迭代器遍历，内部通过判断modCount != expectedModCount是否相等来决定是否抛出异常，当调用list本身的remove方法后，会更新modCount值，但是迭代器中的expectedModCount值未更新，导致抛出异常。

    public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("1");
    list.add("2");
    list.add("3");

    System.out.println(list.size());
    for (String s : list) {
        if ("1".equals(s)) {
            list.remove(s);
        }
    }

}

  • 迭代器组合迭代器的remove

    迭代器的remove与list的remove区别就是，当调用迭代器的方法后，会在最后将modCount的值同步给expectedModCount，所以不会报错。迭代器remove方法如下：

    ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;

    public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("1");
    list.add("2");
    list.add("3");
    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {
        if ("1".equals(iterator.next())) {
            iterator.remove();
        }
    }
}

小结

  • ArrayList 是基于 [] 数组实现的 List 实现类，支持在数组容量不够时，一般按照 1.5 倍自动扩容。同时，它支持手动扩容、手动缩容。
  • ArrayList 随机访问时间复杂度是 O(1) ，查找指定元素的平均时间复杂度是 O(n) 。
  • ArrayList 移除指定位置的元素的最好时间复杂度是 O(1) ，最坏时间复杂度是 O(n) ，平均时间复杂度是 O(n)
  • ArrayList 移除指定元素的时间复杂度是 O(n) 。
  • ArrayList添加元素的最好时间复杂度是 O(1) ，最坏时间复杂度是 O(n) ，平均时间复杂度是 O(n) 。
canimeicaca
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
ArraysList接口所有方法
weixin_53278894的博客
05-04 348
ArraysList接口笔记 ArraysList接口的所有方法及使用方法 boolean add(E e) 将指定的元素追加到此列表的末尾 > .add(); 添加数据 list.add("张三"); list.add(10); list.add(10.0); void add(int index, E element) 在此列表中的指定位置插入指定的元素。 > .add(int index ,E element); 在指定下标位置添加数据 list.
Java集合-List接口-ArrayList类详解
baidu_38126306的博客
09-20 340
Java集合——ArrayList类 1. Java ArrayList特性 ArrayList类是List接口的一个实现类，是一个数组队列，可以动态修改，没有固定大小的限制。 ArrayList 类位于 java.util 包中，使用前需要import它，语法格式如下： import java.util.ArrayList; ArrayList<E> objectName =new ArrayList<>();　 // 初始化 ArrayList底层是用数组实现的存
ArrayList接口
weixin_56948111的博客
05-05 424
ArrayList常用方法… 集合： 称为容器，用于存储、提取、删除数据。JDK提供的集合API都包含在 java.util 包内 接口常用方法： add:将指定的元素追加到此列表的末尾。 == ==:在此列表中的指定位置插入指定的元素。 标记文本 标记文本 标记文本 标记文本 标记文本 标记文本 标记文本 10.标记文本 ...
java框架集合List子接口之ArrayList源码剖析
热门推荐
刘跃辉的博客
09-05 9万+
ArrayList实现了List接口 , 它是有序且可以重复的 , 允许存放所有所有元素 , 包括null , 除了实现List接口之外这个类还提供了一些方法来操作内部存储列表数组的大小 , 这个类大致相当于Vector , 只是它不是同步的 , 同时ArrayList还实现了RandomAccess, Cloneable, java.io.Serializable。
Java—List接口（ArrayList）
一起加油吧~
05-19 8671
今天来看看Java集合中的List集合，为什么List集合中元素能重复？为什么List集合是有序的？我们来共同交流交流 目录 List集合基础概念 List是什么？ 容器类 List集合有什么特点吗？ List底层是什么结构存储的？ List和数组有什么区别？ 为什么数组在末尾添加元素效率高？ 为什么数组检索速度快（为什么ArrayList检索速度快）？ 那使用的时候如何选用是用ArrayList还是数组呢？ 方法有哪些？ List常用算法 LinkedList 单向链表
Java编程中ArrayList源码分析
08-28
主要介绍了Java编程中ArrayList源码分析，具有一定借鉴价值，需要的朋友可以参考下。
ArrayList源码分析(含jdk1.8).pdf
04-24
ArrayList的源码，写了一些自己的分析，包括jdk1.8的新特性
Java集合框架ArrayList源码分析（一）
09-01
主要为大家详细介绍了Java集合框架ArrayList源码分析，感兴趣的小伙伴们可以参考一下
Java集合系列之ArrayList源码分析
08-27
主要为大家详细介绍了Java集合系列之ArrayList源码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
ArrayList 源码深度解析
01-20
ArrayList 源码深度解析 一、重新认识ArrayList 什么是ArrayList？ ArrayList是基于数组实现的List类，封装了一个动态再分配的Object数组，以达到可以动态增长和缩减的索引序列。 长啥样？ 如图，是一个长度为6，...
硬核ArrayList源码分析，答应我每天看一遍好么
12-21
一 前言 知识追寻者目前的系列都是基于jdk1.8进行学习分析；...二 ArrayList源码分析 2.2 空参构造方法源码分析 调试代码 public static void main(String[] args) { // 初始化长度为0 ArrayList list =
ArrayList源码分析.docx 等
02-22
来自视频课笔记 面试肯定没问题 包含线程安全的list和不安全的list
ArrayList源码分析_016.pdf
09-13
ArrayList源码分析_016.pdf
基于jdk1.8 的ArrayList的源码分析
12-22
基于jdk1.8 的ArrayList的源码分析 前言：一说到ArrayList的大家可能立马想到的就是：有序、可重复、查找快但是增删慢、线程不安全。但是具体的原因都不是很清楚，本文就会根据这些问题和大家一起去学习。主要会从...
Java集合——List接口学习总结
最新发布
海旋风的博客
04-11 722
3.Iterable接口是Java集合框架中用于表示“可迭代”的对象的标准接口，它定义了一个iterator()方法，用于返回一个迭代器（Iterator）对象，从而可以遍历集合中的元素。2.Iterator接口是Java集合框架中用于遍历集合元素的标准接口，它定义了一些方法，如hasNext()、next()、remove()等，用于遍历集合中的元素并对其进行操作。其实源码中成员变量上面就有英文解释，简要回答就是保证跨平台，有些虚拟机数组会有会有保留字，出于安全性和健壮性考虑所以做了长度限制。
ArrayList源码分析（超详细）
一条咸鱼的博客
10-05 1682
ArrayList源码详解，面试官：“嗯，回去等通知吧。”
Java集合源码浅析（一） ： ArrayList
冷血之心的博客
04-12 1637
（尊重劳动成果，转载请注明出处：https://yangwenqiang.blog.csdn.net/article/details/105317442冷血之心的博客） 背景 一直都有这么一个打算，那就是将Java中常见集合的源码进行一个全面的梳理（尽管已经有很多人进行了梳理总结）。重复造轮子的意义就在于，笔者可以亲自去阅读与欣赏JDK集合源码，学习JDK设计者们那优雅的code风格。 那么，就...
Arraylist底层源码分析
02-20
Arraylist的底层源码是一个非常复杂的结构，它主要是由一组Object数组来实现的，并且它还使用一个计数器来跟踪元素的数量，以及一个可调节大小的容量来管理数组的大小。而且它在添加或删除元素时还会调整数组大小，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值