ArrayList底层结构和源码分析

_雨_

于 2023-04-24 01:45:00 发布

阅读量539

点赞数

分类专栏： Java 文章标签： java jvm 开发语言

本文链接：https://blog.youkuaiyun.com/weixin_53616401/article/details/130312911

版权

Java 专栏收录该内容

75 篇文章

订阅专栏

文章详细介绍了Java中的ArrayList类，强调其线程不安全的特性，适合单线程环境使用。通过源码分析，解释了ArrayList如何在添加元素时自动扩容，初始容量为0或指定大小，之后每次按1.5倍扩容。文章还提到ArrayList允许包含null元素，并提供了示例代码展示其用法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

ArrayList的注意事项

1.permits all elements, including null，ArrayList 可以加入null，并且多个

2.ArrayList是由数组来实现数据存储的

3.ArrayList 基本等同于Vector，除了ArrayList是线程不安全(执行效率高)看源码.在多线程情况下，不建议使用ArrayList

代码演示：

package idea.chapter14.collection_;

import java.util.ArrayList;

/**
 * 演示ArrayList的注意事项和使用细节
 */
@SuppressWarnings({"all"})
public class ArrayListDetail {
    public static void main(String[] args) {

        //ArrayList 是线程不安全的, 可以看源码 没有 synchronized修饰
        /*
            public boolean add(E e) {
                ensureCapacityInternal(size + 1);  // Increments modCount!!
                elementData[size++] = e;
                return true;
            }
         */
        ArrayList arrayList = new ArrayList();
        arrayList.add(null);
        arrayList.add("jack");
        arrayList.add(null);
        arrayList.add("hsp");
        System.out.println(arrayList);
    }
}

ArrayList源码分析结论

ArrayList的底层操作机制源码分析(重点，难点.)

1.ArrayList中维护了一个Object类型的数组elementData.[debug看源码]

transient Objectl] elementData; //transient 表示瞬间，短暂的，表示该属性不会被序列化

2)当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量为0，第1次添加，则扩容elementData为10，如需要再次扩容，则扩容elementData为1.5倍。

3)如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，则直接扩容elementData为1.5倍。

源码分析:

    /*
    //第一步
    先调用ArrayList的无参构造器，去创建一个空数组
        public ArrayList() {
            this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
        }

    //第二步
    调用add方法
    1.先确定是否要扩容
    ensureCapacityInternal(size + 1);这个方法就是判断是否要进行扩容，
    2.然后进行赋值

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

    //第三步
    指向ensureCapacityInternal方法，进入方法后先进行判断，
    private void ensureCapacityInternal(int minCapacity) {
        //我们第一次进行扩容的时候，此时elementData是null,因此会进入if语句
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
             DEFAULT_CAPACITY这是一个默认值，是10 minCapacity 是1
             因此Nath.max方法会在两个数中选出一个最大值赋值给minCapactiy 所以此时minCapacity就是10
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;//用来记录集合被修改的次数，主要是防止同时有多个线程去修改，如果有那么会抛出一个异常

    // overflow-conscious code
    minCapacity是我需要的最小容量
    elementData.length
    也就是说，我们需要10个的大小，但是你这个数组能给我提供的只有0 两数相减的结果去过大于0，说明就需要扩容了
    if (minCapacity - elementData.length > 0)
        //如果满足上面if的条件，那么就真的扩容
        grow(minCapacity);//真正的扩容的方法
}


//真的扩容的方法
private void grow(int minCapacity) {
    // overflow-conscious code
    第一次进行扩容的时候，因为数组是空 ，所以elementData.length就是0 所以把0赋值给了oldCapacity
    int oldCapacity = elementData.length;
    然后oldCapacity>>1 也就是把oldCapacity除2 但是因为oldCapacity是0 所以结果还是0 因此oldCapacity+（oldCapacity>>1）的结果还是0.把这个结果赋给newCapacity也是0
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    然后newCapacity - minCapacity  因为minCapacity是10 所以0-10小于0
    if (newCapacity - minCapacity < 0)
        然后就进入if语句 把 minCapacity 赋值给newCapacity 所以newCapacity的结果就是10 这也就是为什么，第一次扩容的时候 是10 第二次就按照1.5倍进行扩容
        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);
}

     */

package idea.chapter14.list_;

import java.util.ArrayList;

@SuppressWarnings({"all"})
public class ArrayListSource {
    public static void main(String[] args) {


        //注意Idea 默认情况下，Debug 显示的数据是简化后的，如果希望看到完整的数据
        //需要做设置.
        //使用无参构造器创建ArrayList对象
        ArrayList list = new ArrayList();
        //ArrayList list = new ArrayList(8);
        //使用for给list集合添加 1-10数据
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
        //使用for给list集合添加 11-15数据
        for (int i = 11; i <= 15; i++) {
            list.add(i);
        }
        list.add(100);
        list.add(200);
        list.add(null);


        /*
        //第一步
        先调用ArrayList的无参构造器，去创建一个空数组
            public ArrayList() {
                this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
            }

        //第二步
        调用add方法
        1.先确定是否要扩容
        ensureCapacityInternal(size + 1);这个方法就是判断是否要进行扩容，
        2.然后进行赋值

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

        //第三步
        指向ensureCapacityInternal方法，进入方法后先进行判断，
        private void ensureCapacityInternal(int minCapacity) {
            //我们第一次进行扩容的时候，此时elementData是null,因此会进入if语句
            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
                 DEFAULT_CAPACITY这是一个默认值，是10 minCapacity 是1
                 因此Nath.max方法会在两个数中选出一个最大值赋值给minCapactiy 所以此时minCapacity就是10
                minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
            }

            ensureExplicitCapacity(minCapacity);
        }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;//用来记录集合被修改的次数，主要是防止同时有多个线程去修改，如果有那么会抛出一个异常

        // overflow-conscious code
        minCapacity是我需要的最小容量
        elementData.length
        也就是说，我们需要10个的大小，但是你这个数组能给我提供的只有0 两数相减的结果去过大于0，说明就需要扩容了
        if (minCapacity - elementData.length > 0)
            //如果满足上面if的条件，那么就真的扩容
            grow(minCapacity);//真正的扩容的方法
    }


    //真的扩容的方法
    private void grow(int minCapacity) {
        // overflow-conscious code
        第一次进行扩容的时候，因为数组是空 ，所以elementData.length就是0 所以把0赋值给了oldCapacity
        int oldCapacity = elementData.length;
        然后oldCapacity>>1 也就是把oldCapacity除2 但是因为oldCapacity是0 所以结果还是0 因此oldCapacity+（oldCapacity>>1）的结果还是0.把这个结果赋给newCapacity也是0
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        然后newCapacity - minCapacity  因为minCapacity是10 所以0-10小于0
        if (newCapacity - minCapacity < 0)
            然后就进入if语句 把 minCapacity 赋值给newCapacity 所以newCapacity的结果就是10 这也就是为什么，第一次扩容的时候 是10 第二次就按照1.5倍进行扩容
            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);
    }

         */
    }
}