Java集合源码之ArrayList及相关问题

最新推荐文章于 2022-08-06 19:36:40 发布
最新推荐文章于 2022-08-06 19:36:40 发布
阅读量359 收藏 1
点赞数 3
分类专栏： Java源码 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LY010106/article/details/118072674
版权

Java集合源码之ArrayList

ArrayList的简介

ArrayList可以说是我们最常用的一种集合了。他的本质是一个数组，一个可以自动扩容的动态数组，线程不安全，允许元素为null。

由于数组的内存连续，可以根据下标以O(1)的时间读写元素，因此时间效率很高。

ArrayList的内部属性

//序列化UID，由于ArrayList实现了Serializable接口，所以添加了一个方便于序列化和反序列化的UID。
private static final long serialVersionUID = 8683452581122892189L;
//默认容量10
private static final int DEFAULT_CAPACITY = 10;
//一个空数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//默认的空数组。
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//真正存放元素的数组，transient修饰的变量不可以被序列化和反序列化。
transient Object[] elementData;
//当前存储元素的个数
private int size;

ArrayList的三个构造方法

//空参构造，仅仅将属性中创建的空数组复制过来
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

//传入参数为集合长度
public ArrayList(int initialCapacity) {
    //如果长度大于0，则创建一个对应大小的数组赋给真正数组
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
    //如果长度等于0，则将属性中创建的空数组复制过来    
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}
    
//传入参数是一个集合
public ArrayList(Collection<? extends E> c) {
    	//先将集合转换为数组
        elementData = c.toArray();
    	//如果数组长度不等于0，进入if
        if ((size = elementData.length) != 0) {
            //如果c.toArray（）出错，没返回Object[]，则使用Arrays.copy方法将集合c中的元素传到数组中
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            //如果个数为0，那就把属性中的空数组复制过来
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

ArrayList常用的API

增

1. add（E e）

首先说一下只有一个参数的（向集合中增加的元素）add方法，我们一步一步来：

第一步：调用add（E e）方法

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

这个方法中分为两步，第一步是调用ensureCapacityInternal(size + 1)方法，第二步就是赋值了。

第二步：调用ensureCapacityInternal(size + 1)方法，确定当前数组的所需容量

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}

这一步中判断当前数组是否是空参构造时创建的数组也就是DEFAULTCAPACITY_EMPTY_ELEMENTDATA，然后将数组默认的长度和当前添加元素之后的长度做一个比较，取出最大值然后调用ensureExplicitCapacity(minCapacity)方法判断是否需要扩容。

第三步：调用ensureCapacityInternal(size + 1)方法，判断是否需要扩容

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

这个方法中，首先执行了modCount++，这个变量的字面意思就是修改次数，用到modCount的地方都是线程不安全的，只要我们修改了集合的结构、长度等…都会修改modCount值，然后再次遍历集合的时候，会判断当前的modCount是否相等，如果不相等则证明此线程在遍历时有其他线程对集合发生了修改。然后就是判断当前所需的容量是否大于数组长度，如果大于，则执行grow方法扩容。

第四步：调用grow（minCapacity）方法进行扩容

private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}

说明这个方法的时候，要先知道minCapacity是当前数组所需容量；oldCapacity是当前数组的容量；newCapacity是扩容1.5倍之后的容量。然后看一下方法中的两个if语句。第一个：如果扩容之后没有达到minCapacity当前所需容量，则直接用所需的长度大小，不继续进行扩容1.5倍；第二个：如果扩容之后长度大于数组最大的长度，则调用hugeCapacity(minCapacity)方法对数组长度做一个确定。如果一切都已经做好了，则调用Arrays.copyOf(elementData, newCapacity)方法将原数组并且携带长度复制到新数组。扩容结束。

下面说一下hugeCapacity(minCapacity)方法：

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

如果minCapacity大于最大容量，则新容量则为Integer.MAX_VALUE，否则，新容量大小则为 MAX_ARRAY_SIZE 即为 Integer.MAX_VALUE - 8。

add(int index, E element)

