Java源码学习【1】：ArrayList

最新推荐文章于 2024-06-03 11:16:28 发布
最新推荐文章于 2024-06-03 11:16:28 发布
阅读量407 收藏 1
点赞数 1
分类专栏： jdk源码 文章标签： java 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41852212/article/details/124879152
版权

ArrayList

在这里插入图片描述

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
  1. 实现了 RandomAccess 接口，用索引进行增删改查的数据结构，需要实现随机访问接口。
  2. 迭代器效率低于for循环，非RandomAccess 接口（LinkedList）建议使用迭代器。
  3. Cloneable 接口，ArrayList 支持浅拷贝
  4. Serializable 可以被序列化

讲讲深浅拷贝

相关属性

默认容量，不指定容量时默认为10.

private static final int DEFAULT_CAPACITY = 10;

初始容量为0时，使用的object数组

private static final Object[] EMPTY_ELEMENTDATA = {};

默认容量为10时，使用的object数组

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

为什么要准备两个空数组？

transient 修饰的元素，不能被序列化 ，

transient Object[] elementData;

讲讲transient关键字？

arralyList 的元素数量，不是elementData数组的长度

private int size;

初始化

构造器

    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
		public ArrayList(int initialCapacity) {
      if (initialCapacity > 0) {
          this.elementData = new Object[initialCapacity];
      } else if (initialCapacity == 0) {
        // 传入 0 时，走这个if 
          this.elementData = EMPTY_ELEMENTDATA;
      } else {
          throw new IllegalArgumentException("Illegal Capacity: "+
                                             initialCapacity);
      }
	}
    public ArrayList(Collection<? extends E> c) {
        Object[] a = c.toArray();
        if ((size = a.length) != 0) {
            if (c.getClass() == ArrayList.class) {
                elementData = a;
            } else {
                elementData = Arrays.copyOf(a, size, Object[].class);
            }
        } else {
            // replace with empty array.
            elementData = EMPTY_ELEMENTDATA;
        }
    }

Arrays.asList

List<String> list1 = Arrays.asList();
list1.add("a");

Arrays 没有复写AbstractList的add方法，是直接调用 AbstractList 中的add方法。

public boolean add(E e) {
    add(size(), e);
    return true;
}
public void add(int index, E element) {
    throw new UnsupportedOperationException();
}

会抛出 UnsupportedOperationException 异常

Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.AbstractList.add(AbstractList.java:148)
	at java.util.AbstractList.add(AbstractList.java:108)
	at analyse.ArrayListAnalyse.main(ArrayListAnalyse.java:51)

Arrays.asList() 的使用场景是？

Collections.emptyList

List<String> list2 = Collections.emptyList();
list2.add("a");

    public static final <T> List<T> emptyList() {
        return (List<T>) EMPTY_LIST;
    }
    public static final List EMPTY_LIST = new EmptyList<>();
    private static class EmptyList<E>
        extends AbstractList<E>
        implements RandomAccess, Serializable

没有覆写add方法

Exception in thread “main” java.lang.UnsupportedOperationException

Collections.emptyList() 使用场景？

添加元素 & 扩容

扩容问题

下面代码扩容了几次？👇

        List<String> list = new ArrayList<>(0);
        // 添加了10个元素
        list.add("a");
        list.add("a");
        list.add("a");
        list.add("a");
        list.add("a");
        list.add("a");
        list.add("a");
        list.add("a");
        list.add("a");
        list.add("a");

add(E e)

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

ensureCapacityInternal 确保容量是合法的

    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
          // 此例中，不会走到这个分支中，因为elementData 是 EMPTY_ELEMENTDATA
          // 所以不会 取到默认容量 10 
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
      // 执行完毕后会进入下方的方法内
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
          // 执行扩容方法
            grow(minCapacity);
    }

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
  // 近似1.5倍，3 + 3>>1  = 3 + 1.5 = 4.5 (下取整) = 4
  
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
      //MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8 
      // 比MAX_ARRAY_SIZE 还大时，会尝试使用 Integer.MAX_VALUE
        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;
    }

