引言
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-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
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);
}
这里我们可以知道，根据calculateCapacity返回数组的容量，然后调用ensureExplicitCapacity来判断是否需要扩容，modCount是集成自AbstractList的一个变量是一个操作数，扩容的本质就是生成一个新的数组赋值给elementData ，根据grow方法，扩容是扩大到之前的1.5倍，这里用的是位运算，因为算的很快，扩容的范围也有限制，不过挺大的有几个亿，一般来说我们不会有这么多。
ArrayList踩坑
当我们有一个int数组，我们觉得他没有什么api，不好用，我们想把他变成ArrayList，然后我们转化成功后，想看一下他的长度是多少，如下，我们觉得应该是5，但是。。。
package ArrayList.Test;
import java.util.Arrays;
import java.util.List;
public class Test05 {
public static void main(String[] args) {
int a[]={1,2,3,4,5};
List list= Arrays.asList(a);
System.out.println(list.size());
}
}
让我们看一下源码，然后debug一下，发现传过去的数数组变成了二维数组
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}
我们换一个数组，用String来做数组
package ArrayList.Test;
import java.util.Arrays;
import java.util.List;
public class Test05 {
public static void main(String[] args) {
String a[]={"1","2","3","4","5"};
List list= Arrays.asList(a);
System.out.println(list.size());
}
}
然后我们在看一下源码，发现这里传过去的a没有变成二维数组
原来，是因为T…a可变参数，当我传递基本类型的时候，就会把整个类型放到数组里面再复制，如果是引用类型的话，那就不会出现这种情况，这是因为他的自动拆装箱功能，如果那基本类型用包装类代替，那么就不会有这种问题。
结尾
关于ArrayList就先讲这么多，只要我们了解了里面的数据结构，掌握起来并不难，但是要自己手写一个出来估计有点困难，过段时间困难会出一个手写ArrayList的博客，麻烦各位观众老爷三连一波，谢谢
1673
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
