java ArrayList源码分析

最新推荐文章于 2025-11-04 10:02:19 发布

原创

最新推荐文章于 2025-11-04 10:02:19 发布 · 1k 阅读

18 ·

CC 4.0 BY-SA版权

文章标签：

#java #ArrayList #源码分析 #集合

ArrayList 是 Java 标准库中的一个非常常用的类，它实现了 List 接口，提供了一个动态数组的实现，可以用来存储一系列的元素。

以下是一些关键点的解释：

serialVersionUID：用于序列化时保持类的版本一致性。
DEFAULT_CAPACITY：默认的初始容量。
elementData：用于存储列表元素的数组。
size：列表中当前元素的数量。
MAX_ARRAY_SIZE：可以分配给数组的最大大小。

构造函数：

ArrayList()：创建一个空的 ArrayList。
ArrayList(int initialCapacity)：创建一个具有指定初始容量的 ArrayList。
ArrayList(Collection<? extends E> c)：创建一个包含指定集合中所有元素的 ArrayList。

方法：

trimToSize()：将 elementData 数组的大小调整为 size。
ensureCapacity(int minCapacity)：确保 elementData 数组至少有足够的最小容量。
add(E e)：在列表末尾添加一个元素。
add(int index, E element)：在指定位置插入一个元素。
remove(Object o)：移除列表中第一次出现的指定元素。
remove(int index)：移除指定位置的元素。
clear()：移除列表中的所有元素。
addAll(Collection<? extends E> c)：将指定集合中的所有元素添加到此列表的末尾。
addAll(int index, Collection<? extends E> c)：将指定集合中的所有元素插入到此列表中的指定位置。
get(int index)：返回指定位置的元素。
set(int index, E element)：用指定元素替换指定位置的元素。
size()：返回列表中的元素数量。

ArrayList 还实现了一些其他的内部方法和嵌套类，比如 Itr（迭代器）、ListItr（列表迭代器）、SubList（子列表）等，这些类和方法支持 ArrayList 的高级操作，如迭代、元素搜索、子列表操作等。

此外，ArrayList 还重写了 clone() 方法来实现浅拷贝，以及 toArray() 和 toArray(T[] a) 方法来将列表转换为数组。

ArrayList源代码：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package java.util;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable {
    private static final long serialVersionUID = 8683452581122892189L;
    private static final int DEFAULT_CAPACITY = 10;
    private static final Object[] EMPTY_ELEMENTDATA = new Object[0];
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = new Object[0];
    transient Object[] elementData;
    private int size;
    private static final int MAX_ARRAY_SIZE = 2147483639;

    public ArrayList(int var1) {
        if (var1 > 0) {
            this.elementData = new Object[var1];
        } else {
            if (var1 != 0) {
                throw new IllegalArgumentException("Illegal Capacity: " + var1);
            }

            this.elementData = EMPTY_ELEMENTDATA;
        }

    }

    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    public ArrayList(Collection<? extends E> var1) {
        this.elementData = var1.toArray();
        if ((this.size = this.elementData.length) != 0) {
            if (this.elementData.getClass() != Object[].class) {
                this.elementData = Arrays.copyOf(this.elementData, this.size, Object[].class);
            }
        } else {
            this.elementData = EMPTY_ELEMENTDATA;
        }

    }

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

    }

    public void ensureCapacity(int var1) {
        int var2 = this.elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA ? 0 : 10;
        if (var1 > var2) {
            this.ensureExplicitCapacity(var1);
        }

    }

    private void ensureCapacityInternal(int var1) {
        if (this.elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            var1 = Math.max(10, var1);
        }

        this.ensureExplicitCapacity(var1);
    }

    private void ensureExplicitCapacity(int var1) {
        ++this.modCount;
        if (var1 - this.elementData.length > 0) {
            this.grow(var1);
        }

    }

    private void grow(int var1) {
        int var2 = this.elementData.length;
        int var3 = var2 + (var2 >> 1);
        if (var3 - var1 < 0) {
            var3 = var1;
        }

        if (var3 - 2147483639 > 0) {
            var3 = hugeCapacity(var1);
        }

        this.elementData = Arrays.copyOf(this.elementData, var3);
    }

    private static int hugeCapacity(int var0) {
        if (var0 < 0) {
            throw new OutOfMemoryError();
        } else {
            return var0 > 2147483639 ? 2147483647 : 2147483639;
        }
    }

    public int size() {
        return this.size;
    }

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

    public boolean contains(Object var1) {
        return this.indexOf(var1) >= 0;
    }

    public int indexOf(Object var1) {
        int var2;
        if (var1 == null) {
            for(var2 = 0; var2 < this.size; ++var2) {
                if (this.elementData[var2] == null) {
                    return var2;
                }
            }
        } else {
            for(var2 = 0; var2 < this.size; ++var2) {
                if (var1.equals(this.elementData[var2])) {
                    return var2;
                }
            }
        }

        return -1;
    }

    public int lastIndexOf(Object var1) {
        int var2;
        if (var1 == null) {
            for(var2 = this.size - 1; var2 >= 0; --var2) {
                if (this.elementData[var2] == null) {
                    return var2;
                }
            }
        } else {
            for(var2 = this.size - 1; var2 >= 0; --var2) {
                if (var1.equals(this.elementData[var2])) {
                    return var2;
                }
            }
        }

        return -1;
    }

    public Object clone() {
        try {
            ArrayList var1 = (ArrayList)super.clone();
            var1.elementData = Arrays.copyOf(this.elementData, this.size);
            var1.modCount = 0;
            return var1;
        } catch (CloneNotSupportedException var2) {
            throw new InternalError(var2);
        }
    }

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

    public <T> T[] toArray(T[] var1) {
        if (var1.length < this.size) {
            return (Object[])Arrays.copyOf(this.elementData, this.size, var1.getClass());
        } else {
            System.arraycopy(this.elementData, 0, var1, 0, this.size);
            if (var1.length > this.size) {
                var1[this.size] = null;
            }

            return var1;
        }
    }

    E elementData(int var1) {
        return this.elementData[var1];
    }

    public E get(int var1) {
        this.rangeCheck(var1);
        return this.elementData(var1);
    }

    public E set(int var1, E var2) {
        this.rangeCheck(var1);
        Object var3 = this.elementData(var1);
        this.elementData[var1] = var2;
        return var3;
    }

    public boolean add(E var1) {
        this.ensureCapacityInternal(this.size + 1);
        this.elementData[this.size++] = var1;
        return true;
    }

    public void add(int var1, E var2) {
        this.rangeCheckForAdd(var1);
        this.ensureCapacityInternal(this.size + 1);
        System.arraycopy(this.elementData, var1, this.elementData, var1 + 1, this.size - var1);
        this.elementData[var1] = var2;
        ++this.size;
    }

    public E remove(int var1) {
        this.rangeCheck(var1);
        ++this.modCo

最低0.47元/天解锁文章