ArrayList源码阅读、扩容

最新推荐文章于 2023-02-08 10:08:14 发布
最新推荐文章于 2023-02-08 10:08:14 发布
阅读量142 收藏
点赞数
分类专栏： java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40945081/article/details/115796107
版权

ArrayList

一、基础构成

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892189L;
    
    private static final int DEFAULT_CAPACITY = 10;
    
    private static final Object[] EMPTY_ELEMENTDATA = {};
    
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    
    transient Object[] elementData; // non-private to simplify nested class access
   
    private int size;
 }

1、实现了Serializable接口，可序列化，且有版本号
2、DEFAULT_CAPACITY=10 默认初始化数组大小
3、EMPTY_ELEMENTDATA 当自定义大小创建ArrayList时使用这个实例
4、DEFAULTCAPACITY_EMPTY_ELEMENTDATA 反之则使用这个实例
5、elementData，ArrayList维护的数组引用
6、size数组内元素个数

二、add(E)方法

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

1、首先要确定数组内部空间是否够用，每次添加都要进行判断。看其内部

private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

2、这里又调用了calculateCapacity，而且将elementData传入了进去。

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

1、这里判断ArrayList是不是使用无参构造器创建的，且是第一次扩容
2、如果是的话，就返回默认数组大小和传入的参数中最大的一个
3、如果不是，就直接返回传入的参数

3、再看ensureExplicitCapacity

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

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

1、modCount是继承自AbstractList的属性，记录修改次数
2、如果传入的参数大于数组的大小则进行扩容
3、执行grow(minCapacity);

4、grow(minCapacity);

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        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);
    }
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

1、记录当前数组大小，成为旧容量
2、新容量为旧容量的1.5倍
3、判断新容量如果小于传入参数，则将新容量改为传入参数
4、如果新容量大于最大容量，进入hugeCapacity(minCapacity)，如果传入参数溢出，抛出异常，如果传入参数比最大的容量，则为整数的最大值，否则为最大的数组容量，就是整数最大值减去8
5、复制进行扩容

弄几个例子加深理解：

2.1 new ArrayList()之后add

import java.util.ArrayList;

public class Demo01 {
    public static void main(String[] args) {
       	ArrayList<Integer> integers = new ArrayList<Integer>();
        integers.add(1);
    }
}

内部如何执行的呢？

1、new ArrayList<>(),无参构造方法，源码如下

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

所以内部的elementData就被赋值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA

2、执行add()方法，此时size为0，element为DEFAULTCAPACITY_EMPTY_ELEMENTDATA
  1. 执行ensureCapacityInternal(1);
  2. calculateCapacity(DEFAULTCAPACITY_EMPTY_ELEMENTDATA, 1)，这一步返回10
  3. ensureExplicitCapacity(10)，因为10>DEFAULTCAPACITY_EMPTY_ELEMENTDATA.length,所以进行扩容grow(10)
  4. 最后经过层层判断执行elementData = Arrays.copyOf(DEFAULTCAPACITY_EMPTY_ELEMENTDATA, 10);
  5. 最终得到一个新的数组，初始容量为10
  6. 回到add方法中element[0]=1 size++=1
  7. 返回一个true

那如果再integers.add(2)呢？

  1. ensureCapacityInternal(2);
  2. calculateCapacity里面的判断不满足，直接返回2
  3. 2<elementData.length，不进行扩容

2.2 new ArrayList<>(0)之后add

import java.util.ArrayList;

public class Demo01 {
    public static void main(String[] args) {
        ArrayList<Integer> integers = new ArrayList<>(0);
        integers.add(1);
    }
}

没有人会这样用，只是为了加深理解

用的是这个构造器：

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

1、因为使用的不是无参构造器，所以当initialCapacity为0的时候，会赋值为EMPTY_ELEMENTDATA
2、因此calculateCapacity()返回的就是1
3、在ensureExplicitCapacity中因为1>0所以进行扩容
4、最后扩容为1

因此可以推测，再次进行add的时候会这样进行：

1、calculateCapacity()返回2
2、ensureExplicitCapacity 2>1
3、11.5<2 所以扩容为2
再次add
calculateCapacity返回3，3>2 ，21.5=3 扩容为3
再次add
返回4，4>3，31.5=4 扩容为4
再次add
返回5，5>4，41.5>5 扩容为6
…

再用反射确定一下，一共add了5次：

import java.lang.reflect.Field;
import java.util.ArrayList;

