在java中ArrayList集合底层的扩容原理

第一章 前言概述

第01节 概述

底层说明

arraylist是list的实现类，它的底层是用object数组存储，线程不安全

后期应用

适合用于频繁的查询工作，因为底层是数组，可以快速通过数组下标进行查找

第02节 区别

区别方向	arraylist集合	linkedlist集合
线程安全	不安全	不安全
底层原理	object类型数组	双向链表
随机访问	支持（实现 randomaccess接口）	不支持
内存占用	arraylist 浪费空间， 底层是数组，末尾预留一部分容量空间	linkedlist占用空间比arraylist多，存在头尾地址值占用空间

小结

arraylist 集合的特点：

1. 线程不安全

2. 底层数据结构是数组（查询快，增删慢，支持快速随机访问）

3. 内存占用会存在部分浪费，末尾会预留一部分容量空间

第二章 核心代码

第01节 成员变量

代码

public class arraylist<e> extends abstractlist<e> implements list<e>, randomaccess, cloneable, java.io.serializable{ 

	/**
	 * 默认初始容量大小, 默认初始化容量为10
	 */
	private static final int default_capacity = 10;

	/**
	 * 空数组。当集合内容置空的时候，底层使用空数组标记
	 */
	private static final object[] empty_elementdata = {};

	/**
	* 用于无参数构造方法，创建对象的时候，使用这个数组定义。
	* 相比上面的数组 empty_elementdata 可以进行区分，知道在添加元素的过程当中，容量增加多少
	*/
	private static final object[] defaultcapacity_empty_elementdata = {};

	/**
	 * 保存arraylist数据的数组，这个数组会不断的改变，前面没有被 final 修饰表示地址值会发生的变化
	 */
	transient object[] elementdata; // non-private to simplify nested class access

	/**
	 * arraylist 所包含的元素个数，也就是在 arraylist 集合底层，通过 size()方法，获取到的元素个数
	 */
	private int size; 
}

补充

1. arraylist 集合底层存在6个成员变量
	还有一个 private static final long serialversionuid = 8683452581122892189l;  
	序列化使用, 目前针对于当前的操作过程当中, 暂时不会使用得到。

2. arraylist 集合当中核心的两个成员变量
	a. 底层维护数组  		transient object[] elementdata;
	b. 存储的元素个数		private int size; 

第02节 构造方法

代码

public class arraylist<e> extends abstractlist<e> implements list<e>, randomaccess, cloneable, java.io.serializable{ 

    /**
     * 构造一个初始长度为0的空数组。
     */
    public arraylist() {
        this.elementdata = defaultcapacity_empty_elementdata;
    }

    /**
     * 在构造方法当中，传递一个参数集合c，将集合 c 转换成为新的列表
	 * elementdata 当中的数据，就是新集合存放的数据
     * c.toarray 就是将原始集合的数据取出
	 * 如果取出的集合长度不为零的情况下，则复制 参数集合c 到 elementdata 当中
	 * 如果取出的集合长度为零的情况下，则赋值为空数组  empty_elementdata 
     */
    public arraylist(collection<? extends e> c) {
        elementdata = c.toarray();
        if ((size = elementdata.length) != 0) { 
            if (elementdata.getclass() != object[].class)
                elementdata = arrays.copyof(elementdata, size, object[].class);
        } else { 
            this.elementdata = empty_elementdata;
        }
    }
	
	 /**
     * 指定参数的长度大小
	 * 如果初始化的长度大于0，则返回新的数组
	 * 如果初始化的长度等于0，则返回默认的空数组作为集合 this.elementdata = empty_elementdata;
	 * 如果初始化的长度小于0，则出现非法参数异常
     */
    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);
        }
    }
}

补充（一） 无参构造创建对象

补充（二）带参构造创建对象，带有int类型参数

补充（三）带参构造创建对象，带有 集合类型参数

第三章 扩容操作

第01节 扩容代码

核心方法介绍

来自于 arraylist 集合当中的方法：
	1. public boolean add(e e){ ... }
	2. private void add(e e, object[] elementdata, int s){ .... }
	3. private object[] grow()
	4. private object[] grow(int mincapacity)

