ArrayList源码分析

最新推荐文章于 2024-10-07 11:22:30 发布
最新推荐文章于 2024-10-07 11:22:30 发布
阅读量174 收藏
点赞数 1
文章标签： java 源码 arraylist
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44431196/article/details/120652626
版权

ArrayList源码分析

本文章，纯手写，如果发现有什么问题或者不懂的都可以联系我哦！！！
同时谢谢你们的支持和鼓励~~

ArrayList类的继承和接口

首先看一下ArrayList这个类的继承和实现关系

在这里插入图片描述

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

从上面可以看出它继承了AbstractList，实现了RandomAccess, Cloneable, java.io.Serializable这几个接口

那么来分析一下这几个的作用吧

  1. AbstractList

    通过看这个抽象类的源码可以知道，这个就是ArrayList的骨架，所以ArrayList会通过AbstractList来构建自己的骨架和方法

  2. RandomAccess

    这个接口提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。在实践中，如果集合实现了这个接口，那么就建议采取随机访问，这样速度会更快，如果没有实现这个接口，建议采取顺序访问；因为有无这个接口然后选择访问的方式会对访问速度有很大的影响。

  3. Cloneable
    这个接口主要是提供了ArrayList可以被拷贝的功能

  4. java.io.Serializable

    这个接口主要提供了ArrayList的序列化功能，因为实现了序列化，所以在实践中，如果有大量数据需要进行存储或者取出，那么就可以考虑使用ArrayList集合进行操作。

ArrayList是如何初始化的？

先声明接下来会出现的参数

//初始化容量为10
private static final int DEFAULT_CAPACITY = 10;
//定义一个空数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//定义一个默认容量为空的空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//定义一个数组（这个也就是ArrayList底层使用的数组）
transient Object[] elementData; // non-private to simplify nested class access
//ArrayList中元素所占数组的大小
private int size;

然后从它的三个构造方法说起：

    ArrayList list1 = new ArrayList<>();
    ArrayList list2 = new ArrayList<>(12);
    ArrayList list3= new ArrayList<>(list1);

  1. 第一个无参构造

    进行debug来看看怎么初始化的

    //可以看到，无参构造初始化，进入的就是他自身的无参构造器