public class Demo02 {
    public static void main(String[] args) throws Exception {
        ArrayList<String> arrayList = new ArrayList<>(0);
        Class<? extends ArrayList> aClass = arrayList.getClass();
        Field elementData = aClass.getDeclaredField("elementData");
        elementData.setAccessible(true);
        System.out.println(elementData.getName());
        arrayList.add("a");
        System.out.println(((Object[])elementData.get(arrayList)).length);
        arrayList.add("b");
        System.out.println(((Object[])elementData.get(arrayList)).length);
        arrayList.add("c");
        System.out.println(((Object[])elementData.get(arrayList)).length);
        arrayList.add("d");
        System.out.println(((Object[])elementData.get(arrayList)).length);
        arrayList.add("3");
        System.out.println(((Object[])elementData.get(arrayList)).length);
    }
}

运行结果：
在这里插入图片描述
所以千万不要new ArrayList<>(0)这么干，前面每次添加一个元素都要扩容一次，效率十分糟糕！除非确认整个list的容量是确定的且小于10，否则不要initialCapacity<10。

2.3 new ArrayList<>(Collection<? extends E> c)之后add

先看以下new ArrayList<>(Collection<? extends E> c)的源码

public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

传入的参数必须是一个实现了Collection接口的类的对象。

1、将传入的参数转为一个数组，并赋给elementData
2、同步数组长度到size，并判断不是一个空数组
3、如果是空数组则直接将EMPTY_ELEMENTDATA赋给elementData
4、如果不是，再判断数组类型是否是Object[].class
5、如果不是就Copy过去，如果是则什么不用做，因为前面已经赋值了。

所以他的add和使用new ArrayList<>(initialCapacity)，没有什么区别，都是按照1.5倍进行 扩容的。如果传入的参数toArray之后是一个空数组，那就完全等同于new ArrayList<>(0)，十分糟糕。

有一点我不太明白，为什么传入参数转换之后是空数组的时候，
要将EMPTY_ELEMENTDATA赋值给elementData，这样子做很影响扩容，
为什么不将DEFAULTCAPACITY_EMPTY_ELEMENTDATA 赋值给elementData，
这样再扩容的时候就会有个初始的10扩容了。

所以对于这个构造器总结了以下三点：

  1. 不要传入一个所含元素较少或者空元素的对象进行构造ArrayList
  2. 如果要将一个所含元素较少的对象转为ArrayList，且以后这个里面很少进行添加操作，可以直接使用这个构造器
  3. 否则最好使用new ArrayList<>()创建之后，再进行添加

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

这个不能叫添加，这个是在指定位置插入一个元素。

1、rangeCheckForAdd(index);进去看看

private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

必须在size以内进行插入，且不能小于0，否则IndexOutOfBoundsException

我在这里容易把size和element.length搞混淆，增加删除要更新size，element.length是容量，不能隔位进行插入。

2、ensureCapacityInternal(size + 1);熟悉的扩容，不在赘述
3、System.arraycopy(elementData, index, elementData, index + 1,size - index);
	在下标为index位置插入，将index和其之后的所有元素向后面移动一位。
4、elementData[index] = element;插入进去
5、size++

//将index后的size-index个元素赋值到inedx+1后的位置上
System.arraycopy(elementData, index, elementData, index + 1,size - index);

四、一些简单的方法

4.1 set(int index, E element)

将第index个元素替换为element

源码：

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

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }
  1. 先检查范围，不再赘述
  2. 将旧的值取出来
  3. 新的值放进去
  4. 旧的值返回

4.2 get(int index)

获取下标为index的值

public E get(int index) {
   rangeCheck(index);
   return elementData(index);
}

E elementData(int index) {
    return (E) elementData[index];
}

4.3 trimToSize()

将数组的容量capacity和size置为相等，就相当于把多余的空间给去掉。

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

当ArrayList刚创建的时候，因为size和elementData.length相等，所以调用没有作用
当ArrayList确定不再添加元素的时候可以调用，回收未使用的空间

4.4 size()

public int size() {
    return size;
}

4.5 isEmpty()

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

4.6 contains(Object o)

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

调用了indexOf方法 

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

可以看到：如果是null使用==判断，如果不是null使用equals判断
之所以这样是因为当为null的时候，使用equals会报空指针异常

4.7 lastIndexOf(Object o)

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

反向遍历判断

4.8 clone()

返回一个ArrayList的实例

public Object clone() {
    try {
        ArrayList<?> v = (ArrayList<?>) super.clone();
        v.elementData = Arrays.copyOf(elementData, size);
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError(e);
    }
}

4.9 toArray()和T[] toArray(T[] a)

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

返回Object[]类型的

