Java集合框架-list

目录

 

集合框架

1、为什么使用集合框架？

2、集合框架包含的内容

ArrayList

1、ArrayList概述

2、ArrayList的数据结构

3、ArrayList源码分析

1、继承结构和层次关系

2、类中的属性

3、构造方法

4、核心方法 add

5、核心方法-remove

6、其他方法

4、总结

LinkedList

1、引入

2、LinkedList源码分析

1、LinkedList概述

​

2、LinkedList的数据结构

3、LinkedList的特性

4、继承结构以及层次关系

5、类的属性

6、构造方法

7、内部类（Node）

8、核心方法

9、LinkedList的迭代器

10、总结

---

集合框架

1、为什么使用集合框架？

如果并不知道程序运行时会需要多少对象，或者需要更复杂的方式存储对象，那我们就可以使用Java的集合框架！

2、集合框架包含的内容

Java集合框架提供了一套性能优良，使用方便的接口和类，他们位于java.util包中。

Collections 类提供了对集合进行排序，遍历等多种算法实现！

• Collection 接口存储一组不唯一，无序的对象
• List 接口存储一组不唯一，有序的对象。
• Set 接口存储一组唯一，无序的对象
• Map 接口存储一组键值对象，提供key到value的映射
• ArrayList实现了长度可变的数组，在内存中分配连续的空间。遍历元素和随机访问元素的效率比较高
• 
• LinkedList采用链表存储方式。插入、删除元素时效率比较高
• 
• HashSet:采用哈希算法实现的Set

ArrayList

1、ArrayList概述

1. ArrayList是可以动态增长和缩减的索引序列，它是基于数组实现的List类。
2. 该类封装了一个动态再分配的Object[]数组，每一个类对象都有一个capacity【容量】属性，表示它们所封装的Object[]数组的长度，当向ArrayList中添加元素时，该属性值会自动增加。如果想ArrayList中添加大量元素，可使用ensureCapacity方法一次性增加capacity，可以减少增加重分配的次数提高性能。
3. ArrayList的用法和Vector向类似，但是Vector是一个较老的集合，具有很多缺点，不建议使用。

ArrayList和Collection的关系：

2、ArrayList的数据结构

底层的数据结构就是数组，数组元素类型为Object类型，即可以存放所有类型数据。

我们对ArrayList类的实例的所有的操作底层都是基于数组的。

3、ArrayList源码分析

1、继承结构和层次关系

IDEA快捷键：Ctrl+H

ArrayList实现的接口：

• List接口
• RandomAccess接口
• Cloneable接口
• Serializable接口

2、类中的属性

public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
// 版本号
private static final long serialVersionUID = 8683452581122892189L;
// 缺省容量
private static final int DEFAULT_CAPACITY = 10;
// 空对象数组
private static final Object[] EMPTY_ELEMENTDATA = {};
// 缺省空对象数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 元素数组
transient Object[] elementData;
// 实际元素大小，默认为0
private int size;
// 最大数组容量
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
}

3、构造方法

通过IDEA查看源码，看到ArrayList有三个构造方法：

总结：ArrayList的构造方法就做一件事情，就是初始化一下储存数据的容器，其实本质上就是一个数组，在其中就叫elementData。

4、核心方法 add

• boolean add(E)
•  void add(int，E)

当我们调用add方法时，实际上的函数调用如下：

5、核心方法-remove

• fastRemove(int)方法是private的，是提供给remove(Object)这个方法用的。
• remove(int)：通过删除指定位置上的元素
• remove(Object)：这个方法可以看出来，arrayList是可以存放null值得
• clear()：将elementData中每个元素都赋值为null，等待垃圾回收将这个给回收掉，所以叫clear
• removeAll(collection c)
• batchRemove(xx,xx)：用于两个方法，一个removeAll()：它只清楚指定集合中的元素，retainAll()用来测试两个集合是否有交集。

总结：remove函数，用户移除指定下标的元素，此时会把指定下标到数组末尾的元素向前移动一个单位，并且会把数组最后一个元素设置为null，这样是为了方便之后将整个数组不被使用时，会被GC，可
以作为小的技巧使用。

