ArrayList源码解析（中）

最新推荐文章于 2022-04-25 20:34:59 发布
最新推荐文章于 2022-04-25 20:34:59 发布
阅读量763 收藏
点赞数
分类专栏： 【源码解析】 JDK源码解析 文章标签： 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laiwenqiang/article/details/54924093
版权

判断元素位置

这些函数都相对简单。因为存储的元素可能为null，所以判断的时候多了一次。

public int size() {
    return size;
}

public boolean isEmpty() {
    return size == 0;
}

public boolean contains(Object o) {
    return indexOf(o) >= 0;
}

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;
}

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;
}

数组转化

  1. toArray()重载了两个方法，其中一个返回Object[]，另外一个返回指定类型的数组。
  2. 对于有参的方法的调用建议：传入一个空的对象，如 new Integer[]{} 作为参数。
  3. 关于ClassCastException异常：经常会需要将ArrayList里的内容转化为特定类型的数组，但是如果使用无参的toArray()进行强制转换，就会出现ClassCastException异常。此时需要使用第二个有参的方法。例如类似于：
    (Integer[]) ArrayList某个实例.toArray(new Integer[]{})。
  4. 在我们使用 T[] toArray(T[] a) 的时候还需要再一次进行显式的转化，这点有点不懂。因为这个函数内部已经转化了，但是我们还需要 (Integer[]) ArrayList某个实例.toArray(new Integer[]{}) 这么写，而不是 ArrayList某个实例.toArray(new Integer[]{}) 这么写？
  5. 依旧是有参的那个函数，如果传入的参数的长度大于size，得到的结果会变得没有使用意义，正如下面代码注释里演示的一样。
public Object clone() {
        try {
            @SuppressWarnings("unchecked")
                ArrayList<E> v = (ArrayList<E>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError();
        }
    }

public Object[] toArray() {
    return Arrays.copyOf(elementData, size);
}

@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
    if (a.length < size)
        // Make a new array of a's runtime type, but my contents:
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    System.arraycopy(elementData, 0, a, 0, size);
    // 如果a的长度大于size，a[size] = null，这个逻辑不知为何这么设计，不理解
    // 比如elementData{1,2}, a{3,4,5}, 得到的结果会是{1,2,null,4,5}
    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) {
    rangeCheck(index);

    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}
  1. add操作时怎么扩充容量？调用ensureCapacityInternal(size + 1) 方法，如果 size+1 < elementData.length，则表示容量充足，不需要扩充；如果反之，那么容量扩充到原来的elementData.length 的1.5倍。
  2. 在进行add操作的时候，都会尝试对elementData扩充容量(ensureCapacityInternal()方法)，这里有个提升效率的技巧，详见ArrayList源码解析（上）的 “关于扩展容量的相关操作” 段落。
/**
* 每次进行增加操作的时候，都会尝试扩充elementData的容量
*/
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

public void add(int index, E element) {
    rangeCheckForAdd(index);

    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}

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;
}
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;
}

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
}

public void clear() {
    modCount++;

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

    size = 0;
}

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));
}

private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

private String outOfBoundsMsg(int index) {
    return "Index: "+index+", Size: "+size;
}

public boolean removeAll(Collection<?> c) {
    return batchRemove(c, false);
}

public boolean retainAll(Collection<?> c) {
    return batchRemove(c, true);
}

关于batchRemove()方法
1. 批量删除的方法，具体是对集合c和elementData的交集处理，这里详细说明一下。

假如集合c和elementData的交集是U，那么，
如果complement是true，elementData最终会只存储U；
如果complement是false，elementData最终删除U。