public <T> T[] toArray(T[] a) {
    if (a.length < size)
        // Make a new array of a's runtime type, but my contents:
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

返回泛型类型的数组，不过需要传入一个数组
这个数组的类型是泛型数组类型。如果传入数组长度小于size，会返回一个新的数组，里面包含所有元素
如果长度大于size，会将元素copy到这个数组内去。

4.10 E remove(int index)

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

1、先checkRange
2、将要remove的值取出来
3、获得index之后的元素的个数
4、当index!=size的时候，把之后的元素都向前移动一位
5、将最后一位置空等待垃圾回收器回收
6、返回删除的值

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

先遍历找到后删除成功返回true，找不到返回false。删除调用了fastRemove

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就是不返回删除的元素

4.12 clear()

public void clear() {
    modCount++;

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

    size = 0;
}

将所有的元素置空，size复制为0，置空就是等待垃圾回收器回收

4.13 addAll(Collection<? extend E> c)

将一个集合类添加到ArrayList中去

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

和add差不多，先看容量，然后统一的将a复制到elementData最后面，只要传入参数含有元素，就返回true

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

在index位置插入一个集合

1、查询index是否越界
2、获取要插入的数组长度，看容量进行扩容与否
3、将index之后的元素移动到index+numNew
4、将数组复制到element中index起始的位置
5、更新size
6、返回true or false，看numNew是否为0

4.14 removeAll(Collection c)、retainsAll(Collection c)

1、removeAll(Collection)，将elementData与c的交集从elementData中删去
2、retainsAll(Collection c)，将elementData与c的交集留下，其他的从elementData中删去

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

c不能为空，否则NullPointerException

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

同上，c不能为空

二者都调用了batchRemove，区别在于第二个参数一个是false，一个是true

看看batchRemove

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

先看try中的内容：

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

1、当c包含一个元素，且complement为true时，将elementData从0往后依次赋值，这样就保留下来了交集，所以retainsAll传入的是true
2、同理，不包含一个元素返回false，complement为false，就删除了交集

因为判断与赋值都是再elementData中进行的，所以还需要进一步处理。
经过了try之后，elementData[w] (包括自己)之前的的元素都是需要的。
w之后的到r都是不需要的。

再看finally中的内容：

// Preserve behavioral compatibility with AbstractCollection,
// even if c.contains() throws.
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;
}

注释含义：c.contains()可能抛出异常，要保证兼容性。就是说可能处理到了一半发生异常了，这个时候该怎么补救。

1、如果没处理完抛出异常，就会走第一个if
2、将r后面剩下的size-r个元素，复制w之后，不管是retain还是remove，这样做的好处是可以对传入参数维护之后再次调用，不影响结果
3、更新w
4、第二个if，就是将w~size中没有用到的位置置空，给垃圾回收器回收

这个返回值，如果elementData没有任何改动就返回false，如果有改动就返回true

五、内部类，迭代器

之后再补吧眼睛疼死了，干了一天的游戏

