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底层源码的主要内容,如果未能解决你的问题,请参考以下文章
深度挖掘RocketMQ底层源码「底层系列」深度挖掘RocketMQ底层导致消息丢失透析(Broker Busy和ToManyRequest)
#yyds干货盘点# Collection - ArrayList 源码解析
深度挖掘RocketMQ底层源码「底层源码挖掘系列」透彻剖析贯穿RocketMQ的消费者端的运行调度的流程(Pull模式)