public ArrayList() {
    //这是将本身的数组设置为空数组
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

  2. 第二个有参构造

    //有参构造就会进入到这个构造方法中
//initialCapacity这个就是传过来的初始化容量参数
public ArrayList(int initialCapacity) {
    //判断如果初始化容量的参数大于0，那么就将新创建的数组（这个数组的容量就是前面传过来的初始化容量大小）赋给本地的数组
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        //如果初始化容量大小等于零，那么就将本地数组置为空数组
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        //如果上面两种条件都不满足，那么就会报出非法容量异常
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

  3. 第三个有参构造

    //进入到这个构造方法中，参数传递是集合
public ArrayList(Collection<? extends E> c) {
    //首先将传过来的集合变成数组，然后将这个数组赋给本地数组
    elementData = c.toArray();//有关这个方法的调用在下面代码中指出
    //这里将size赋值，然后判断本地数组的长度	是否等于0
    if ((size = elementData.length) != 0) {
        // 如果不等于0，再进行判断本地数组的类和对象数组的类是否相同
        if (elementData.getClass() != Object[].class)
            //如果不相同，那么就会将本地数组的类型转换成对象数组类型
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // 如果上述条件都不符合，那么就会将本地数组置为空
        this.elementData = EMPTY_ELEMENTDATA;
    }
}


//这是上面的toArray方法
public Object[] toArray() {
    //而这个方法的底层实现是将数据拷贝到一个新数组，然后将这个新数组进行返回
    return Arrays.copyOf(elementData, size);
}

//original就是传过来的数据，newLength就是传过来的集合长度
public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }

//实际上调用的就是这个方法！！！！！
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
    //这里进行三元运算判断，判断新类型是否和对象数组类型相同，这里不管判断是正确还是不正确，都会创建一个新数组，然后把数据放到这个新数组里面，进行返回
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    //这里是进行数据拷贝，Math.min(original.length, newLength)这个是比较传过来的数据长度和传过来的长度大小。
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

    通过上面的构造方法，可以知道ArrayList是如何初始化的

ArrayList是怎么实现增删改查的？

下面再通过它的增删改查来进一步探索

从增加开始说起，直接上代码

//就从这个代码开始debug吧
ArrayList list1 = new ArrayList<>();
list1.add("aaa");

//首先进入的是这个添加方法中，这是boolean类型的方法，但是它返回的永远是ture
public boolean add(E e) {
    //这个方法主要是判断是否是第一次添加，然后数组是否初始化过，然后再进行后面的扩容判断。
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    
    //在将元素添加进数组之前，需要判断这个数组的容量是否能够让这个元素添加进去
    
    //将size作为下标，存储传进来的元素
    elementData[size++] = e;
    return true;
}

 private void ensureCapacityInternal(int minCapacity) {
     //因为是第一次添加操作，所以传过来的minCapacity最小值是1，也就是前面的size + 1
     //这里进行判断，本地数组是否为空数组
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //如果是空数组，那么就将这个最小容量设置为默认容量，也就是10
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

     //进行扩容判断
        ensureExplicitCapacity(minCapacity);
    }


 private void ensureExplicitCapacity(int minCapacity) {
     //计数用的
        modCount++;

        
     //判断预扩展的值与当前数组的容量大小
        if (minCapacity - elementData.length > 0)
            //如果大于，说明数组容量不够，会进行扩容操作
            grow(minCapacity);
    }

private void grow(int minCapacity) {
        // oldCapacity将本地数组长度记录下来
        int oldCapacity = elementData.length;
    
    	//>>是右移，也就是除以2的几次幂
    	//<<是左移，也就是乘以2的几次幂
    
    	//newCapacity=旧的容量+将旧的容量右移后的结果     
    	//得到的结果就是newCapacity是原来旧容量的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
    	//判断如果新的容量减去最小容量小于0
        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) {
     //如果最小容量小于0，内存溢出异常
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
     //如果上述条件不满足，进行三元运算，如果最小容量大于最大数组容量，那么就会将这个更大的值返回，否则就返回最大数组容量
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

将思路捋清：这个代码主要是在添加元素之前将确保一下数组容量的大小，以便后面可以正常的元素插入。在这个确保容量的时候，首先如果是第一次添加进来的，那么因为我们初始化集合是用的无参构造方法，所以先将这个数组的大小设置为默认大小。设置完之后，再判断添加的元素之后的长度是否大于当前数组的容量，如果大于那么就会进入到扩容中，然后将旧的容量扩充为原来的1.5倍（**这里主要是针对第一次进来时的情况：**如果扩充的容量比最小容量还小，那么就标志这扩容失败，容量还是采用最小容量，如果容量大于最大数组容量那么就会再进行相关的判断…）

思考思考思考！！！！！

到了这里，其实我还是有很多的疑问，虽然源码看明白了，但是为什么是这么个流程呢？

带着问题，将源码更通透的理解一下：

为什么是否扩容的判断条件如此难懂？
minCapacity - elementData.length > 0 ？？？？

为什么最小容量大于元素存储的容量还要进行扩容，这里最小容量大于存储容量，那就证明有空间存储啊，为啥还要进行扩容，反而最小容量如果小于那就什么操作也不做？？？？
下面纯属个人理解：

首先这里有一个错误的理解：受第一次添加数据的影响，我把minCapacity当成了一个定值，我一直把这个值当做是10来处理，其实这个最小容量是根据每次添加数据动态更新的值；elementData.length我把它理解成当前数组中存储元素的长度，其实是初始化数组长度的值!!!因此，我无法理解这个扩容的判断条件。

正确思路：将上述的错误思想改正之后，豁然开朗，解决思路就是我来了一个一万次循环将元素添加进集合当中，那么这个时候，你会发现这个minCapacity是个什么东西呢，它其实就是在我们添加元素之前，将数组容量预扩展一个存放元素的空间，然后用这个预扩展的值减去当前数组的长度，如果这个长度大于数组长度，那么就说明数组长度不够，这时候就会调用grow方法，将数组扩容为原来的1.5倍。

如果上面的描述还是不懂，那么现在假设现在循环到了第十一次，到调用这个添加方法的时候，首先判断容量是否够，传过去的参数就是minCapacity=11，而这个时候elementData.length就是当时初始化的长度，也就是10，所以说现在是不是就必须得将数组扩容呢？那么就进入到grow方法当中，一顿操作下来，那容量不就变成了15嘛，然后不就可以继续存元素了吗？？？

经过上面的一顿分析之后，下面再看看另外的几个添加方法：

public void add(int index, E element) 在指定位置添加元素

ArrayList list1 = new ArrayList<>();
list1.add("aaa");
list1.add("bbb");
list1.add("ccc");
//添加到指定位置
list1.add(1,"abc");

//进入到这个方法当中
public void add(int index, E element) {
    //校验传过来的下标是否合格
    rangeCheckForAdd(index);
	//校验数组容量是否设置过，然后判断是否需要扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //arraycopy(Object src,  int  srcPos,Object dest, int destPos,int length);
    //src表示源数组，srcPos表示源数组要复制的起始位置，desc表示目标数组,destPos在目标数组中开始赋值的位置,length表示要复制的长度。
    
    //主要就是这段copy代码，这段代码是怎么实现的呢？？？
    //首先数据源是elementData{aaa,bbb,ccc}，也就是原数组，要复制的起始位置就是index=1(bbb)，目标数组还是elementData{aaa,bbb,ccc}，开始赋值的位置就是2(ccc)开始，要复制的长度为3-1=2；那么根据上述条件，我们知道复制完之后数组的数据变成了elementData{aaa,bbb,bbb,ccc}
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    //然后将索引的位置变成要添加的元素值（在指定的地方添加元素）
    elementData[index] = element;
    size++;
}


private void rangeCheckForAdd(int index) {
    //是否大于数组长度，是否小于0，如果是就会抛出索引越界异常
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

public boolean addAll(Collection<? extends E> c) 添加集合元素

ArrayList list1 = new ArrayList<>();
list1.add("aaa");
list1.add("bbb");
list1.add("ccc");
ArrayList list3= new ArrayList<>(list1);
list3.addAll(list1);

//进入到这个方法中来
public boolean addAll(Collection<? extends E> c) {
    //首先将集合变成一个对象数组
    Object[] a = c.toArray();
    //记录数组的长度
    int numNew = a.length;
    //校验数组的容量，判断是否扩容
    ensureCapacityInternal(size + numNew);  // Increments modCount
    //又来到的熟悉的地方，同样的，我们根据上一个方法来进行分析
    //数据源：a{aaa,bbb,ccc}  复制起始位置0  目标数组elementData{}  目标数组的位置0  复制的长度3
    //那么最终得到的结果就是复制过来的数组elementData{aaa,bbb,ccc}
    System.arraycopy(a, 0, elementData, size, numNew);
    //数组的长度变成原本的长度加上新添加数据的长度
    size += numNew;
    return numNew != 0;
}

public boolean addAll(int index, Collection<? extends E> c) 将集合添加到指定位置上

ArrayList list1 = new ArrayList<>();
list1.add("aaa");
list1.add("bbb");
list1.add("ccc");
ArrayList list3= new ArrayList<>();
list3.add("ddd");
list3.add("eee");
list3.addAll(1,list1);

//进入到这个方法中
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;
    //如果大于0
    if (numMoved > 0)
        //首先是进行第一次拷贝，这次拷贝主要是将目标数组扩充为可以容纳新数组的数组
        //数据源elementData{ddd,eee}  复制的起始位置1  目标数组elementData  在目标数组赋值的位置1+3  复制的长度1    复制完成之后的数组变成elementData{ddd,eee,null,null,eee}
        System.arraycopy(elementData, index, elementData, index + numNew,
                         numMoved);
	//第二次拷贝才是将真正的数据添加进数组中
    System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
}

修改方法set

上代码

ArrayList list1 = new ArrayList<>();
list1.add("aaa");
list1.add("bbb");
list1.add("ccc");
list1.set(1,"ddd");

public E set(int index, E element) {
    //判断索引下标是否越界
    rangeCheck(index);
	//将旧的值取出
    E oldValue = elementData(index);
    //将新的值修改
    elementData[index] = element;
    //返回旧的值
    return oldValue;
}

获取方法get

ArrayList list1 = new ArrayList<>();
list1.add("aaa");
list1.add("bbb");
list1.add("ccc");
list1.get(2);

public E get(int index) {
    //判断索引下标是否越界
    rangeCheck(index);
	//返回当前索引的值
    return elementData(index);
}

toString方法源码解析

ArrayList list1 = new ArrayList<>();
list1.add("aaa");
list1.add("bbb");
list1.add("ccc");
list1.toString();

//首先得明确一点，这个方法不是ArrayList的而是AbstractList中的方法
public String toString() {
    //主要使用的迭代器
    Iterator<E> it = iterator();
    //判断如果为空，就直接返回空串
    if (! it.hasNext())
        return "[]";

    //如果不为空，那么用StringBuilder进行字符串拼接
    StringBuilder sb = new StringBuilder();
    //先将结构搭建好
    sb.append('[');
    //然后用循环将里面的数据一一拼接到字符串上
    for (;;) {
        E e = it.next();
        //这里通过三元运算，判断y
        sb.append(e == this ? "(this Collection)" : e);
        if (! it.hasNext())
            //如果没有数据了，就进行结尾
            return sb.append(']').toString();
        sb.append(',').append(' ');
    }
}

迭代器的源码

这里我会通过三个不同的案例，来分析一下迭代器具体的源码，然后引申出相关的问题

第一个例子：通过迭代器遍历，使用集合自带的方法删除目标元素

ArrayList list1 = new ArrayList<>();
list1.add("aaa");
list1.add("bbb");
list1.add("ccc");
Iterator it = list1.iterator();
while(it.hasNext()){
    String s = (String) it.next();
    if (s.equals("aaa")){
        list1.remove(s);
    }
}

将这个代码运行之后，你会发现代码报错

Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
	at java.util.ArrayList$Itr.next(ArrayList.java:851)
	at jihe.test.main(test.java:17)

为什么会报错呢？？？带着问题，查看源码！！！

//先进入这个迭代器的方法中，而后会发现，一个内部类继承iterator重写了迭代器方法
public Iterator<E> iterator() {
    return new Itr();
}


//主要来看一下这个类的具体实现
private class Itr implements Iterator<E> {
    int cursor;       // 这里是光标位置
    int lastRet = -1; // 返回最后一个元素的索引
    //将实际修改次数赋值给预期修改次数（报错的关键语句）
    int expectedModCount = modCount;

    //判断光标位置是否到达末尾
    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        //检查实际修改次数和预期修改次数是否一样，如果不一样那么就会报出刚刚的错误ConcurrentModificationException（报错的关键方法）
        checkForComodification();
        //将光标的值赋值给i
        int i = cursor;
        //size：就是数组的长度
        //然后用i和size进行比较，如果光标的值大于size的值，那么就会抛出异常NoSuchElementException
        if (i >= size)
            throw new NoSuchElementException();
        //将集合数组赋值给elementData
        Object[] elementData = ArrayList.this.elementData;
        //如果光标的值大于数组的长度抛出异常ConcurrentModificationException
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        
        //光标自增
        cursor = i + 1;
        //将i的值赋值给lastRet，并且将当前遍历到的数据进行返回
        return (E) elementData[lastRet = i];
    }


    
final void checkForComodification() {
    //判断实际修改次数和语气修改次数是否相等
        if (modCount != expectedModCount)
            //不想等就直接报出ConcurrentModificationException异常
            throw new ConcurrentModificationException();
    }
    
    
    
//上面的遍历大致就是那么个思路，然后根据程序的执行，我们会进行比较判断，如果当前遍历的值与要删除的值相同，那么就调用ArrayList自带的移除方法
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) {
    	//首先会把实际修改次数加1
        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
    }

那么通过上面的案例，可能还是没有明白为什么会报错呢，程序都执行到了结尾了，数据也移除了，那么为什么还会报错呢？？

请继续往下看，程序确实已经完成了移除操作，但是，程序还没有执行完，继续往下走，会再次进入迭代器的遍历当中，当遍历了一个元素之后，再次调用next方法，就可以看到next方法中首先出现的checkForComodification();，那么核心就在这个方法当中了，还记得之前在添加数据的时候，modCount会记录修改的次数，之前添加了三个元素，也就是modCount=3，然后将modCount的值赋给了expectedModCount，那么expectedModCount的值是不是也等于3，但是在刚刚移除元素的过程中，是不是有modCount++出现，那么这时候modCount是不是等于4，这样是不是一切都明了了，此时modCount != expectedModCount成立，就会报出刚刚的错误了。

if (modCount != expectedModCount)
    throw new ConcurrentModificationException();

第二个例子：和第一次是一样的代码，注意不同的是这次移除的是倒数第二个元素

ArrayList list1 = new ArrayList<>();
list1.add("aaa");
list1.add("bbb");
list1.add("ccc");
Iterator it = list1.iterator();
while(it.hasNext()){
    String s = (String) it.next();
    if (s.equals("bbb")){
        list1.remove(s);
    }
}

前面的操作流程都是一样的，但是这次运行结果竟然不报错！！！！？？

为什么不报错呢？？？

这属于是特殊情况，为什么这么说呢，根据刚刚的代码，再来分析一下思路，如果删除的是倒数第二个元素，那么在下一次迭代器遍历中，首先看到的判断条件是不是public boolean hasNext(){return cursor != size;}，实际上就是这里出了问题，现在想一下，集合中一共有三个元素，在进行了移除操作，就剩下两个元素，而且在移除操作最后一步elementData[–size] = null，首先是将size进行–操作，这样就说明此时的size大小为2，而光标在上一次的遍历中是不是cursor = i + 1有这个操作，这时候cursor是不是也变成了2，那么hasNext这个判断条件就变成了false，既然变成了false，就会直接跳出遍历，程序并没有报错！！

第三个例子：和第一次一样的代码，不同的是这一次使用的是迭代器自带的移除方法

ArrayList list1 = new ArrayList<>();
list1.add("aaa");
list1.add("bbb");
list1.add("ccc");
Iterator it = list1.iterator();
while(it.hasNext()){
    String s = (String) it.next();
    if (s.equals("ccc")){
        //注意，这里是迭代器自带的方法进行元素的删除
        it.remove();
    }
}

前面遍历操作的流程大致都是一样的，主要看一下这个迭代器自带的删除方法有什么异同

下面进行源码分析

public void remove() {
    //来看一下lastRet是什么？
    //之前在前面的代码中，是不是在遍历的next方法中出现，这个lastRet指向的就是，当前遍历的元素，也可以说是遍历到的最后一个元素（不是遍历完，而是遍历到当前的元素，当前元素的下表作为lastRet的值）。这个lastRet的值就是需要remove的那个元素的下标
    //首先判断这个下标是否小于0，如果是就会抛出IllegalStateException
    if (lastRet < 0)
        throw new IllegalStateException();
    //检查预期修改次数和实际修改次数是否相同
    checkForComodification();

    try {
        //调用集合本地的remove方法，将lastRet这个下标指向的值删除
        ArrayList.this.remove(lastRet);
        //将当前遍历的最后一个值得下标赋值给光标
        cursor = lastRet;
        //将lastRet置为-1
        lastRet = -1;
        //将实际修改的次数赋值给预期修改次数
        expectedModCount = modCount;
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

public E remove(int index) {
    //校验下表是否越界
    rangeCheck(index);

    //实际修改次数加1
    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;
}

private void rangeCheck(int index) {
    if (index >= size)
        //如果索引下标大于集合大小，就会报错
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

总结：可以看到，通过迭代器的方法进行删除的时候，大致思路是一样的，而且底层的删除还是用的ArrayList自带的集合进行删除的，不过不同的是，迭代器的删除方法中**expectedModCount = modCount;**多出了这样的一个步骤，所以迭代器删除是不会报错的。

clear、contains、isEmpty源码

  1. clear方法：

    //简单明了
public void clear() {
    //实际修改次数自增
    modCount++;

    // 通过遍历，将所有的值置为空，以便垃圾回收机制将它们进行回收
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    //将数组的大小也置为0
    size = 0;
}

  2. IsEmpty方法：

    //判断数组大小是否为0
public boolean isEmpty() {
    return size == 0;
}

  3. contains方法：

    ArrayList list1 = new ArrayList<>();
list1.add("aaa");
list1.add("bbb");
list1.add("ccc");
list1.contains("abc");

    //首先进入这个方法中，返回indexOf(o) >= 0比值是否大于0，如果大于就是包含相应的值，如果小于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;
        }
    //如果都没有找到，就返回-1
        return -1;
    }

最终可以通过判断**list1.contains(“abc”);**的返回值是ture还是false来判断是否包含所传入的值。

考虑以下几个问题

  1. ArrayList是如何扩容的?

  2. ArrayList频繁扩容导致添加性能几句下降，如何处理？
    只想到了使用初始容量的构造方法，不过浪费空间

  3. ArrayList插入或者删除元素一定比LinkedList慢吗？
    不一定，这个就要看是否针对某个位置进行相应的插入和删除操作，如果不针对位置进行插入和删除，那么肯定是LinkedList比较快的，如果针对位置，那么它们俩的性能是差不多的。

  4. ArrayList是线程安全的吗？

    不是线程安全的，那么又如果解决这个不安全，或者手写一个不安全的案例看看？

    如何解决线程不安全？

    使用Vector、使用synchronize、以及Collections.synchronizedList()、lock（）

  5. 如何将某个ArrayList复制到另一个ArrayList中
    构造方法、clone、添加

  6. 多线程下保证正常读写？
    copyOnWriteArrayList

  7. ArrayList和LinkedList的区别？

Capricieux丶☆
关注
Java编程中ArrayList源码分析
08-28
Java编程中ArrayList源码分析 Java编程中ArrayList源码分析是Java编程中一个重要的知识点，对于Java开发者来说，了解ArrayList的源码可以帮助他们更好地理解Java集合框架的实现机制，从而提高自己的编程水平。 ...
【Java】ArrayList源码分析
qq_39921135的博客
07-02 857
假设集合第一次新建的长度为10的数组已经装满了，然后此时我需要一次性添加100个数据，很显然，长度为10的数组扩容1.5倍为15个数据的数组，肯定不够，此时新数组的长度就以实际情况为准：110（原来的10个 + 新增加的100个数据）。当原来10个元素的数组存满时，它会创建一个新的数组，新数组长度是原来的1.5倍，也就是长度为15。当我们不断的添加，数组里面的元素存满了，这个时候如果需要继续再存，在底层就需要自动扩容。这个类的源码比较多，看起来不太方便，因此我们需要将它的大纲视图罗列出来，有两种办法。
ArrayList 源码分析
搬运Gong
03-23 981
ArrayList的初始化过程及动态扩容机制源码分析
Java 集合—— ArrayList 源码分析
weixin_44814196的博客
08-22 831
分析 ArrayList 的底层数据结构和扩容机制。
java ArrayList源码分析（深度讲解）
Cyan_RA9的博客
03-13 1941
java 集合篇章——ArrayList类源码分析。通过Debug一步一步带你看懂源码!
【源码】ArrayList 源码分析
来到人间不过是个蹭饭的客人，还挑什么酸甜苦辣。
06-22 454
本文主要介绍了ArrayList的相关知识，底层数据结构，数组集合相互转换，源码主要分析了其扩容机制。
ArrayList源码分析（超详细）
一条咸鱼的博客
10-05 2228
ArrayList源码详解，面试官：“嗯，回去等通知吧。”
ArrayList源码分析(含jdk1.8).pdf
04-24
在了解ArrayList的源码分析时，我们主要探讨其在Java Development Kit (JDK) 1.8中的实现。ArrayList是一个非常重要的集合框架，用于动态数组的实现，其功能类似于数组，但可以在运行时动态调整大小。它是一个非线程...
JDK1.0主要特性
FoolRabbit的专栏
10-06 278
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 484
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Java内存布局
阿呆的专栏
10-01 822
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
【RocketMQ】RocketMQ应用难点
记录一名在读研究生的学习笔记、感悟、开发产物
09-30 920
本文探讨了RocketMQ中消息重复消费的问题及其解决方案，尤其是在CLUSTERING模式下的扩容影响。文章分析了重复消费的原因，如广播模式、负载均衡模式下的多consumerGroup消费、消费者组内的动态变化及网络延迟等，并提出了利用唯一标识进行去重的方法。此外，还讨论了如何选择合适的存储机制以高效处理大量消息标识，如HashMap、MySQL、Redis以及推荐的布隆过滤器等方案。对于防止消息堆积与确保消息不丢失，也给出了相应的策略和技术措施。
2024Java最新面试题总结（针对于一些小厂、中厂）
最新发布
weixin_62375676的博客
10-07 688
2024最新Java面试题，针对一些小厂，中厂
JAVA开源项目 旅游管理系统 计算机毕业设计
as230627的博客
10-03 1323
旅游管理系统基于Springboot框架、JAVA编程语言、MYSQL数据库开发完成，“操作简单，功能实用”这是本软件设计的核心理念，本系统力求创造最好的用户体验。
【hot100-java】【合并两个有序链表】
m0_73629042的博客
09-30 393
记忆中，两个指针合并即可。
Python并发编程(1)——Python并发编程的几种实现方式
一点
10-03 1057
Python 并发编程是指在 Python 中编写能够同时执行多个任务的程序。并发编程在任何一门语言当中都是比较难的，因为会涉及各种各样的问题，在Python当中也不例外。Python 提供了多种方式来实现并发，包括多线程（threading）、多进程（multiprocessing）、异步编程（asyncio），以及一些高级用法concurrent.futures和第三方库如gevent。
古典舞在线交流：SpringBoot平台实现与优化
2401_85341950的博客
10-04 603
在这段时期里，我查找了很多相关的资料，查阅了很多Java的相关文献，结合自己的经验，设计了这个古典舞在线交流平台，虽然每个学期学校都会针对动手练习进行相应的课程设计，但是在古典舞在线交流平台的具体设计中还是遇到了一些小问题，但在不断的学习、研究中都将问题一一解决，在一一克服的过程中，我也得到了成长，知识和经验也得到了丰富，这对我来说是一笔巨大的财富。这次设计也大大提高了我的动手的能力，让我在学习中充分体会到了探索的乐趣，享受成功的创作过程，在本次设计过程中汲取的东西，是一笔宝贵的财富，让我受益匪浅。
深度解析Java ArrayList源码
以下是对ArrayList源码中关键部分的分析： 1. **数据结构**： ArrayList底层使用一个Object类型的数组`elementData`来存储元素。当数组满时，会通过扩容机制自动创建一个新的更大的数组并将原有元素复制过去。 2....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值