JAVA容器-List接口容器详解
JAVA容器系列专题
【JAVA容器概论】
【JAVA容器-List接口容器详解】
【JAVA容器-迭代器Iterator详解】
【JAVA容器-Set接口容器详解】
【JAVA容器-Map接口容器详解】
【JAVA容器演进及应用(含对Disruptor的浅解)】
List接口容器关系图
List接口常用方法
增加：add(int index, E element)
删除：remove(int index) remove(Object o)
修改：set(int index, E element)
查看：get(int index)
public class TestList {
//这是main方法，程序的入口
public static void main(String[] args) {
List list = new ArrayList();
list.add(13);
list.add(17);
list.add(6);
list.add(-1);
list.add(2);
list.add("abc");
System.out.println(list);
list.add(3,66);
System.out.println(list);
list.set(3,77);
System.out.println(list);
//在集合中存入的是Integer类型数据的时候，调用remove方法调用的是：remove(int index)
list.remove(2);
System.out.println(list);
list.remove("abc");
System.out.println(list);
Object o = list.get(0);
System.out.println(o);
//List集合 遍历：
//方式1：普通for循环：
System.out.println("---------------------");
for(int i = 0;i<list.size();i++){
System.out.println(list.get(i));
}
//方式2：增强for循环：
System.out.println("---------------------");
for(Object obj:list){
System.out.println(obj);
}
//方式3：迭代器：
System.out.println("---------------------");
Iterator it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
ArrayList
前置知识
物理结构：紧密结构
逻辑结构：线性表（数组）
源码解读（JDK1.8）
public class ArrayList<E>{
// 底层就是一个数组，Object类型的数组
transient Object[] elementData;
// 记录数组中的有效数据
private int size;
// 底层数组默认大小
private static final int DEFAULT_CAPACITY = 10;
// 空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
private static final Object[] 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);
}
}
// 无参构造器，设置空数组
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 添加元素
public boolean add(E e) {
// 判断是否需要扩充底层数组
ensureCapacityInternal(size + 1);
// 既设置了元素数量值，又在底层数组末尾追加了新的元素
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;
}
// 判断是否需要扩充底层数组
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// 如果添加元素后的长度大于当前底层数组的长度，那就进行数组扩展
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
// 扩展底层数组
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
// 设置新数组长度是当前数组长度的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 将老数组copy到一个设置好长度的新数组并使底层数组指向新数组地址
elementData = Arrays.copyOf(elementData, newCapacity);
}
}
阅读ArrayList源码可知：
- ArrayList底层是数组。
- 数组每次扩展为原来的1.5倍。
- ArrayList底层数组默认长度为0。
JDK1.7初期版本的ArrayList的无参构造器会创建一个长度为10的底层数组，会消耗内存，其实，JDK1.7后期版本就进行优化了，而不是像网上说的JDK1.8才优化此处逻辑。
Vector
前置知识
物理结构：紧密结构
逻辑结构：线性表（数组）
源码解读（JDK1.8）
public class Vector<E>{
// 底层数组
protected Object[] elementData;
// 存放有效长度
protected int elementCount;
// 数组扩展因子 如果不设置，底层数组长度默认扩大为原先的2倍
protected int capacityIncrement;
public Vector(int initialCapacity, int capacityIncrement) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
this.capacityIncrement = capacityIncrement;
}
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
// 无参构造器 默认创建长度为10的底层数组
public Vector() {
this(10);
}
// 方法级的锁
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
// 扩展数组
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
// 根据capacityIncrement扩展因子进行长度扩展，默认扩展为原先数组长度的2倍
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
}
阅读Vector源码可知：
- Vector底层是数组。
- 如果设置扩展因子大小，数组每次扩展的长度为扩展因子capacityIncrement的大小；否则，数组每次扩展为原长度的2倍。
- Vector底层数组默认长度为10
- 元素操作时都会使用方法级的Synchonized锁，线程安全，但是效率低
LinkedList
前置知识
物理结构：跳转结构
逻辑结构：线性表（双向链表）
源码解读（JDK1.8）
public class LinkedList<E>{
// 记录集合中元素的数量
transient int size = 0;
// Node内部类
private static class Node<E> {
// 存储节点数据
E item;
// 存储下个节点信息
Node<E> next;
// 存储上个节点信息
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
// 存储头节点
transient Node<E> first;
// 存储尾节点
transient Node<E> last;
//添加元素操作：
public boolean add(E e) {
// 添加元素
linkLast(e);
return true;
}
void linkLast(E e) {
// 保存当前尾节点快照，新建一个没有后继节点的新节点，并将其设置为尾节点
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
// 如果尾节点快照为null，说明当前集合为null，那就把新节点设置为头节点
if (l == null)
first = newNode;
else
// 否则把新节点设置为尾节点快照的后继节点
l.next = newNode;
// 集合元素长度加1
size++;
modCount++;
}
//通过索引得到元素：
public E get(int index) {
return node(index).item;
}
Node<E> node(int index) {
// 如果这个索引在集合长度的前半段，那就从前往后遍历查询这个索引的元素
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
// 如果这个索引在集合长度的后半段，那就从后往前遍历查询这个索引的元素
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
}
阅读LinkedList源码可知：
- LinkedList底层是双向链表，链表中每个节点都有元素信息、前驱结点、后继结点。
- 新增元素时只需修改相关节点的前驱结点或后继结点的指向即可，效率极高。
- 查询元素时优化了查询逻辑，提高查询效率。
List接口下常用容器总结
- Vector线程安全，执行效率低，ArrayList和LinkedList线程不安全，执行效率高。
- Vector集合实现方法级Synchonized锁，锁粒度大，执行效率低，后面在并发情况中会被其他的并发容器代替，所以不建议使用Vector集合。
- Vector集合默认创建长度为10的底层数组，默认扩展为原始长度的2倍，比较耗费内存，所以不建议使用Vector集合。
- 如果存储数据较固定，查询频繁，那就使用ArrayList容器。
- 如果更新数据频繁，那就使用LinkedList容器。
298
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