第二个要说的就是有两个参数的add方法，第一个参数是插入的下标索引，第二个是插入的数据。

public void add(int index, E element) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    ensureCapacityInternal(size + 1); 
    System.arraycopy(elementData, index, elementData, index + 1,size - index);
    elementData[index] = element;
    size++;
}

这个方法中分为三步，

  • 第一步调用ensureCapacityInternal(size + 1)方法进行扩容的相应判断和操作。
  • 第二步就是调用System.arraycopy(elementData, index, elementData, index + 1,size - index)方法将数组从下标index处分开，以便于插入操作。
  • 第三步就是在对应下标index处赋值了。

addAll（Collection<? extends E> c）

第三个就是增添一个集合的数据了。

public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew); 
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

这个方法分为四步：

  • 第一步：将传入的集合转换为数组，并求出转换的数组长度。
  • 第二步：调用ensureCapacityInternal(size + numNew)方法，根据计算出的长度和已有数组长度判断是否需要扩容。
  • 第三步：将新数组的内容从size开始全部添加到elementData数组中去。
  • 第四步：更新数组长度size。

addAll(int index, Collection<? extends E> c)

这最后一个增的方法就是在指定下标处添加一整个集合了。

public boolean addAll(int index, Collection<? extends E> c) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(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;
}

这个方法一共有六步：

  • 第一步：判断index和原数组的长度关系，如果不符合逻辑则抛出异常。
  • 第二步：将传入的集合转换为数组，并求出转换的数组长度。
  • 第三步：调用ensureCapacityInternal(size + numNew)方法，根据计算出的长度和已有数组长度判断是否需要扩容。
  • 第四步：将原数组从index开始向后移动。
  • 第五步：将新数组的内容从index开始全部添加到elementData数组中去。
  • 第六步：更新数组长度size。

小结

  • 无论是add还是addAll，都是先判断是否越界，如果越界就扩容，然后再移动数组
  • 如果需要扩容，默认扩容原来的一般大小；如果还不够，那就直接将目标的size作为扩容后的大小

删

remove(int index)

第一个删的方法是remove(int index)方法，这个方法是删除指定下标的集合元素

public E remove(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
	//第一步：修改集合结构和长度，要先修改modCount
    modCount++;
    //第二步：获取该下标的元素
    E oldValue = (E) elementData[index];
	//第三步：利用numMoved来判断删除的元素是否是最后一个元素，如果不是，则要将index后面的元素往前移动
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,numMoved);
    //第四步：将最末尾元素置null
    elementData[--size] = null;
    return oldValue;
}

remove(Object o)

第二个则是remove(Object o)方法，删除集合中的指定元素（仅仅删除一个）

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

这个方法主要的两个for循环是寻找集合中有没有和传入参数相同的数据，主要的删除操作是调用的fastRemove(index)方法：

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
}

这个方法和remove（int index）方法几乎一样，步骤也几乎一样。

  • 第一步：修改集合结构和长度，要先修改modCount
  • 第二步：利用numMoved来判断删除的元素是否是最后一个元素，如果不是，则要将index后面的元素往前移动
  • 第三步：将最末尾元素置null

removeAll(Collection<?> c)

刚才那个是删除集合中的一个相同元素，这个removeAll顾名思义就是删除集合中所有与参数相同的数据。

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

我们看到这个方法中实际调用了batchRemove(c, false)方法进行操作。

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 {
        //第二步：将后面的元素全部置空
        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;
}

retainAll(Collection<?> c)

这个删除操作意为只保留两个集合的交集。这个方法和removeAll(Collection<?> c)方法挺像，只不过就是更改了一个参数complement。上一个是将所有不同的元素放在前面，而这个是将所有相同的元素放在前面，然后置空后面的数据。

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

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 {
        //第二步：将后面的元素全部置空
        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;
}

clear（）

这个删除操作是将集合中元素全部清除

public void clear() {
    modCount++;
    // 直接遍历每一位，然后把每一位都置空，让GC去清理
    for (int i = 0; i < size; i++)
        elementData[i] = null;
    size = 0;
}

