专栏首页JavaEdgeArrayList源码解析(基于Java8)扩容删除

ArrayList源码解析(基于Java8)扩容删除

首先:执行List<Person> list1 = new ArrayList<>(); 在堆内存开辟了一块空间,既然是new出来的,那我们直接从构造函数入手

很简单一行代码,继续看一下

this.elementData

DEFAULTCAPACITY_EMPTY_ELEMENTDATA

分别是什么

Object[]数组,也就是说该数组可以放任何对象(所有对象都继承自父类Object)

static修饰的变量,常驻于方法区,我们不需要new,JVM会提前给我们初始化好,这个特性在实际开发过程中,经常拿来做缓存 fianl修饰的变量,JVM也会提前给我们初始化好

继续,执行list1.add(person1)看怎么处理add的

先看ensureCapacityInternal方法,有个参数size,看一下这个size从哪来的

size是int基本数据类型,成员变量初始化的为0

继续往下看

ensureCapacityInternal是在add里面调用的

private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        //如果底层数组就是默认的缓存数组,取两个参数的大的一个值继续往下调用,很明显这个大值为10
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
 }

 private void ensureExplicitCapacity(int minCapacity) {
        modCount++;//记录修改次数

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

扩容

    private void grow(int minCapacity) {
        // 取到旧数组的长度
        int oldCapacity = elementData.length;
        //计算新数组的长度
        //>>是移位运算符,相当于int newCapacity = oldCapacity + (oldCapacity/2),但性能会好一些
        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);
    }

这就是数组的扩容,一般是oldCapacity + (oldCapacity >> 1),相当于扩容1.5倍

跟进到Arrays这个工具类,很简单

再看copyOf()方法

System.arraycopy()方法用了一个native来修饰。 native的方法,是由其它语言来实现的,一般是(C或C++),所以这儿没有实现代码。 这是一个数组拷贝方法,大家还在写for循环拷贝数组吗?以后多用这个方法吧,简单又方便还能获得得更好的性能。

顺便看一看size()方法的源码

很简单,就是返回size值,而不是底层数组的长度,就是为何String里叫length()而List里叫size()的原因

有人说,诶,就一个元素,在堆内存中占了10个位置,好浪费啊,没办法,你要享受ArrayList的便利与丰富的API,就得牺牲一下空间作为代价

ArrayList还提供了其它构造方法,我们顺便来看一下

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

当我们在写代码过程中,如果我们大概知道元素的个数,比如一个班级大概有40-50人,我们优先考虑List<Person> list2 = new ArrayList<>(50)以指定个数的方式去构造,这样可以避免底层数组的多次拷贝,进而提高程序性能。

在长度为n数组中: 直接通过下标去访问元素,时间复杂度为O(1) 需要循环查找元素的时候,时间复杂度为O(n)

删除

删除指定位置的元素

public E remove(int index) {
        rangeCheck(index);

        //维护的一个变量,记录修改次数
        modCount++;
        //根据数组下标拿到底层数组里的元素
        E oldValue = elementData(index);

        //计算数组需要拷贝的元素个数
        int numMoved = size - index - 1;
        if (numMoved > 0)
            //拷贝删除位置(index)+1后面的numMoved个元素并从删除位置(index)开始复制
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        //相当于:size = size - 1; elementData[size] == null
        //size减1,数组最后一个位置赋值为null
        elementData[--size] = null; // clear to let GC do its work

        //返回事先拿到的删除元素
        return oldValue;
}

这段代码里还调了一个方法rangeCheck()方法,我们看一下

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

好简单对不对,就是检查底层数组下标是否越界。我们再看另外一种删除方式

删除指定对象元素

public boolean remove(Object o) {
        //如果要删除的元素为null
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    //循环查找null,找到后执行fastRemove()方法
                    fastRemove(index);
                    //删除成功,返回true
                    return true;
                }
        } else {
            //要删除元素非空
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    //equals循环对比,对比成功则执行fastRemove()方法
                    fastRemove(index);
                    //删除成功,返回true
                    return true;
                }
        }
        //其他情况,返回 false
        return 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
}

和上面用下标删除方式一致,就是少了某些代码,就不细说了

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • AbstractList源码解析1 实现的方法2 两种内部迭代器3 两种内部类3 SubList 源码分析4 RandomAccessSubList 源码:AbstractList 作为 Lis

    它实现了 List 的一些位置相关操作(比如 get,set,add,remove),是第一个实现随机访问方法的集合类,但不支持添加和替换

    JavaEdge
  • Dubbo实战(一) - 入门

    随着互联网的发展,网站应用的规模不断扩大,常规的垂直应用架构已无法应对,分布式服务架构以及流动计算架构势在必行,亟需一个治理系统确保架构有条不紊的演进。

    JavaEdge
  • SpringMVC的@ResponseBody注解说明

    @ResponseBody 注解与 @RequestBody 注解类似。 @ResponseBody 注解可被应用于方法上,标志该方法的返回值将被直接写回到HT...

    JavaEdge
  • ArrayList 源码分析

    ArrayList 源码分析 1. 在阅读源码时做了大量的注释,并且做了一些测试分析源码内的执行流程,由于博客篇幅有限,并且代码阅读起来没有 IDE 方便,所...

    lwen
  • Java集合框架源码解析之ArrayList

    叶应是叶
  • 【JDK1.8】JDK1.8集合源码阅读——ArrayList

    joemsu
  • ArrayList内部原理解析Header源码分析Footer

    俞其荣
  • 【JDK1.8】JDK1.8集合源码阅读——ArrayList

    joemsu
  • ArrayList源码学习

    ArrayList是一种以数组实现的列表,而数组的优势在于有角标,因此查询的速度较快,是一种可以动态扩容的数组。我们着重了解添加、获取、替换、删除操作。

    路行的亚洲
  • 封装数组之改进为泛型数组

    前言:通过上一节我们对我们需要封装的数组,进行了基本的增删改查的封装,但只局限于int类型的操作,为了能提供多种类型数组的操作,我们可以将其进一步封装为泛型数组...

    wfaceboss

扫码关注云+社区

领取腾讯云代金券