来自于其他类当中的功能
	1. arrays.copyof(elementdata, newcapacity);  表示来自于 数组工具类 arrays 当中的 copyof() 底层使用的是 system.arraycopy() 方法
	2. math.max(default_capacity, mincapacity)   表示来自于 数学工具类 math 当中的 max() 方法，比较两个数据最大值，取较大者，返回

核心代码解释

public class arraylist<e> extends abstractlist<e> implements list<e>, randomaccess, cloneable, java.io.serializable{ 

    /**
     * 将指定的元素添加到此集合的末尾位置
     *
     * modcount 是来自于父类的 abstractlist 当中的成员变量
     * add(e, elementdata, size) 调用自己下面的重载方法
	 * return true  表示当前的方法，一定可以添加成功，因为list系列的集合添加数据都是允许成功的 true 如果是set此方法返回false
     */
    public boolean add(e e) {
        modcount++;
        add(e, elementdata, size);
        return true;
    }
	
	
	/**
     * 这个方法是私有方法，仅仅自己可以使用。不允许外界访问得到。便于上面的 add() 方法重载调用的
	 * 参数1: 表示需要添加的元素数据 e e
	 * 参数2: 表示成员变量当中, 需要维护管理的底层数组  object[] elementdata
     * 参数3: 表示成员变量当中, size 容器 elementdata 当中存放的真实有效的数据个数
	 * 方法里面的逻辑: 当size已经等于了内部容器 elementdata 的最大长度，则准备进行扩容的操作，扩容使用 grow() 方法
	 * 无论上面是否进行了扩容的操作，这里都需要将添加的元素赋值到数组当中，也就是 elementdata[s] = e;
	 * 并且将当前成员变量的 size 在原始数据的基础上面，增加1，表示添加了新的元素之后，长度变化了，增加了1
     */
    private void add(e e, object[] elementdata, int s) {
        if (s == elementdata.length)
            elementdata = grow();
        elementdata[s] = e;
        size = s + 1;
    }
	
	
	/**
     * 这个方法是私有方法，仅仅自己可以使用。不允许外界访问得到。便于上面的 add() 方法调用的
	 * 方法的内部调用了 arraylist 当中自己重载的方法 grow(size + 1) 同时传入了参数。
	 * 这里参数的含义，表示的是 集合当中总长度 size + 1 表示在原始size基础上增加1 
	 * 方法的返回值是一个新的数组，也就是扩容之后的数组
     */
	private object[] grow() {
        return grow(size + 1);
    }


    /**
     * 这个方法是私有方法，仅仅自己可以使用。不允许外界访问得到。便于上面的 grow() 方法调用的
	 * 这里的参数 mincapacity ，就是上面传入的参数 size + 1，也就是说最小容量 mincapacity = size + 1
	 * 方法体当中的执行逻辑:
	 * 		1. 获取到了底层维护数组的长度 int oldcapacity = elementdata.length; 这里就是旧容量 oldcapacity
	 *      2. 判断旧容量 oldcapacity 是否小于0，也就是 else 的逻辑，
	 *				如果满足 if 当中的逻辑， 则表示 旧数组当中存在数据，并且 旧数组并不是 默认容量的空数组地址值
	 *					说明: 扩容过的就不会是之前默认 defaultcapacity_empty_elementdata 的地址值
	 *					在这种情况下，就会得到 1.5被的数组长度整数，传递给 arrays.copyof()方法进行扩容，得到新数组返回
	 * 				如果满足 else 当中的逻辑，则返回 default_capacity 和 mincapacity 较大值。
	 * 					说明: default_capacity 值表示的是成员变量，默认为 10   
	 *					说明: mincapacity 在低于10的时候，表示的会是扩容添加的长度1,2,3..9.10.11..
     */
    private object[] grow(int mincapacity) {
        int oldcapacity = elementdata.length;
        if (oldcapacity > 0 || elementdata != defaultcapacity_empty_elementdata) {
            int newcapacity = arrayssupport.newlength(oldcapacity,
                    mincapacity - oldcapacity, /* minimum growth */
                    oldcapacity >> 1           /* preferred growth */);
            return elementdata = arrays.copyof(elementdata, newcapacity);
        } else {
            return elementdata = new object[math.max(default_capacity, mincapacity)];
        }
    }
}

到此这篇关于在java中arraylist集合底层的扩容原理的文章就介绍到这了,更多相关arraylist集合扩容原理内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！