小结

直接正常的数组删除操作，就是判断是不是末尾，如果是，就直接赋值为null，如果不是，就将数组后面的内容全部往前移1位，然后把最后面赋值为null。所有的删除操作都会修改modCount。

改

set(int index, E element)

改操作只有这一个方法操作，也就是修改指定下标的数据。

public E set(int index, E element) {
    //第一步：判断index与size的大小关系是否合理
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    //第二步：取出原有元素
    E oldValue = (E) elementData[index];
    //第三步：将准备更改的元素放进去
    elementData[index] = element;
    return oldValue;
}

不需要修改modCount

查

get(int index)

public E get(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

    return (E) elementData[index];
}

非常简单，不需要更改modCount。

是否包含 contains(Object o)

这个方法判断一个集合中是否包含某个元素。

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

这个方法主要调用了indexOf(o)方法，我们来看一下：

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

这个方法就是遍历集合，寻找是否有相同的元素，有则返回下标，没有则返回-1到contains方法中与0对比。

判空方法 isEmpty()

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

这个方法直接判断size是否为0就可以了

缩容trimToSize()

这个方法用于将一个集合的长度大小修改成为集合中元素的数量大小

public void trimToSize() {
    //第一步：修改modCount
    modCount++;
    //第二步：如果size为0，则直接把EMPTY_ELEMENTDATA复制过去，否则则调用Arrays.copyOf方法复制
    if (size < elementData.length) {
        elementData = (size == 0)? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
    }
}

迭代器Iterator

什么是迭代器Iterator？

Iterator是一种接口，为各种不同的数据结构提供统一的访问机制。 任何数据结构只要部署 Iterator 接口，就可以完成遍历操作（即依次处理该数据结构的所有成员）。

Iterator是一个特殊的对象：
1. 它具有next()方法，调用该方法就会返回一个结果对象
2. 结果对象有两个属性值：value和done。
3. value表示具体的返回值；done是布尔类型，表示集合是否完成遍历，没有则返回true，否则返回false
4. 内部有一个指针，指向数据结构的起始位置。每调用一次next()方法，指针都会向后移动一个位置，直到指向最后一个位置

迭代器的作用：

  1. 为各种数据结构，提供一个统一的、简便的访问接口；
  2. 使得数据结构的成员能够按某种次序排列；
  3. 创造一种新的遍历命令for…of循环，Iterator 接口主要供for…of消费。

迭代器的简单使用

Collection<String> coll = new ArrayList<String>();	//多态
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
coll.add("abc4");
// 迭代器,对集合ArrayList中的元素进行取出
// 调用集合的方法iterator()获取Iterator接口的实现类的对象
Iterator<String> it = coll.iterator();
// 接口实现类对象,调用方法hasNext()判断集合中是否有元素
// boolean b = it.hasNext();
// System.out.println(b);
// 接口的实现类对象,调用方法next()取出集合中的元素
// String s = it.next();
// System.out.println(s);
// 迭代是反复内容,使用循环实现,循环的终止条件：集合中没元素, hasNext()返回了false
while (it.hasNext()) {
	String s = it.next();
	System.out.println(s);
}

输出为：

abc1
abc2
abc3
abc4

迭代器的源码

构造方法（创建迭代器）

public Iterator<E> iterator() {
    // 构造Itr对象并返回
    return new Itr();
}

这个方法创建一个Itr对象并且返回，那么我们下面就看以下Itr（）的源码就可以了。

Itr中的属性

//数组的元素个数
protected int limit = ArrayList.this.size; 
//下一个元素的下标
int cursor;
//上一次返回元素的下标
int lastRet = -1; 
//保存modCount，用于判断集合是否被修改过
int expectedModCount = modCount;

hasNext（）方法

public boolean hasNext() {
    return cursor < limit;
}

这个就是判断下一个元素的下标是否小于limit当前数组元素个数，如果小于则返回true，证明有下一个元素。

next（）方法

返回数据

