Java 基础 - ArrayList 源码

最近发现有些源码直接翻译英文注释就可以了，论学好英语的重要性，之后的源码就以翻译注释为主了

继承


这些个接口或类基本都认识，不多介绍，主要介绍 RandomAccess 接口；
RandomAccess 接口也是一个空接口，作用可以看接口的注释：

Marker interface used by List implementations to indicate that they support fast (generally constant time) random access. The primary purpose of this interface is to allow generic algorithms to alter their behavior to provide good performance when applied to either random or sequential access lists.
这段话翻译的意思是：

List 实现使用的标记接口，指示它们支持快速（通常是恒定时间）随机访问。此接口的主要目的是允许通用算法在应用于随机或顺序访问列表时更改其行为以提供良好的性能。
很容易想到 ArrayList 是数组实现，可以通过下标轻松实现随机访问，添加这个标记接口就是为了区分 LinkedList，在循环时，ArrayList 使用 for 循环，而 LinkedList 使用迭代器。

变量

// 默认容量为10
private static final int DEFAULT_CAPACITY = 10;
//构造方法中容量为0或传入空集合时的空实例
private static final Object[] EMPTY_ELEMENTDATA = {};
//用户使用默认容量且没有添加一个元素的时候的空示例
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 元素数组
transient Object[] elementData;
//列表长度
private int size;
//最大容量
 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//  从结构上修改此列表的次数。结构修改是那些改变列表大小的修改，或者以其他方式干扰列表，使得正在进行的迭代可能产生不正确的结果。
protected transient int modCount = 0;

核心函数

扩容
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
// 默认1.5倍扩容
        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);
    }
查找
// 非空情况下使用for循环+equals实现，lastIndexOf同理
   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 E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }
 E elementData(int index) {
        return (E) elementData[index];
    }
更新
// 将指定位置的值更新
public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }
添加
// 尾部添加
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!!
//需要从index到尾部的所有元素往后移一位
        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)
//需要从index到尾部的所有元素往前移一位
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work，清除尾部元素方便GC清理

        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;
    }
// 删除指定位置元素但是并没有返回值，也没有更新modCount
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
    }

批量删除

// complement为true，list删除x部分，反之list删除y部分
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.
        //发生异常时，将list中未处理的部分复制到已处理的后面
            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;
    }

内部类

Itr

迭代器的实现类，实现类中有一个新方法 public void forEachRemaining(Consumer<? super E> consumer),这个方法是用 Lambda 实现之前的迭代器遍历。
Consumer<? super E>这个函数接口接收一个泛型 T，没有返回值，所以 Lambda 形式的迭代器遍历方式为：

List a = new ArrayList();
Iterator it = a.iterator();
it.forEachRemaining(obj -> System.out.println(obj.toString()));

这个方法也是要改变迭代器游标的。所以只能使用一次，再次使用就没有元素可以用了。

ListItr

ListItr 继承自 Itr，他除了拥有 Itr 的全部方式，还拥有往前滑动游标的方法，意思是它是一个双向迭代器，可以往后滑，也可以往前。使用方法为：

List a = new ArrayList();
//游标从0开始
ListIterator it = a.listIterator();
//游标从2开始，即从第三个元素开始
ListIterator it = a.listIterator(2);

SubList

继承自 AbstractList，相当于一个拥有偏移量的 List，所有的操作都需要指定位置加上偏移量后进行。作用是成产一个 List 的子 List，但是内部保存有被截取的 list 的引用，所以对它的操作也会影响原有的 list。使用时需谨慎。
使用方法为：

List<String> l = new ArrayList<>();
        l.add("a");
        l.add("b");
        l.add("c");
        l.add("d");
        l.add("e");
        l.add("f");
        l.add("g");
        System.out.println(l);
        List<String> sl = l.subList(1,4);
        System.out.println(sl);
        sl.clear();
        System.out.println(sl);
        System.out.println(l);

ArrayListSpliterator

拆分器，实现了 Spliterator 接口。拆分器的作用为用于遍历和划分源元素的对象。拆分器覆盖的元素源可以是数组、集合、IO 通道或生成器函数。是 1.8 后为 Stream 提供支持的类。其方法跟迭代器差不多，tryAdvance(Consumer<? super T> action)跟next()作用类似，不过 tryAdvance 可以直接传入一个方法对当前游标指向的元素进行操作，forEachRemaining跟迭代器中的 forEachRemaining 使用方法和作用也一模一样，Spliterator<T> trySplit();可以拆分出一个一半大小的拆分器。