6、其他方法

set()方法：设定指定下标索引的元素值

public E set(int index, E element) {
// 检验索引是否合法
rangeCheck(index);
// 旧值
E oldValue = elementData(index);
// 赋新值
elementData[index] = element;
// 返回旧值
return oldValue;
}

indexOf()方法：从头开始查找与指定元素相等的元素

// 从首开始查找数组里面是否存在指定元素
public int indexOf(Object o) {
if (o == null) { // 查找的元素为空
for (int i = 0; i < size; i++) // 遍历数组，找到第一个为空的元素，返回下标
if (elementData[i]==null)
return i;
} else { // 查找的元素不为空
for (int i = 0; i < size; i++) // 遍历数组，找到第一个和指定元素相等的元
素，返回下标
if (o.equals(elementData[i]))
return i;
}
// 没有找到，返回空
return -1;
}

get()方法：

public E get(int index) {
// 检验索引是否合法
rangeCheck(index);
return elementData(index);
}

4、总结

1. arrayList可以存放null。
2. arrayList本质上就是一个elementData数组。
3. arrayList区别于数组的地方在于能够自动扩展大小，其中关键的方法就是gorw()方法。
4. arrayList中removeAll(collection c)和clear()的区别就是removeAll可以删除批量指定的元素，而clear是全是删除集合中的元素。
5. arrayList由于本质是数组，所以它在数据的查询方面会很快，而在插入删除这些方面，性能下降很多，有移动很多数据才能达到应有的效果
6. arrayList实现了RandomAccess，所以在遍历它的时候推荐使用for循环。

LinkedList

1、引入

插入，删除操作频繁时，可使用LinkedList来提高效率。LinkedList提供对头部和尾部元素进行添加和删除操作的方法！

LinkedList的特殊方法

2、LinkedList源码分析

1、LinkedList概述

1. LinkedList是一种可以在任何位置进行高效地插入和移除操作的有序序列，它是基于双向链表实现的。
2. LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
3. LinkedList 实现 List 接口，能对它进行队列操作。
4. LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。
5. LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。
6. LinkedList 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。
7. LinkedList 是非同步的。

2、LinkedList的数据结构

单向链表：

element：用来存放元素
next：用来指向下一个节点元素通过每个结点的指针指向下一个结点从而链接起来的结构，最后一个节点的next指向null。

单向循环链表：
element、next 跟前面一样，在单向链表的最后一个节点的next会指向头节点，而不是指向null，这样存成一个环

双向链表：
element：存放元素
pre：用来指向前一个元素
next：指向后一个元素
双向链表是包含两个指针的，pre指向前一个节点，next指向后一个节点，但是第一个节点head的pre指向null，最后一个节点的tail指向null。

双向循环链表：
element、pre、next 跟前面的一样
第一个节点的pre指向最后一个节点，最后一个节点的next指向第一个节点，也形成一个“环”。

LinkedList底层使用的双向链表结构，有一个头结点和一个尾结点，双向链表意味着我们可以从头开始正向遍历，或者是从尾开始逆向遍历，并且可以针对头部和尾部进行相应的操作。

3、LinkedList的特性

4、继承结构以及层次关系

• 异步，也就是非线程安全
• 双向链表。由于实现了list和Deque接口，能够当作队列来使用。
• 链表：查询效率不高，但是插入和删除这种操作性能好。
• 是顺序存取结构

• 减少实现顺序存取（例如LinkedList）这种类的工作，通俗的讲就是方便，抽象出类似LinkedList这种类的一些共同的方法
• 以后如果自己想实现顺序存取这种特性的类(就是链表形式)，那么就继承这个AbstractSequentialList抽象类，如果想像数组那样的随机存取的类，那么就去实现AbstracList抽象类。
• 这样的分层，就很符合我们抽象的概念，越在高处的类，就越抽象，往在底层的类，就越有自己独特的个性。自己要慢慢领会这种思想。
• LinkedList的类继承结构很有意思，我们着重要看是Deque接口，Deque接口表示是一个双端队列，那么也意味着LinkedList是双端队列的一种实现，基于双端队列的操作在LinkedList中全部有效。