add(int index, E element)

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

System.arraycopy();

list 如果在list前面或者中间进行add操作时会导致底层数组在内存上的移动，增加时间开销。

Arrays.copyOf(elementData, newCapacity) 是一个浅拷贝操作

    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);
          // 
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

addAll(Collection<? extends E> c)

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

    private void rangeCheckForAdd(int index) {
      // 检查 index 的合法性 把可能性大的放前面 对整体性能会有提升
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

返回值有歧义。

对于代码里面中间的list变量，我们需要明白它里面是否有元素

        List<String> list6 = new ArrayList<>();
        List<String> list7 = new ArrayList<>();
        // 输出的是？
        System.out.println(list6.addAll(list7));

clone()

arraylist 中拷贝出来的对象修改次数会被修改为0

public Object clone() {
    try {
        ArrayList<?> v = (ArrayList<?>) super.clone();
        v.elementData = Arrays.copyOf(elementData, size);
      // 拷贝出来的对象 修改次数要被修改为0
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError(e);
    }
}

更新、获取元素

public E get(int index) {
  // 先进行范围的检查
    rangeCheck(index);

    return elementData(index);
}

    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

        List<String> list4 = new ArrayList<>();
        list.add("a");
        System.out.println(list.set(0,"b"));



    public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

set 操作中，返回的是 oldValue

retainAll(Collection c)

求两个集合是否有交集，使用之后会将原list 中与传入集合中相同的元素删除。

 public boolean retainAll(Collection<?> c) {
   //判断集合是否为null
        Objects.requireNonNull(c);
   // 传入true，表示 删除C中没有包含A的元素 
        return batchRemove(c, true);
    }
/**
complement 表示 删除C中没有包含A的元素 
*/
    private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
           
// 遍历整个数组，如果c中包含该元素，则把该元素放到写指针的位置
            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) {
// 如果c.contains()抛出了异常，则把未读的元素都拷贝到写指针之后
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
            if (w != size) {
                // clear to let GC do its work
// 将写指针之后的元素置为空，帮助GC
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }

（1）遍历elementData数组；

（2）如果元素在c中，则把这个元素添加到elementData数组的w位置并将w位置往后移一位；

（3）遍历完之后，w之前的元素都是两者共有的，w之后（包含）的元素不是两者共有的；

（4）将w之后（包含）的元素置为null，方便GC回收；

测试例子

        // 例子 8
        List<String>  list9 = new ArrayList();
        list9.add("1");
        list9.add("2");
        list9.add("3");
        List<String>  list10 = new ArrayList();
        list10.add("1");
        list10.add("2");
        System.out.println(list9.retainAll(list10));
        System.out.println(Arrays.toString(list9.toArray()));
        System.out.println(Arrays.toString(list10.toArray()));
        /**
         * true
         * [1, 2]
         * [1, 2]
         */

删除元素

remove()

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

返回的是remove的元素

    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
    }

避免fastRemove的代码在remove中重复书写，所以抽离出一个新的方法，并非真的fast-remove

removeRange

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

removeRange(int fromIndex, int toIndex) 开头和结尾的元素是否被删除？

开头不被删，结尾的会被删

removeAll

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

    public static <T> T requireNonNull(T obj) {
        if (obj == null)
            throw new NullPointerException();
        return obj;
    }

只判断了null，没判断空，可以removeAll 一个空的list（错误操作❌）

clear()

public void clear() {
    modCount++;

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

    size = 0;
}

逐个设置为null，造成对象不可达，引起GC回收。

        List<String> list5 = new ArrayList<>();
        list5.add("1");
        list5.clear();
        list5.add("1");
        // 扩容几次？

clear 没有重置list的size，所以list底层数组的size还是原来的size，如果重新添加元素，不会再次扩容。

当我们需要对一个list重复利用的话，一定要选择list.claer()