作者：suruns
链接：http://pipe.suruns.com/blogs/suruns/articles/2020/01/10/1578644068949
来源：Pipe
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

原文地址：https://www.cnblogs.com/suruns/p/12185876.html

时间： 2024-10-25 23:46:54

Java 基础 - ArrayList 源码的相关文章

Java笔记---ArrayList源码分析

一.前言 一直就想看看java的源码,学习一下大牛的编程.这次下狠心花了几个晚上的时间,终于仔细分析了下 ArrayList 的源码(PS:谁说的一个晚上可以看完的?太瞎扯了).现在记录一下所得. 二.ArrayList 源码分析 2.1 如何分析? 想要分析下源码是件好事,但是如何去进行分析呢?以我的例子来说,我进行源码分析的过程如下几步: 找到类:利用 Eclipse 找到所需要分析的类(此处就是 ArrayList) 新建类:新建一个类,命名为 ArrayList,将源码拷贝到该类.因为我

Java基础——集合源码解析 List List 接口

今天我们来学习集合的第一大体系 List. List 是一个接口,定义了一组元素是有序的.可重复的集合. List 继承自 Collection,较之 Collection,List 还添加了以下操作方法 位置相关:List 的元素是有序的,因此有get(index).set(index,object).add(index,object).remove(index) 方法. 搜索:indexOf(),lastIndexOf(); 迭代:使用 Iterator 的功能板迭代器 范围性操作:使用 s

Java集合---ArrayList源码

本文转载自博客园牛奶.不加糖 原文地址:http://www.cnblogs.com/ITtangtang/p/3948555.html 本文仅供本人学习参考使用,如有侵权立即删除. 一. ArrayList概述: ArrayList是基于数组实现的,是一个动态数组,其容量能自动增长,类似于C语言中的动态申请内存,动态增长内存. ArrayList不是线程安全的,只能用在单线程环境下,多线程环境下可以考虑用Collections.synchronizedList(List l)函数返回一个线程安

Java中ArrayList源码分析

一.简介 ArrayList是一个数组队列,相当于动态数组.每个ArrayList实例都有自己的容量,该容量至少和所存储数据的个数一样大小,在每次添加数据时,它会使用ensureCapacity()保证容量能容纳所有数据. 1.1.ArrayList 的继承与实现接口 ArrayList继承于AbstractList,实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口. public class  ArrayList<E> ex

Java之ArrayList源码解读（JDK 1.8）

java.util.ArrayList 详细注释了ArrayList的实现,基于JDK 1.8 . 迭代器SubList部分未详细解释,会放到其他源码解读里面.此处重点关注ArrayList本身实现. 没有采用标准的注释,并适当调整了代码的缩进以方便介绍 import java.util.AbstractList; import java.util.Arrays; import java.util.BitSet; import java.util.Collection; import java.

Java基础——HashMap源码分析

本篇介绍的HashMap综合了ArrayList和LinkedList这两个集合的优势,它的底层是基于哈希表实现的,如果不考虑哈希冲突的话,HashMap在增删改查操作上的时间复杂度都能够达到惊人的O(1). 对于HashMap类源码中开头注释翻译: HashMap基于哈希表的 Map 接口的实现.此实现提供所有可选的映射操作,并允许使用 null 值和 null 键.(除了不同步和允许使用 null 之外,HashMap 类与 Hashtable 大致相同.)此类不保证映射的顺序,特别是它不保

Java 基础 - Integer 源码

上班闲的时候看下源码,边看边更新,欢迎评论 继承关系 其中 Number 是个抽象类,主要抽象了一下方法: 即数值型的类型转换 变量 @Native public static final int MIN_VALUE = 0x80000000; int 型最小值,表示-2^(32-1) @Native public static final int MAX_VALUE = 0x7fffffff; int 型最大值,表示 2^(32-1) - 1 因为 Java 都是有符号的数值,所以 int 范

java.util.ArrayList源码分析

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable 可变数组大小的List实现,允许所有的元素,包括null.(该类可粗略地看作是Vector,除了它不是同步化的) size.isEmpty.get.set.iterator和listIterator操作的运行时间是常量.add操作对于添加n个

【Java集合源码剖析】ArrayList源码剖析

转载请注明出处:http://blog.csdn.net/ns_code/article/details/35568011 ArrayList简介 ArrayList是基于数组实现的,是一个动态数组,其容量能自动增长,类似于C语言中的动态申请内存,动态增长内存. ArrayList不是线程安全的,只能用在单线程环境下,多线程环境下可以考虑用Collections.synchronizedList(List l)函数返回一个线程安全的ArrayList类,也可以使用concurrent并发包下的C