public E next() {
    // 判断是否修改过List的结构，如果修改了就抛异常
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
    int i = cursor;
    // 如果越界了就抛异常
    if (i >= limit)
        throw new NoSuchElementException();
    Object[] elementData = ArrayList.this.elementData;
    // 再次判断是否越界，有可能在我们这里的操作时，有异步线程修改了List
    if (i >= elementData.length)
        throw new ConcurrentModificationException();
    // 标记加1
    cursor = i + 1;
    // 返回数据，并设置上一次的下标
    return (E) elementData[lastRet = i];
}

remove（）方法

public void remove() {
    if (lastRet < 0)
        throw new IllegalStateException();
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();

    try {
        // 调用ArrayList的remove方法移除数据
        ArrayList.this.remove(lastRet);
        // 更新一系列数据
        cursor = lastRet;
        lastRet = -1;
        expectedModCount = modCount;
        limit--;
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

总结

ArrayList的扩容因子为什么是1.5？

k=1.5时，就能充分利用前面已经释放的空间。如果k >= 2，新容量刚刚好永远大于过去所有废弃的数组容量。

为什么不取扩容固定容量呢？

扩容的目的需要综合考虑这两种情况：

扩容容量不能太小，防止频繁扩容，频繁申请内存空间 + 数组频繁复制

扩容容量不能太大，需要充分利用空间，避免浪费过多空间；

而扩容固定容量，很难决定到底取多少值合适，取任何具体值都不太合适，因为所需数据量往往由数组的客户端在具体应用场景决定。依赖于当前已经使用的量 * 系数， 比较符合实际应用场景。

比如，我现在已经用到一个数组100的容量，接下来很可能会有这个数量级的数据需要插入。

为什么是1.5，而不是1.2，1.25，1.8或者1.75？

因为1.5 可以充分利用移位操作，减少浮点数或者运算时间和运算次数。

为什么数组长度的最大值MAX_ARRAY_size是Integer.MAX_VALUE - 8

数组作为一个对象，需要一定的内存存储对象头信息，对象头信息最大占用内存不可超过8字节。

modCount到底是什么东西

在看ArrayList、HashMap源码的时候发现，很多时候只要涉及到了元素的增删就会伴随着modCount的++。那么为什么要有这个modCount？

modCount字面意思就是修改次数，用到modCount的地方，比如ArrayList、hashMap、LinkedList等等，他们都是现成不安全的，所以只要是修改了结构的地方，就会将modCount++，然后再遍历时就会去判断当前的modCount是否相等，如果不相等则证明此线程在遍历时有其他线程对集合发生了修改。

Fial-Fast机制

我们都知道这些集合是线程不安全的，如果在使用迭代器的过程中，有其他线程对集合进行了修改，那么就会抛出ConcurrentModificationException异常，这就是Fail-Fast策略。而这个时候源码中就通过modCount进行了操作。迭代器在创建时，会创建一个变量等于当时的modCount，如果在迭代过程中，集合发生了变化，modCount就是++。这时迭代器中的变量的值和modCount不相等了，那就抛异常。

所以，遍历线程不安全的集合时，尽量使用迭代器

如何实现线程安全的ArrayList

  1. 所有涉及到改变 modCount 值得地方全部加上 synchronized
  2. 直接使用 Collections.synchronizedList
  3. 使用Vector
  4. 使用CopyOnWriteArrayList替换ArrayList

ArrayList和Vector的区别

  • ArrayList线程不安全，Vector线程安全。都允许值为null。
  • 默认大小都是10
  • 扩容的时候ArrayList默认扩容原大小的1.5倍，Vector默认扩容原大小的2倍(可自定义)。

ArrayList和LinkedList

  • 都允许空值。
  • ArrayList是数组实现的，有扩容操作。LinkedList是链表实现，双向链表。
  • ArrayList的get/set性能好，LinkedList的插入和删除性能好。可是事实并不是这样，如果是从头部开始插入，LinkedList性能比ArrayList好；从中间插入，ArrayList却远好于LinkedList；从尾端插入，ArrayList比LinkedList好。
  • LinkedList同时还支持堆栈、队列的API，所以也可以把它当做堆栈、队列使用。
  • ArrayList的遍历就是简单的从0开始遍历，而LinkedList他会判断当前的值是前半部分还是后半部分，对应的就从头还是尾开始遍历。
3gAndroid
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ArrayList扩容问题
qq_43498002的博客
06-16 934
1、ArrayList.add方法 1.1、ensureCapacityInternal minCapacity是add方法中传入的size+1的值 calculateCapacity返回的是10或者minCapacity的值， 如果待扩展的容量大于数组长度，则要调用grow方法扩展容量 grow方法具体操作容量的扩展 数组容量要扩展1.5倍（原长度加上原长度右移一位即0.5倍）， 若扩展1.5倍后还不够数组增加的内容，则数组容量就为数组增加的内容长度， 若扩展长度大于int类型最大值，则扩展容
ArrayList扩容一般是1.5倍扩容或2倍扩容
Feixiangdechenyu的博客
06-17 1390
通过选择1.5倍的扩容，可以在一定程度上减少频繁扩容的次数，同时也避免了过多的内存浪费。在Java中，ArrayList的扩容策略是相对灵活的，具体的扩容倍数会根据实际情况进行选择。更新内部数组和元素数量：扩容完成后，ArrayList会将内部数组设置为新的数组，并更新元素数量属性为当前元素的个数。通常情况下，新容量是当前容量的一定倍数（例如，通常是当前容量的1.5倍或2倍）。创建新的内部数组：根据新的容量，ArrayList会创建一个新的内部数组，用于存储元素。这样可以避免在初始阶段进行频繁的扩容操作。
ArrayList 详解(为什么初始容量10,扩容1.5倍?)
xx12321q的博客
03-02 6983
ArrayList ArrayList 是 List 接口底下的实现类 , 底层是数组, 可自动扩容 , 满足数组的所有特性 先来看它的构造方法 ArrayList() : 构造一个初始容量为10的空列表 ArrayList(collection<? exteds E> c) 构造一个包含指定集合的列表 ArrayList(int initialCapacity) 构造一个指定初始容量的空列表 从构造方法中可以看出 , 如果我们使用无参的构造方法的话 , 底层的数组默认长度就是10
ArrayList扩容机制
编码小波的博客
10-10 4090
ArrayList扩容机制 ArrayList每次扩容是原来的1.5倍。数组进行扩容时，会将老数组中的元素重新拷贝一份到新的数组中，每次数组容量的增长大约是其原容量的1.5倍。这样代价是很高的，因此在实际使用时，我们应该尽量避免数组容量的扩张。尽可能指定其容量，以避免数组扩容的发生。 初始化方式不同，容量也不同： 初始化方式 容量 数量变化 List arrayList = new ArrayList(); 初始数组容量为10,当真正对数组进行添加时，才真正分配容量 10->15-&g
Arraylist动态扩容
kevin
06-13 235
JDK1.7环境 1、构造参数 ArrayList() ArrayList(int initialCapacity)用指定的大小来初始化内部的数组 ArrayList(Collection<? extends E> c)用一个ICollection对象来构造，并将该集合的元素添加到ArrayList 2、ArrayList() ArrayList list = ne...
Java集合系列之ArrayList源码分析
08-27
主要为大家详细介绍了Java集合系列之ArrayList源码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java集合框架ArrayList源码分析（一）
09-01
主要为大家详细介绍了Java集合框架ArrayList源码分析，感兴趣的小伙伴们可以参考一下
Java进阶课程系列之ArrayList集合底层源码实战分析
06-16
? ArrayList?是一种变长的集合类，基于定长数组实现...本节课程会带着大家去学习集合底层源码是什么个结构，他在做什么事情，能做到什么事情，会出现的问题以及解决方法，希望同学能够仔细听，详细你会收到丰富的回报的
深入Java集合ArrayList的源码解析
12-21
现在由大恶人付有杰来从增删改查几个角度轻度解析ArrayList的源码 首先ArrayList的底层数据结构非常简单，就是一个数组。 从源码第115行我们可以得出信息，他的默认数组长度是10。 /** * Default initial capacity...
java集合源码-jdk-collection:java集合类源码阅读
05-19
集合源码 JDK-Collection集合入门 总的list和set类结构大致如下所示 Map不继承Collection,其结构如下 首先介绍下迭代器的概念 迭代器无非是一个接口,假设我们有一个数组,如果我们要实现迭代器,只需要根据该接口定义...
ArrayList 底层学习（初始容量为10？每次扩容1.5倍？）
qq_46381044的博客
08-06 960
ArrayList 是 List 接口下的实现类，它的底层是数组，可以自动扩容。它的底层数组如下： Arraylist()：构造的是一个初始容量为10的空列表ArrayList(int initialCapacity)：构造的是一个指定初始容量的一个空列表 从源码可以看到，赋予底层 elementData 的是一个空数组，那我们为什么说它的默认容量为10呢？因为 ArrayList 起初创建的是一个空数组，在第一次调用add()方法时为初始数组扩容，因此初始容量变成了10。 add(）中调用了 ensure
ArrayList 集合扩容
qq_45981503的博客
05-10 2337
ArrayList 初始容量：10 扩容因子：1，当容量达到上限后才会触发扩容。 扩容公式：新容量 = 旧容量/2 + 旧容量 + 1 比如：初始容量为4，其容量的每次扩充后的新容量为：4->7->11->17->26->... 即每次扩充至原有基础的1.5倍 Vector 初始容量：10 扩容因子：1，当容量达到上限后才会触发扩容。 扩容公式：old*2 如：一次扩容为20、二次扩容为40 HashSet 初始容量：16（Hashset是基于Has..
Java—ArrayList（扩容机制）
一起加油吧~
05-19 1万+
对于ArrayList集合可能大家并不陌生，但ArrayList集合的扩容机制大家是否了解呢？我们今天着重来看看 目录 适用于什么场景？ ArrayList特点 实战演练 ArrayList扩容机制 综上所述，ArrayList的特点如下 适用于什么场景？ 检索比较多的场景 ArrayList特点 1、ArrayList集合底层采用了数据这种数据结构，是Object类型 2、ArrayList的默认初始容量为10，扩容因子为1.5 3、建议给定一个预估计的初始化容量，减少
ArrayList默认大小，以及扩容倍数。
流浪者的博客
01-30 9517
目录 1、结果 2、分析 2.1、初始大小 2.2、加载因子 2.3、扩容倍数 2.4、底层实现 1、结果 此文章基于Jdk1.8,以及无参构造函数来的。1.7我粗略看了一下啊，基本也是这样，没仔细看，只是不敢确保。 初始大小 加载因子 扩容倍数 底层实现 是否线程安全 0 1 旧容量+旧容量右移一位 即 a+(a/2) Object数组 线程不安全 2、分析 2....
ArrayList扩容1.5倍
热门推荐
不善言谈者
01-24 2万+
先写一个小案例 代码 package com.itheima.demo; import java.lang.reflect.Field; import java.util.ArrayList; public class ArrayListDemo { public static void main(String[] args) { ArrayList&lt;I...
都说新的Arraylist 扩容是(1.5倍+1) 看了1.8的源代码发现不是这么回事
abcdef00001111234的博客
11-05 1710
都说新的Arraylist 扩容是(1.5倍+1) 看了1.8的源代码发现不是这么回事 就用下面这段代码在jdk的三个版本运行看了下效果 import java.lang.reflect.Field; import java.util.ArrayList; public class ArrayListDemo { public static void...
java源码中的hashmap,hashtable,arraylist,linkedlist
最新发布
09-15
答：hashmap、hashtable、arraylist和linkedlist都是Java源码中常用的数据结构。hashmap是一种散列表，它使用键值对来存储数据；hashtable是一种哈希表，它使用散列函数来存储数据；arraylist是一种动态数组，它可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值