ArraysList底层源码

Posted Code_BinBin

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了ArraysList底层源码相关的知识,希望对你有一定的参考价值。

引言

ArrayList是我们写项目的时候经常用到的一个集合,日常使用的时候,除了ArrayList还有HashMap,LinkList这些我们都会用到,那我们是否应该去了解一下他们的底层呢

ArrayList和LinkList

一说到ArrayList和LinkList,我们知道前者查询很快,后者插入很快,因为一个的底层是数组,一个的底层是链表,数组查询快,删除慢,链表查询慢,删除快,但是我们运行一下,真的是这样的吗?

package ArrayList;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

public class Test01 
    public static void main(String[] args) 
        List list1=new ArrayList();
        List list2=new LinkedList();
        long start1=System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) 
            list1.add(i);
        
        long end1=System.currentTimeMillis();
        System.out.println("ArrayList插入的时间:"+(end1-start1));

        long start2=System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) 
            list2.add(i);
        
        long end2=System.currentTimeMillis();
        System.out.println("LinkList插入的时间:"+(end2-start2));


    


什么是标记接口

我们点进ArrayList里面看看源码

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

    private static final long serialVersionUID = 8683452581122892189L;

    /**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * Shared empty array instance used for empty instances.
     */
    private static final Object[] EMPTY_ELEMENTDATA = ;

    /**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = ;

我们可以看到,ArrayList继承了List, RandomAccess, Cloneable,java.io.Serializable四个接口,我们点进这四个接口看一下

List

public interface List<E> extends Collection<E> 
    // Query Operations

    /**
     * Returns the number of elements in this list.  If this list contains
     * more than <tt>Integer.MAX_VALUE</tt> elements, returns
     * <tt>Integer.MAX_VALUE</tt>.
     *
     * @return the number of elements in this list
     */
    int size();

    /**
     * Returns <tt>true</tt> if this list contains no elements.
     *
     * @return <tt>true</tt> if this list contains no elements
     */
    boolean isEmpty();

    /**

RandomAccess

public interface RandomAccess 


Cloneable

public interface Cloneable 

Serializable

public interface Serializable 

标记接口,我们可以理解成一个标签,比方说我们写博客的时候,要给某个博客赋予相应的标签,看到这篇博客有这个标签,那么我们就知道这篇博客是干什么的了,而且标签里面没有内容,所以标记接口里面也没有内容,只有名字,我们来看看这些标记接口分别代表了什么意思

  • RandomAccess:有了这个接口就可以随机访问,遍历的时候会使用for循环,如果没有则不可随机访问,遍历的时候使用迭代器。
  • Cloneable:有了这个就代表可以拷贝其中拷贝分为深拷贝和浅拷贝,这个会在下文介绍
  • Serializable:把对象存入网络传输,写磁盘

什么是深拷贝和浅拷贝

当我们使用了一个List,这个时候,我们需要复制一份这个List,但是如果是新建一个数组,然后用for循环把这些内容放进新的数组,这样未免太耗时间,那么这里就需要拷贝

package ArrayList.Test;

import java.util.ArrayList;
import java.util.List;

public class Test02 
    public static void main(String[] args) 
        long start=System.currentTimeMillis();
        ArrayList list=new ArrayList();
        for (int i = 0; i < 100000; i++) 
            list.add(i);
        
        ArrayList list1= (ArrayList) list.clone();
       

        long end=System.currentTimeMillis();
        System.out.println(end-start);

    


package ArrayList.Test;

import java.util.ArrayList;
import java.util.List;

public class Test02 
    public static void main(String[] args) 
        long start=System.currentTimeMillis();
        ArrayList list=new ArrayList();
        for (int i = 0; i < 100000; i++) 
            list.add(i);
        

        ArrayList list1=new ArrayList();
        list.forEach((index)->list1.add(list.get((Integer) index)));

        long end=System.currentTimeMillis();
        System.out.println(end-start);
       
    


浅拷贝

首先我们新建一个student类,继承cloneable接口,重写方法,注意,重写后方法修饰是protected,我们把它修改成public

package ArrayList.entity;

public class Student implements Cloneable
    int id;
    String name;
    int age;

    public int getId() 
        return id;
    

    public void setId(int id) 
        this.id = id;
    

    public String getName() 
        return name;
    

    public void setName(String name) 
        this.name = name;
    

    public int getAge() 
        return age;
    

    public void setAge(int age) 
        this.age = age;
    

    @Override
    public Object clone() throws CloneNotSupportedException 
        return super.clone();
    

    public Student() 
    

    public Student(int id, String name, int age) 
        this.id = id;
        this.name = name;
        this.age = age;
    
    



我们来执行以下

package ArrayList.Test;

import ArrayList.entity.Student;

public class Test03 
    public static void main(String[] args) throws CloneNotSupportedException 
        Student s1=new Student(1,"lsl",20);
        s1.clone();
        Student s2=(Student) s1.clone();
        System.out.println(s2.getName());
    



可以看到我们直接拷贝到了第一个new出来的对象,所以说浅拷贝是直接使用Object中的clone方法,拷贝的对象是非独立的

深拷贝

我们新建一个Teacher类,操作和上文一样

package ArrayList.entity;

public class Teacher implements Cloneable 
    int id;
    String name;
    int age;
    Student student;
    public Teacher() 
    

    public Teacher(int id, String name, int age, Student student) 
        this.id = id;
        this.name = name;
        this.age = age;
        this.student = student;
    

    public int getId() 
        return id;
    
    public void setId(int id) 
        this.id = id;
    
    public String getName() 
        return name;
    
    public void setName(String name) 
        this.name = name;
    
    public int getAge() 
        return age;
    
    public void setAge(int age) 
        this.age = age;
    
    public Student getStudent() 
        return student;
    
    public void setStudent(Student student) 
        this.student = student;
    

    @Override
    public Object clone() throws CloneNotSupportedException 
        return super.clone();
    


写一个测试类

package ArrayList.Test;

import ArrayList.entity.Student;
import ArrayList.entity.Teacher;

public class Test04 
    public static void main(String[] args) throws CloneNotSupportedException 
        Teacher u1=new Teacher(1,"小明",20,new Student());
        u1.getStudent().setName("lsl");
        u1.setAge(25);
        Teacher u2= (Teacher) u1.clone();
        u2.getStudent().setName("cy");
        u2.setAge(18);
        System.out.println("u1的student的name:"+u1.getStudent().getName());
        System.out.println("u2的student的name:"+u2.getStudent().getName());
        System.out.println("u1的age:"+u1.getAge());
        System.out.println("u1的age:"+u2.getAge());

    


运行结果


我们发现,当u2的对象变量变化时,u1也跟着变了,但是u2的int变量变化时,u1没有变化,这是为什么呢?这里涉及到了java的传值方式,一个是值的传递,一个是引用的传递,我们画一张图分析一下

拷贝发生在栈区,当我们设一个int的局部变量时,int在栈区复制一份就相当于是直接定义了另一个数据,而对象是的画是new了一个对象,但是指向的地址还是原来的地方,String类型比较特殊,String的字符地址存在堆的常量池里面,当拷贝的时候,就会在常量池多一个地址出来,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);
        
    

ArrayList底层源码解析

ArraryList的属性

//默认容量
 private static final int DEFAULT_CAPACITY = 10;
 //空数组
 private static final Object[] EMPTY_ELEMENTDATA = ;
 //空数组
 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = ;
 //集合的元素
 transient Object[] elementData; 
 //大小
 private int size;
//数组的最大容量
 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

DEFAULTCAPACITY_EMPTY_ELEMENTDATA是一个空数组,被final和static修饰了,那么这个有什么用呢?我们先看一下ArrayList的一个构造方法,在看图片分析

public ArrayList() 
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    


原来当我们new了若干个ArrayList,但是没有赋值的时候,两个ArrayList的空数组全部指向DEFAULTCAPACITY_EMPTY_ELEMENTDATA,这样就可以节省很多空间了

当我们是直接new 一个ArrayList并赋值的时候,便会走另一个构造方法

 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类,然后转化成数组,获取数组的大小,如果size为0那么直接返回之前的EMPTY_ELEMENTDATA,size不等于0的话判断是否为AraayList,如果不是,就直接拷贝,这里我们发现有两个为空数组的全局变量,那么为什么需要两个呢?

我们来看看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);
        
    

根据上文我们知道,ArrayList的初始化容量是10,但是,我们也可以自己设置初始化容量,设置0,10,100,1000,10000,1000000…都可以,当我们自己设置了初始化容量的时候,那么就会走这个构造方法,当初始化容量的数值大于0,那么elementData 就等于一个新的数组,否则就等于EMPTY_ELEMENTDATA

上面的问题还没有解决,我们再来看一下ArrayList的add方法

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

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

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

通过这几步,就我们可以知道如果elementData 等于DEFAULTCAPACITY_EMPTY_ELEMENTDATA,那么返回的就是初始胡容量,否则,返回的是自己设定的容量

现在,我们来看看扩容

 private void ensureExplicitCapacity(int minCapacity) 
        modCount++;

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

 private void grow(int minCapacity) 
        // overflow-con

以上是关于ArraysList底层源码的主要内容,如果未能解决你的问题,请参考以下文章

ArraysList底层源码

HashMap底层源码解析下(超详细图解)

集合类不安全操作

深度挖掘RocketMQ底层源码「底层系列」深度挖掘RocketMQ底层导致消息丢失透析(Broker Busy和ToManyRequest)

#yyds干货盘点# Collection - ArrayList 源码解析

深度挖掘RocketMQ底层源码「底层源码挖掘系列」透彻剖析贯穿RocketMQ的消费者端的运行调度的流程(Pull模式)