阿兰你在哪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ArrayList的add()方法源码分析（jdk1.8）
qq_50748627的博客
08-28 542
成员变量 //默认的初试容量 private static final int DEFAULT_CAPACITY = 10; // 当你造了一个指定长度为0的数组，就会把elementData实例化为这个长度为0的数组 private static final Object[] EMPTY_ELEMENTDATA = {};、 // 当你造一个默认长度ArrayList时，就会把emementData实例化为这个长度为0的数组 private static final Object[] DEFAULT.
ArrayList源码解读
AthonyDavis的博客
08-13 192
ArrayList源码解读 ArrayList简介 下文简介翻译自ArrayList源码注释。 List接口的可调整大小的数组实现。 实现所有可选的列表操作，并允许所有元素，包括null 。 除了实现List接口之外，该类还提供了操作内部用于存储列表的数组大小的方法。 （这个类大致相当于Vector ，只是它是不同步的。） size 、 isEmpty 、 get 、 set 、 iterator和listIterator操作在恒定时间内运行。 add操作在分摊常数 time 内运行，即添加 n 个元素需
初始化ArrayList的两种方法
lvjingWn的博客
06-22 1110
方式一： ArrayList list = new ArrayList(); String str01 = String(“str01”); String str02 = String(“str02”); list.add(str01); list.add(str02); 方式二： ArrayList list = new ArrayList(){{add(“...
java add_java中的ArrayList.add()方法
weixin_28837357的博客
02-19 100
案例：import java.util.*;public class ArrayListTest{public static void main(String[] args){ArrayList al = new ArrayList();al.add("one");al.add("two");for (int i=1;i{System.out.println(al.get(i));}}}/*Arr...
ArrayList.add方法底层浅析
qq_38217990的博客
02-08 1370
ArrayList.add方法底层浅析
关于ArrayList的add方法添加元素，使ArrayList里面元素都会被同化成最后一次add的值的问题
Explore
10-04 402
问题背景： 在力扣刷题的时候，刷到一个题可以用回溯法解，但是在解题过程中碰到一个Arraylist的add方法添加对象元素时，出现同化整个Arraylist里所有元素的问题。 解决思路： 通过搜索得知，Arraylist的add方法添加对象时，添加的是对象的地址。 附代码看看： static ArrayList result = new ArrayList<>();//result public static void backtracking(StringBuffer b ,int start
ArrayList扩容机制、底层源码解读
lyllzcllf的博客
01-03 475
ArrayList扩容机制、底层源码解读 ArrayList的底层操作机制源码分析 ArrayList中维护了一个Object类型的数组elementData ;transient Object[] elementData; //transient 表示瞬间，短暂的，表示该属性不会被序列号 当创建对象是，如果使用的是无参构造器，则初始elementData容量为0(jdk7是10) 当添加元素时，先判断是否需要扩容，如果需要扩容，则条用grow方法，否则直接添
ArrayList扩容机制源码解析.md
12-06
本资源根据个人学习和总结，主要介绍Java中ArrayList扩容机制源码的解析，主要包含文字和代码等内容，以源码的形式进行分析，详细介绍了ArrayList扩容机制的整个流程，特此将该资源分享
ArrayList源码.zip
03-13
当添加元素时，如果当前容量不足，ArrayList会自动扩容，通常扩容为原来的1.5倍。这种设计使得ArrayList在插入元素时有较好的性能表现，但删除元素特别是中间位置的元素时，效率相对较低，因为需要移动后续元素。 ...
ArrayList源码分析
05-05
- 预估容量：在创建ArrayList时，根据预期的元素数量预设容量，可以减少扩容次数，提高性能。 - 尽量避免在循环中调用`add()`或`remove()`，因为这可能导致多次扩容或元素移动。 10. **异常处理** ArrayList的...
Java编程中ArrayList源码分析
08-28
ArrayList的主要特点是其容量可以自动增长，可以根据需要自动扩容。 二、时间复杂度 ArrayList的时间复杂度主要体现在添加、删除、get、set、iterator和listIterator等操作上。添加、删除操作的时间复杂度为O(N)，...
Java源码篇之容器类——ArrayList
12-20
初始容量为10，当数组容量不足时，会通过`ensureCapacityInternal`方法进行扩容，通常扩容为原来的1.5倍。 - **add()方法** `add()`方法用于在列表的指定位置插入元素。如果列表已满，它会创建一个新的更大的数组并...
看完这篇ArrayList，工资直接+1000
weixin_57907028的博客
07-01 197
前言 ArrayList小编猜想应该所有Java的小伙伴都用过，如果还有小伙伴没用过，请文末留言，你放学给我留下来我给你补习补习。本文是集合类讲解的第一篇，选择了一个相对比较简单、大家又比较熟悉的ArrayList开篇。集合是Java中非常重要而且基础的内容，因为任何数据必不可少的就是该数据是如何存储的，集合的作用就是以一定的方式组织、存储数据。 正文 狗剩：小编，新系列开启，还有点小激动呀！ 毕竟同时肝几个系列，也是有点要老命的，你看我这日渐光亮的头顶，哎，啥也不说了。 狗剩：…以后省洗发水了你，憋
ArrayList
qq_39323945的博客
09-20 1005
源码分析解答刚才的问题在哪里。
new ArrayList()和new ArrayList(0)的区别
qq_35358091的博客
10-12 5904
先来看一下ArrayList的两个常用的构造方法 public ArrayList(int initialCapacity) { if (initialCapacity > 0) { this.elementData = new Object[initialCapacity]; } else if (initialCapa...
js 函数的length
qiqiyiyi_的博客
03-30 1929
函数的 length 是 函数的形参个数 形参数量是指在第一个具有默认值之前的参数个数 console.log("==============", function (...arguments) { }.length) // => ============== 0 function () { }.length // => 0 function (c) { }.length // => 1 function (a, b) { }.length //
3秒搞定ArrayList
weixin_43924487的博客
06-15 746
jdk8 总结 扩容和删除 ArrayList 就是一个实现了List接口的可自动扩容的数组，**当添加元素的时候它会尝试扩容,扩容的标准是变为原来的1.5倍**，当删除元素的时候，它会左移元素，避免数组出现"空位" ** 容量** new ArrayList<>() 初始化容量为0，等到第一次add的时候再初始化为10 有序集合 可以存储重复值和null值 示例： public static void main(String[] args) {
Java创建List 的三种方法
热门推荐
白开水
12-29 2万+
java 基础知识
udp分片报文pcap文件
最新发布
07-18
udp分片报文pcap文件：64kudp大包分成每片658字节总计100片
ArrayList扩容源码分析
03-30
下面我们来看一下ArrayList扩容的源码实现。 在ArrayList中，扩容是由ensureCapacity方法实现的。当元素数量超过了数组容量时，该方法会调用grow方法来扩容数组。 ``` private void ensureCapacityInternal(int ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值