错误示范：

 List<String> list5 = new ArrayList<>();
 list5 = new ArrayList<>();

再次添加元素时会继续扩容。

序列化问题

序列化是什么？为什么要序列化？

readObject & writeObject

 private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // 记录修改次数，防止其他线程修改
        int expectedModCount = modCount;
        s.defaultWriteObject();

        s.writeInt(size);

        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }
// 如果不一致 抛出修改异常
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

    /**
     * Reconstitute the <tt>ArrayList</tt> instance from a stream (that is,
     * deserialize it).
     */
    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(); 

        if (size > 0) {
            // 计算容量
            int capacity = calculateCapacity(elementData, size);
            SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
          // 检查是否需要扩容
            ensureCapacityInternal(size);

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

为什么用 transient 修饰 elementData ？

        /*
        发送list给server端（过网络）
        list 序列化 （writeObject）
           transient Object[] elementData
        server 端接收到list
        list 反序列化 （readObject）
         */

假如有1w个元素，则 list size 大约为1.5w
如果直接序列化 elementData 数组
则会有5k个空元素序列化
所以使用for 循环逐个遍历list中的元素，

优点

  1. 避免浪费序列化次数
  2. 不需要考虑null序列化问题

参考

死磕 Java集合之ArrayList源码分析

尔等同学
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基础之ArrayList源码学习
T_ZZZ的博客
05-26 202
ArrayList源码解读： 特点说明： ArrayList底层是数组队列，相当于动态数组。和java的数组相比，它的容量能动态增长。当添加大量的元素时，应用程序可以通过扩容机制来增加ArrayList实例的容量。这可以减少递增式再分配的数量。 同样的由于ArrayList和LinkedList二者的结构不同，在增删查改方面的速度也是大不一样的。对于ArrayList来说，线性表的顺序存储，插入、删除元素的时间复杂度为O(n)，求表长以及增加元素，取第i元素的时间复杂度为O(1) LinkedList不支
Java中ArrayList类的方法（源码）
程序媛乐园
10-02 382
文章目录ArrayList中的方法一、add二、get和set1、get2、set三、toString四、remove其他总结 ArrayList中的方法 以下内容是基于JDK 11的API整理的，对add、remove、get、set、toString方法在工具中查看了源码，剩下的罗列出了API中的方法便于速览。 创建数组： 实例化data对象，并指定泛型类型 ArrayList<Integer> data = new ArrayList<>(); 一、add 添加数据： 调
list remove方法_执行ArrayList的remove(object)方法抛异常？
weixin_39723010的博客
12-04 348
简介或许有很多小伙伴都尝试过如下的代码：ArrayList list = ...;for (Object object : list) { if (条件成立) { list.remove(object); }}然后会发现抛出java.util.ConcurrentModificationException异常，这是一个并发异常。那么这个到底是什么情况？首先需要...
ArrayList
qq_42729356的博客
11-17 130
ArrayList
java.lang.StringIndexOutOfBoundsException: 字符串索引越界异常的正确解决方法，亲测有效已解决，嘿嘿嘿
最新发布
PythonAigc的博客
06-03 557
`java.lang.StringIndexOutOfBoundsException` 异常在 Java 中是一个常见的运行时异常，它表明你试图访问一个字符串中不存在的索引位置。字符串的索引是从 0 开始的，所以如果你有一个长度为 `n` 的字符串，有效的索引范围是 `0` 到 `n-1`。
java源码分析---ArrayList类（JDK14）
wrz_1028的博客
08-14 312
更多源码分析，请点击 ArrayList ArrayList 执行效率高，但是线程不安全。相当于一个可变长度数组（顺序列表），可以通过下标索引直接对元素进行访问，但是插入和删除效率较低。 ArrayList 底层采用 Object 数组来保存数据，所以如果要保存基本类型需要使用他们的包装类。 public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAcces.
Exception in thread “main“ java.lang.StringIndexOutOfBoundsException: String index out of range: 7
qq_62702607的博客
05-17 6247
报错： Exception in thread "main" java.lang.StringIndexOutOfBoundsException: String index out of range: 7 at java.lang.String.substring(String.java:1963) at Test.main(Test.java:4) 越界了 ！！ 代码： public class Test { public static void main(Strin...
java中StringIndexOutOfBoundsException异常问题
Andrew_Chenwq的博客
04-11 1178
这个问题就是字符串下标越界。下面这个是出现异常的代码当：String fileName = fileItem.getName ();fileItem这个值是空值时执行这个语句：String substring = fileName.substring ( fileName.lastIndexOf ( “.” ) );
深入Java集合学习系列：ArrayList的实现原理
03-18
《深入Java集合学习系列：ArrayList的实现原理》 在Java编程中，ArrayList是集合框架中一个重要的类，属于List接口的实现，它提供了动态数组的功能，允许我们在集合中存储、添加、删除元素，并且可以按索引访问。这...
Java 中模仿源码自定义ArrayList
08-31
通过分析ArrayList的源码，我们可以学习到如何创建一个类似的数据结构，这有助于我们提升对数组、扩容、索引操作等概念的理解。 首先，自定义的MyArrayList类需要一个存储元素的数组，这里选择的是`Object[] ...
java源码学习比较java源码学习比较
11-19
Java源码学习是每个Java开发者深入理解编程语言本质的重要步骤。在Java的世界里，源码是洞察语言机制、设计模式以及优秀库实现的关键。本文将深入探讨如何通过学习Java源码来提升自己的编程技能，同时比较不同的学习...
java8源码-learn:学习
06-04
在这个名为"java8-source-learn:学习"的压缩包中，包含的源码是为了帮助开发者深入理解Java 8的新功能而编写的。让我们逐一探讨这些新特性。 1. **函数式编程**： Java 8引入了Lambda表达式，这是对函数式编程的一...
java源码：Java扫雷源码.rar
10-13
这个项目的源码对于学习Java编程、游戏逻辑实现以及用户界面设计都有很大的帮助。下面，我们将深入探讨这个项目中的关键知识点。 首先，我们要理解Java语言的基础。Java是一种面向对象的编程语言，它具有跨平台的...
public ArrayList(Collection<? extends E> c)方法的一个注释 c.toArray might (incorrectly) not return Objec...
weixin_33873846的博客
04-19 150
/** * Constructs a list containing the elements of the specified * collection, in the order they are returned by the collection's * iterator. * 使用集合类对象初始化ArrayList * * @param c the colle...
Java开发中遇到的异常记录
诗和远方
03-12 546
一. java.lang.StringIndexOutOfBoundsException: String index out of range: -1 public class Demo { public static void main(String[] args) { String str = "How to Train Your Dragon"; //...
Java集合（8）——ArrayList源码解析
想当厨子的程序媛
03-22 613
类图 官方文档 ArrayList成员变量 ArrayList构造函数 ArrayList内部类 ArrayList成员方法 ArrayList成员方法源码解析 1. public ArrayList(int initialCapacity)带参构造方法 public ArrayList(int initialCa...
ArrayList 带参数（Collection<? extends E> c）构造器的一点见解
qq_22083043的博客
08-23 2676
先贴上源码： public class ArrayList extends AbstractList         implements List, RandomAccess, Cloneable, java.io.Serializable {       private static final Object[] EMPTY_ELEMENTDATA = {};     priv
ArrayList 源码坑读学习记录
terry
06-16 1642
Field DEFAULT_CAPACITY 这个属性是ArrayList的容量，默认初始就赋值位10，如果构造函数没有出入集合容量的话，就会用这个默认的初始化容量 private static final int DEFAULT_CAPACITY = 10; EMPTY_ELEMENTDATA 初始化一个Object类型的空数组对象，用于后续方法调用 private static final Object[] EMPTY_ELEMENTDATA = {}; DEFAULTCAPACITY_EM

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值