2. 在对elementData的元素进行筛选的时候，这里使用了r、w两个游标，从而避免从新开辟一个新的数组进行存储。这种方法也是比较常见的一种算法题。

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.
        if (r != size) {
            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;
}
laiwenqiang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
阿里面试题目
haochajin的博客
10-21 500
晚上正在公司加班，突然收到阿里的电话，其实之前已经面试过阿里的杭州岗位，只不过连电话面试都没通过就被刷下来了。现在又来了一次，被问到了以下的题目： 1、Java引用类型有哪些 Java不同于C/C++，不需要程序员来管理内存，Java会自己进行内存回收，回收操作通过垃圾收集器线程进行处理，jvm在进行垃圾收集的时候，需要判断哪些对象需要销毁，这时就与这几种引用类型相关。 强引用（Strong...
数据结构与算法-ArrayList-add(E e)方法源码分析
闲言
07-14 346
查看ArrayList的初始化   在创建ArrayList 集合的时候，如果不指定集合的长度，就走空参构造方法，在构造方法内部为 elementData属性赋初始值（DEFAULTCAPACITY_EMPTY_ELEMENTDATA） public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }   可以看到DEFAULTCAPACITY_EMPTY_ELEMENTDATA .
System.arrayCopy( )函数
chouya8141的博客
04-24 188
以ArrayList集合中remove为例子： public E remove(int index) { rangeCheck(index); modCount++; E oldValue = elementData(index); ...
jQuery 获取与设置 元素属性【一篇文章轻松拿下】
weixin_52212950的博客
04-25 5976
hello大家好呀！此篇文章带领大家熟练掌握 jQuery 的属性方面的操作，包括固有属性的获取与设置，自定义属性的获取与设置等等，走进 jQuery 的更深层次阶段 一：固有属性的设置与获取 prop 什么是固有属性？固有属性即标签本身具有的属性，例如 a 标签的 href 属性，input 标签的 type 属性，这些就叫做元素的固有属性，此版块我们要学会获取与设置其固有属性。 1.1 固有属性的获取 element.prop('属性名') <b...
【Java】集合源码 - ArrayList
zhangshuo的博客
10-31 217
ArrayList1. 概述2. 类3. 属性4. 方法构造方法add()add(index)remove()removeAll()retainAll()batchRemove()indexOf()get(int)set(int, E) 1. 概述 ArrayList 是 List 的一个实现, 其底层使用数组来存储元素, 且支持数组动态扩容 因为底层使用数组, 所以 ArrayList 的查找较...
ArrayList 源码深度解析
01-20
ArrayList 源码深度解析 一、重新认识ArrayList 什么是ArrayList？ ArrayList是基于数组实现的List类，封装了一个动态再分配的Object数组，以达到可以动态增长和缩减的索引序列。 长啥样？ 如图，是一个长度为6，...
Java中ArrayList类的源码解析
08-31
Java中ArrayList类的源码解析 ArrayList是Java中最常用的集合类之一，它实现了List接口，继承自AbstractList抽象类。在ArrayList中，我们可以看到它的源码实现了Iterable接口、List接口和Collection接口。下面我们...
第二章 ArrayList源码解析1
08-04
第二章 ArrayList源码解析 ArrayList是Java集合框架中的一种动态数组，它继承自AbstractList，并实现了List接口。ArrayList主要用于存储可变大小的对象列表，它的核心是通过一个Object类型的数组elementData来实现...
ArrayList源码解析
10-08
ArrayList源码解析，如果想要深层了解ArrayList的实现的话，可以下载看看。
ArrayList源码分析
05-05
本篇文章将深入探讨ArrayList的源码，了解其内部实现机制，以及在实际编程中如何有效地使用ArrayList。 1. **ArrayList的构造函数** ArrayList提供了多个构造函数，包括无参构造、指定容量构造和初始化容量并赋值...
组件element------data组件
weixin_45343884的博客
08-07 998
（1）Table 表格 基础表格-------基础的表格展示用法。 —当el-table元素中注入data对象数组后，在el-table-column中用prop属性来对应对象中的键名即可填入数据，用label属性来定义表格的列名。可以使用width属性来定义列宽。 <template> <el-table :data="tableData" ...
JDK源码（二十二）：ArrayList
u011175079的博客
05-26 174
java.util.ArrayList是实现List接口的可调整大小的数组实现。实现所有可选的列表操作，可以存储所有类型元素，包括null。除了实现List接口之外，这个类还提供了一些方法来操作内部用于存储列表的数组的大小。（这个类大致相当于Vector，只是它是非同步的）。 类名 public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess,
【Java集合源码剖析】ArrayList源码剖析
ZWF564267707的博客
12-23 166
转载请注明出处：http://blog.csdn.net/ns_code/article/details/35568011 本篇博文参加了CSDN博文大赛，如果您觉得这篇博文不错，希望您能帮我投一票，谢谢！ 投票地址：http://vote.blog.csdn.net/Article/Details?articleid=35568011 ArrayList简介 ...
System.arraycopy
weixin_30302609的博客
09-11 68
public static void　arraycopy(Objectsrc, intsrcPos, Objectdest, intdestPos, i...
ArrayList源码剖析
为了明天的美好
07-08 866
注：本文转自：http://blog.csdn.net/ns_code/article/details/35568011ArrayList简介 ArrayList是基于数组实现的，是一个动态数组，其容量能自动增长，类似于C语言中的动态申请内存，动态增长内存。ArrayList不是线程安全的，只能用在单线程环境下，多线程环境下可以考虑用Collections.synchronizedList
System.arraycopy和Arrays.copyOf的原理解剖
weixin_33757609的博客
10-17 1088
数组的复制其实在很多业务情况下会用到，不同的业务情况下选择适合的方式来实施复制是每个开发人员要考虑的事情。那么System.arraycopy、Arrays.copyOf到底是如何复制的呢？接下来就一起来讨论一下吧。arraycopyarraycopy是System提供的native静态方法，方法原型如下；public static native void arraycopy(Object arg...
ArrayList拷贝
wwhhff11
07-22 588
ArrayList深拷贝：elementData = Arrays.copyOf(elementData, size, Object[].class);public static void main(String[] args) { ArrayList<Integer> list = new ArrayList<>(); // list.add(1); //
ArrayList源码阅读笔记
三分恶的博客
08-16 723
简介 ArrayList是基于数组实现的一种列表。 ArrayList继承体系如下： 图一：ArrayList继承体系 ArrayList实现了List, RandomAccess, Cloneable, java.io.Serializable等接口。 ArrayList实现了List，提供了基础的添加、删除、遍历等操作。 ArrayList实现了RandomAccess，提供了随机访问的能力。 ArrayList实现了Cloneable，可以被克隆。 ArrayList实现了Ser
arraylist 源码解析
最新发布
06-10
下面是ArrayList的源码解析： 1. 成员变量 ```java /** * Default initial capacity. */ private static final int DEFAULT_CAPACITY = 10; /** * Shared empty array instance used for empty instances. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值