List接口的实现类

常见的List接口的实现类

ArrayList:数组实现,查询快,增删慢,轻量级;(线程不安全)
LinkedList:双向链表实现,增删快,查询慢 (线程不安全)
Vector:数组实现,重量级 (线程安全、使用少)

ArrayList实现类

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

内部实现

transient Object[] elementData; 用于存储数据,体现ArrayList采用的是数组的方式提供实现

构造器

//new ArrayList(1000);
public ArrayList(int initialCapacity) { //参数是初始化容积
if (initialCapacity > 0) { 如果容积初始值大于0则创建对应的对象
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) { 如果容积值位0则创建一个空数组
this.elementData = EMPTY_ELEMENTDATA;
} else { 如果小于0则抛出一个运行时异常
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
//new ArrayList();
public ArrayList() { 没有初始化参数值,则自动创建一个0个长的空数组
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

add方法的实现

//向存储数据的elementData添加新元素
public boolean add(E e) {
ensureCapacityInternal(size + 1); //确保内部容量,处理数组elementData的长度,确保
可以存放数据,如果当前数组长度不足,则需要增加数组长度。参数的含义是满足条件的最小容积
elementData[size++] = e;
return true; //如果添加过程中不出异常,则返回一定是true
}

add方法用于向集合中添加元素,如果ArrayList中真正存放数据的数组长度不足,则新建一个数组,新
数组的长度为原始长度1.5倍,并拷贝原始数组中的数据到新数组中,最后再追加新元素。

Vector

类定义
属于老版本提供的,从1.0,而ArrayList比较新,从1.2。属于线程安全的类,大部分方法上都有synchronized,一般用于要求线程安全的属性定义

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

数据存储

protected Object[] elementData; 采用也是数组的方式存储数据

构造器方法

public Vector() {
 this(10); //表示调用当前类的其它构造器,初始化容积为10,增长的步长值为0
}
public Vector(int initialCapacity) {
 this(initialCapacity, 0);
}
public Vector(int initialCapacity, int capacityIncrement) { //参数1是初始化容积,参数2是容
积增长的步长值
 super();
 if (initialCapacity < 0)
 throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
 this.elementData = new Object[initialCapacity]//按照初始化容积值构建对应的数组
 this.capacityIncrement = capacityIncrement;
}

add新增元素的方法实现

public synchronized boolean add(E e) {//线程安全的方法
modCount++; //修改次数+1
 ensureCapacityHelper(elementCount + 1); //处理容积
 elementData[elementCount++] = e; //在数组中存储元素
 return true;
}
private void ensureCapacityHelper(int minCapacity) {
 // overflow-conscious code
 if (minCapacity - elementData.length > 0) //需要储存的数据超出数组可以存放的数据格
式,则需要进行增长
 grow(minCapacity);
 }
private void grow(int minCapacity) {
 int oldCapacity = elementData.length; //当前数组的长度,也就是可以存放的元素个数
 int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement :
oldCapacity); //新长度为原始长度的2倍或者原始长度+步长值
 if (newCapacity - minCapacity < 0) //如果新长度不满足最小长度要求,则新长度为最小要
求的长度
 newCapacity = minCapacity;
 if (newCapacity - MAX_ARRAY_SIZE > 0) //如果新长度大于最大数组长度进行长度处理
 newCapacity = hugeCapacity(minCapacity);
 elementData = Arrays.copyOf(elementData, newCapacity); //将原始数组中的数据拷贝到新
数组中,并替换原始数组
 }
private static int hugeCapacity(int minCapacity) { //和ArrayList处理一致
 if (minCapacity < 0) //OOM 内存溢出
 throw new OutOfMemoryError();
 return (minCapacity > MAX_ARRAY_SIZE) ?
 Integer.MAX_VALUE :
 MAX_ARRAY_SIZE;
 }

LinkedList

类定义

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>,
Cloneable, java.io.Serializable
//Deque是队列接口,提供一个双端队列的访问方法实现

底层实现为双向链表

private static class Node<E> { //节点定义
 E item; //具体存储的数据
 Node<E> next; //向后的指针
 Node<E> prev; //向前的指针
}

LinkedList类中的数据存储

transient Node<E> first; //头指针,指向链表的第一个元素
transient Node<E> last; //尾指针,指向链表的最后一个元素

List总结

在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值