接口实现分析：

public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
}

• List接口：列表，add、set、等一些对列表进行操作的方法
• Deque接口：有队列的各种特性，
• Cloneable接口：能够复制，使用那个copy方法。
• Serializable接口：能够序列化。
• 注意到没有RandomAccess：那么就推荐使用iterator，在其中就有一个foreach，增强的for循环，其中原理也就是iterator

5、类的属性

public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
// 实际元素个数
transient int size = 0;
// 头结点
transient Node<E> first;
// 尾结点
transient Node<E> last;
}

LinkedList的属性非常简单，一个头结点、一个尾结点、一个表示链表中实际元素个数的变量。注意，头结点、尾结点都有transient关键字修饰，这也意味着在序列化时该域是不会序列化的。

6、构造方法

空参构造函数

public LinkedList() {
}

有参构造函数

//将集合c中的各个元素构建成LinkedList链表。
public LinkedList(Collection<? extends E> c) {
// 调用无参构造函数
this();
// 添加集合中所有的元素
addAll(c);
}

说明：会调用无参构造函数，并且会把集合中所有的元素添加到LinkedList中。

7、内部类（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;
}
}

说明：内部类Node就是实际的结点，用于存放实际元素的地方。

8、核心方法

1、add()方法

public boolean add(E e) {
// 添加到末尾
linkLast(e);
return true;
}

add函数用于向LinkedList中添加一个元素，并且添加到链表尾部。具体添加到尾部的逻辑是由linkLast函数完成的。

2、addAll方法

为什么要先转化为数组再进行遍历，而不是直接遍历集合

1. 如果直接遍历集合的话，那么在遍历过程中需要插入元素，在堆上分配内存空间，修改指针域，这个过程中就会一直占用着这个集合，考虑正确同步的话，其他线程只能一直等待。
2. 如果转化为数组，只需要遍历集合，而遍历集合过程中不需要额外的操作，所以占用的时间相对是较短的，这样就利于其他线程尽快的使用这个集合。说白了，就是有利于提高多线程访问该集合的效率，尽可能短时间的阻塞。

3、remove(Object o)

4、get(index)

5、indexOf(Object o)

//就是通过实体元素来查找到该元素在链表中的位置。跟remove中的代码类似，只是返回
类型不一样。
public int indexOf(Object o) {
int index = 0;
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null)
return index;
index++;
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item))
return index;
index++;
}
}
return -1;
}

9、LinkedList的迭代器

在LinkedList中除了有一个Node的内部类外，应该还能看到另外两个内部类，那就是ListItr，还有一个是DescendingIterator。

看一下ListItr中的方法，可以发现，在迭代的过程中，还能移除、修改、添加值得操作。

DescendingIterator内部类：

private class DescendingIterator implements Iterator<E> {
//看一下这个类，还是调用的ListItr，作用是封装一下Itr中几个方法，让使用者以正常的思维
去写代码，例如，在从后往前遍历的时候，也是跟从前往后遍历一样，使用next等操作，而不用使用特
殊的previous。
private final ListItr itr = new ListItr(size());
public boolean hasNext() {
return itr.hasPrevious();
}
public E next() {
return itr.previous();
}
public void remove() {
itr.remove();
}
}

10、总结

1. linkedList本质上是一个双向链表，通过一个Node内部类实现的这种链表结构。

2. 能存储null值

3. 跟arrayList相比较，就真正的知道了，LinkedList在删除和增加等操作上性能好，而ArrayList在查询的性能上好

4. 从源码中看，它不存在容量不足的情况

5. linkedList不光能够向前迭代，还能像后迭代，并且在迭代的过程中，可以修改值、添加值、还能移除值。

6. linkedList不光能当链表，还能当队列使用，这个就是因为实现了Deque接口。