List接口

List接口

概述

有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

Collection将集合划分为两大类：**

1. List集合
2. Set集合

List接口的特点

1. 有序【存储有序】

2. 可重复

3. 可以存储 null值

4. 部分子集合线程安全，部分不安全 例如 ArrayList 和 Vector

5. 有索引，针对每个元素能够方便地查询和修改

6. 判断元素是否重复依赖于equals方法

   ​ a. 如果元素是系统类，不需要重写equals方法

   ​ b. 如果是自定义类,就需要我们按需求重写 equals方法

List接口的常用方法

增加

void add(int index, E element) 在指定 index 索引处理插入元素 element
boolean addAll(int index, Collection<? extends E> c) 在指定 index 索引处理插入集合元素 c

删除

E remove(int index) 删除指定索引 index 处的元素

修改

E set(int index, E element) 修改指定索引 index 处的元素为 element			

遍历

E get(int index) + int size() for循环遍历集合中的每一个元素
ListIterator<E> listIterator() 通过列表迭代器遍历集合中的每一个元素
ListIterator<E> listIterator(int index) 通过列表迭代器从指定索引处开始正向或者逆向遍历集合中的元素

获取

E get(int index) 获取指定索引处的元素
int indexOf(Object o) 从左往右查找，获取指定元素在集合中的索引,如果元素不存在返回 -1
int lastIndexOf(Object o) 从右往左查找，获取指定元素在集合中的索引,如果元素不存在返回 -1
List<E> subList(int fromIndex, int toIndex) 截取从 fromIndex 开始到 toIndex-1 处的元素

List接口的遍历方式

1. toArray

2. Iterator

3. foreach

4. 普通for

5. ListIterator

List接口去除重复元素

​ 方式一：创建一个新的集合去除重复元素再使用地址传递

​ 方式二：在原集合的基础上使用选择排序思想去除重复元素

List<String> list = new ArrayList<String>();
		list.add("张三");
		list.add("李四");
		list.add("李四");
		list.add("李四");
		list.add("王五");

for (int i = 0; i < list.size(); i++) {
    for (int j = i + 1; j < list.size(); j++) {
        if (list.get(i).equals(list.get(j))) {
            list.remove(j);
            j--;
        }
    }
}

并发修改异常的处理

异常名称：并发修改异常 java.util.ConcurrentModificationException

产生原因：在使用迭代器迭代的同时使用原集合对元素做了修改

解决办法：

1. 使用 toArray 方法

2. 使用 普通 for 遍历

3. 使用 ListIterator 遍历集合并且使用 列表迭代器修改元素

ArrayList

概述

List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现
List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector类，除了此类是不同步的。）

特点

1. 底层数据结构是数组
2. 增加和删除的效率低，查询和修改的效率高
3. 能够存储 null 值
4. 线程不安全，效率高 可以通过 Collections.synchronizedList();变安全
5. 有索引，能够方便检索
6. 元素可重复，我们自己可以通过 选择排序去重复
7. 不可以排序，但是可以通过 Collections.sort();方法排序

注：ArrayList中常用的方法全部来自于 父类 Collection,List,Object.这里不再做详细叙述。

Vector

概述

Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。

特点

1. 底层数据结构是数组
2. 有索引，能够方便检索
3. 增加和删除的效率低，查询和修改的效率高
4. 线程安全，效率低
5. 能够存储 null 值
6. 元素可重复【我们自己可以通过选择排序思想去除重复元素】
7. 不可以排序，但是可以通过 Collections.sort();方法排序

常用方法

增加

public synchronized void addElement(E obj) 添加元素 obj 到集合中
public synchronized void insertElementAt(E obj, int index) 在指定索引 index 处插入元素 obj

删除

public synchronized void removeElementAt(int index) 移除指定索引 index 处的元素
public synchronized void removeAllElements() 移除所有元素

修改

public synchronized void setElementAt(E obj, int index) 修改指定索引 index 的元素为 obj

遍历

public synchronized E elementAt(int index) + size() for循环遍历集合中的所有元素
public synchronized Enumeration<E> elements() 使用 Enumeration 迭代器遍历集合中的元素

获取

public synchronized E firstElement() 获取集合中的第一个元素
public synchronized E lastElement() 获取集合中的最后一个元素
public synchronized E elementAt(int index) 获取指定索引 index 的元素

相关面试题

ArrayList和Vector的区别？
1）  Vector的方法都是同步的(Synchronized),是线程安全的(thread-safe)，而ArrayList的方法不是，由于线程的同步必然要影响性能，因此,ArrayList的性能比Vector好。 
2） 当Vector或ArrayList中的元素超过它的初始大小时,Vector会将它的容量翻倍,而ArrayList只增加50%的大小，这样,ArrayList就有利于节约内存空间。

Stack

概述

Stack 类表示后进先出（LIFO）的对象堆栈。它通过五个操作对类 Vector 进行了扩展 ，允许将向量视为堆栈。它提供了通常的 push 和 pop 操作，以及取堆栈顶点的 peek 方法、测试堆栈是否为空的 empty 方法、在堆栈中查找项并确定到堆栈顶距离的 search 方法。

特点

1. 基于栈结构的集合，先进后出
2. Stack 类是 Vector类的子类，所以该类也是线程安全的，效率低，建议使用 Deque接口的实现类

常用方法

E push(E item) 将元素压入栈底
E pop() 将元素从栈结构中弹出，并作为此函数的值返回该对象，此方法会影响栈结构的大小
E peek() 查看堆栈顶部的对象，但不从栈中移除它。
boolean empty() 测试栈是否为空。
int search(Object o) 返回对象在栈中的位置，以 1 为基数。

注：如果栈中元素为空，再尝试弹栈，将会抛出 EmptyStackException 异常, 而不是 NoSuchElementException

示例代码如下：

Stack<String> stack = new Stack<>();
// 压栈
stack.push("A");
stack.push("B");
stack.push("C");

while (!stack.isEmpty()) {
    System.out.println("栈顶元素:" + stack.peek());
    // 弹栈
    System.out.println("弹出栈顶元素:" + stack.pop());
}

Queue

概述

在处理元素前用于保存元素的 collection。除了基本的 Collection 操作外，队列还提供其他的插入、提取和检查操作。每个方法都存在两种形式：一种抛出异常（操作失败时），另一种返回一个特殊值（null 或
false，具体取决于操作）。插入操作的后一种形式是用于专门为有容量限制的 Queue 实现设计的；在大多数实现中，插入操作不会失败。

特点

1. 该接口是队列接口的根接口，先进先出
2. 该接口提供队列相关两种形式的方法，一种抛出异常（操作失败时），另一种返回一个特殊值（null 或
   false，具体取决于操作）。插入操作的后一种形式是用于专门为有容量限制的 Queue 实现设计的；在大多数实现中，插入操作不会失败。

常用方法

	抛出异常	返回特殊值
插入	add(e)	offer(e)
移除	remove()	poll()
检查	element()	peek()

示例代码：

Queue<String> queue = new ArrayDeque<>();
queue.add("A");
queue.add("B");
queue.add("C");

while (!queue.isEmpty()) {
    System.out.println(queue.remove());
}
// 或者
queue.offer("A");
queue.offer("B");
queue.offer("C");

while (!queue.isEmpty()) {
    System.out.println(queue.poll());
}

Deque

概述

一个线性 collection，支持在两端插入和移除元素。名称 deque 是“double ended queue（双端队列）”的缩写，通常读为“deck”。大多数 Deque 实现对于它们能够包含的元素数没有固定限制，但此接口既支持有容量限制的双端队列，也支持没有固定大小限制的双端队列。

特点

1. Deque是一个Queue的子接口，是一个双端队列，支持在两端插入和移除元素
2. deque支持索引值直接存取。
3. Deque头部和尾部添加或移除元素都非常快速。但是在中部安插元素或移除元素比较费时。
4. 插入、删除、获取操作支持两种形式：快速失败和返回null或true/false
5. 不推荐插入null元素，null作为特定返回值表示队列为空

常用方法

	第一个元素（头部）		最后一个元素（尾部）
	抛出异常	特殊值	抛出异常	特殊值
插入	addFirst(e)	offerFirst(e)	addLast(e)	offerLast(e)
移除	removeFirst()	pollFirst()	removeLast()	pollLast()
检查	getFirst()	peekFirst()	getLast()	peekLast()

双向队列操作

插入元素

• addFirst(): 向队头插入元素，如果元素为null，则发生空指针异常
• addLast(): 向队尾插入元素，如果为空，则发生空指针异常
• offerFirst(): 向队头插入元素，如果插入成功返回true，否则返回false
• offerLast(): 向队尾插入元素，如果插入成功返回true，否则返回false

移除元素

• removeFirst(): 返回并移除队头元素，如果该元素是null，则发生NoSuchElementException
• removeLast(): 返回并移除队尾元素，如果该元素是null，则发生NoSuchElementException
• pollFirst(): 返回并移除队头元素，如果队列无元素，则返回null
• pollLast(): 返回并移除队尾元素，如果队列无元素，则返回null

获取元素

• getFirst(): 获取队头元素但不移除，如果队列无元素，则发生NoSuchElementException
• getLast(): 获取队尾元素但不移除，如果队列无元素，则发生NoSuchElementException
• peekFirst(): 获取队头元素但不移除，如果队列无元素，则返回null
• peekLast(): 获取队尾元素但不移除，如果队列无元素，则返回null

栈操作

pop(): 弹出栈中元素，也就是返回并移除队头元素，等价于removeFirst()，如果队列无元素，则发生NoSuchElementException

push(): 向栈中压入元素，也就是向队头增加元素，等价于addFirst()，如果元素为null，则发生NoSuchElementException，如果栈空间受到限制，则发生IllegalStateException

引用场景

1. 满足FIFO场景时
2. 满足LIFO场景时，曾经在解析XML按标签时使用过栈这种数据结构，但是却选择Stack类，如果在进行栈选型时，更推荐使用Deque类，应为Stack是线程同步

ArrayDeque

概述

Deque 接口的大小可变数组的实现。数组双端队列没有容量限制；它们可根据需要增加以支持使用。它们不是线程安全的；在没有外部同步时，它们不支持多个线程的并发访问。禁止 null 元素。此类很可能在用作堆栈时快于 Stack，在用作队列时快于 LinkedList。

特点

LinkedList

LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
LinkedList 实现 List 接口，能对它进行队列操作。
LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。
LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。
LinkedList 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。
LinkedList 是非同步的。

LinkedList构造函数

// 默认构造函数
LinkedList()

// 创建一个LinkedList，保护Collection中的全部元素。
LinkedList(Collection<? extends E> collection)

AbstractSequentialList简介

在介绍LinkedList的源码之前，先介绍一下AbstractSequentialList。毕竟，LinkedList是AbstractSequentialList的子类。

AbstractSequentialList 实现了get(int index)、set(int index, E element)、add(int index, E element) 和 remove(int index)这些函数。这些接口都是随机访问List的，LinkedList是双向链表；既然它继承于AbstractSequentialList，就相当于已经实现了“get(int index)这些接口”。

此外，我们若需要通过AbstractSequentialList自己实现一个列表，只需要扩展此类，并提供 listIterator() 和 size() 方法的实现即可。若要实现不可修改的列表，则需要实现列表迭代器的 hasNext、next、hasPrevious、previous 和 index 方法即可。

LinkedList继承关系

java.lang.Object
   ↳     java.util.AbstractCollection<E>
         ↳     java.util.AbstractList<E>
               ↳     java.util.AbstractSequentialList<E>
                     ↳     java.util.LinkedList<E>

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

LinkedList的本质是双向链表。
(01) LinkedList继承于AbstractSequentialList，并且实现了Dequeue接口。
(02) LinkedList包含两个重要的成员：header 和 size。
　　header是双向链表的表头，它是双向链表节点所对应的类Entry的实例。Entry中包含成员变量： previous, next, element。其中，previous是该节点的上一个节点，next是该节点的下一个节点，element是该节点所包含的值。
　　size是双向链表中节点的个数。

总结：

(01) LinkedList 实际上是通过双向链表去实现的。
它包含一个非常重要的内部类：Entry。Entry是双向链表节点所对应的数据结构，它包括的属性有：当前节点所包含的值，上一个节点，下一个节点。
(02) 从LinkedList的实现方式中可以发现，它不存在LinkedList容量不足的问题。
(03) LinkedList的克隆函数，即是将全部元素克隆到一个新的LinkedList对象中。
(04) LinkedList实现java.io.Serializable。当写入到输出流时，先写入“容量”，再依次写入“每一个节点保护的值”；当读出输入流时，先读取“容量”，再依次读取“每一个元素”。
(05) 由于LinkedList实现了Deque，而Deque接口定义了在双端队列两端访问元素的方法。提供插入、移除和检查元素的方法。每种方法都存在两种形式：一种形式在操作失败时抛出异常，另一种形式返回一个特殊值（null 或 false，具体取决于操作）。

 			第一个元素（头部）                 最后一个元素（尾部）
        抛出异常        特殊值            抛出异常        特殊值
插入    addFirst(e)    offerFirst(e)    addLast(e)        offerLast(e)
移除    removeFirst()  pollFirst()      removeLast()    pollLast()
检查    getFirst()     peekFirst()      getLast()        peekLast()

(06) LinkedList可以作为FIFO(先进先出)的队列，作为FIFO的队列时，下表的方法等价：

队列方法       等效方法
add(e)        addLast(e)
offer(e)      offerLast(e)
remove()      removeFirst()
poll()        pollFirst()
element()     getFirst()
peek()        peekFirst()

(07) LinkedList可以作为LIFO(后进先出)的栈，作为LIFO的栈时，下表的方法等价：

栈方法        等效方法
push(e)      addFirst(e)
pop()        removeFirst()
peek()       peekFirst()

LinkedList遍历方式

LinkedList支持多种遍历方式。建议不要采用随机访问的方式去遍历LinkedList，而采用逐个遍历的方式。

1、通过迭代器遍历。即通过Iterator去遍历。

for(Iterator iter = list.iterator(); iter.hasNext();)
    iter.next();

2、通过快速随机访问遍历LinkedList

int size = list.size();
for (int i=0; i<size; i++) {
    list.get(i);        
}

3、通过foreach遍历LinkedList

for (Integer integ:list) 
    ;

4、通过Iterator集合遍历LinkedList

Iterator<String> it = list.iterator();
		while(it.hasNext()){
			String s = it.next();
			System.out.println(s);
		}

5、通过pollFirst()来遍历LinkedList

while(list.pollFirst() != null)
    ;

6、通过pollLast()来遍历LinkedList

while(list.pollLast() != null)
    ;

7、 通过removeFirst()来遍历LinkedList

try {
    while(list.removeFirst() != null)
        ;
} catch (NoSuchElementException e) {
}

8、 通过removeLast()来遍历LinkedList

try {
    while(list.removeLast() != null)
        ;
} catch (NoSuchElementException e) {
}

面试题总结

集合中常用的数据结构都有哪些，并说明各自的优缺点？

常用的数据结构
数组、栈、队列、链表、哈希表、二叉树

数组

数组的特点：
1、长度固定
2、可以存储基本数据类型(8个)，也可以存储引用类型(类、接口、数组)
3、存储元素类型一致
4、数组可以在内存中连续存储多个元素的构造，在内存中的分配也是连续的
5、数组中的元素通过数组的下标进行访问的，下标从0开始的
数组的优点 ：
1、通过索引查询元素速度快
2、通过索引遍历数组方便
数组的缺点：
1、数组的大小是固定的，所以不能动态的扩容
2、数组只能存储一种类型的数据
3、添加，删除的操作慢，因为要移动其他的元素
数组的适用场景：
频繁查询，对存储空间要求不大，很少增加和删除的情况

Stack

栈的特点
1、先进后出
2、栈的表现有入栈、压栈、进栈-------出栈、弹栈
栈的优点：存取速度比堆要快。
栈的缺点：存在栈的数据大小和生存期必须是确定的，缺乏灵活性。

集合

集合的特点：
1、长度可变
2、可以存储引用类型，也可以存储基本数据类型对应的包装类类型(Integer、Character等)
3、可以存储多种类型(String,int,double等)

List

有序、可以有重复元素的集合
List 接口的三个典型实现：
1、List list1 = new ArrayList();
　　　　底层数据结构是数组，查询快，增删慢;线程不安全，效率高
2、List list2 = new Vector();
　　　　底层数据结构是数组，查询快，增删慢;线程安全，效率低,几乎已经淘汰了这个集合
3、List list3 = new LinkedList();
　　　　底层数据结构是链表，查询慢，增删快;线程不安全，效率高

Set

HashSet：要保证元素唯一性，需要覆盖掉Object中的equals和hashCode方法（因为底层是通过这两个方法来判断两个元素是否是同一个）

TreeSet：以二叉树的结构对元素进行存储，可以对元素进行排序。
排序的两种方式：
1、元素自身具备比较功能，元素实现Comparable接口，覆盖compareTo方法。
2、创建一个比较器对象，该对象实现Comparator接口，覆盖compare方法，并将该对象作为参数传给TreeSet的构造函数（可以用匿名内部类）。

Map

Map的特点：
元素是成对出现的，以键(key)和值(value)的形式体现出来，键要保证唯一性
常用类有：HashMap、Hashtable 、TreeMap
HashMap：线程是不安全的，允许存放null键、null值。
Hashtable：线程是安全的，不允许存放null键、null值。
TreeMap：可以对键进行排序（要实现排序方法同TreeSet）。

LinkedList

链表的特点：
通过一个链子把多个结点（元素）连接起来，由数据和地址值组成的元素，
节点本身必须有一个地址值（就是下一个元素的地址值）
链表的优点：
1、链表是很常用的一种数据结构，不需要初始化容量，
2、可以任意加减元素；
3、添加或者删除元素时只需要改变前后两个元素结点的指针域指向地址即可，
4、添加，删除很快；
链表的缺点：
1、含有大量的指针域，占用空间较大；
2、查找元素需要遍历链表来查找，
3、非常耗时。
链表的适用场景：
数据量较小，需要频繁增加，删除操作的场景

Queue

队列的特点：
是一种先进先出的数据结构，运算受限制的线性表，只可以在对头删除元素，在队尾插入元素
线性表是同一类型数据的一个有限序列
元素之间的先后排列次序蕴涵着其线性关系。线性表中的第一个元素称为表头元素，最后一个元素称为表尾元素
队列可以分为顺序队列和链式队列，根据不同的存储方式，定义的结构也不同。
顺序队列包含一个数组成员，有二端包含一个数组成员 我们把删除一端叫头
插入一端叫尾
链接存储的有序线性表类需要继承链接线性表类LinkList和实现有序线性表接口SortedList
区别：
1.占用的内存空间
链表存放的内存空间可以是连续的，也可以是不连续的，数组则是连续的一段内存空间。一般情况下存放相同多的数据数组占用较小的内存，而链表还需要存放其前驱和后继的空间。
2.长度的可变性
链表的长度是按实际需要可以伸缩的，而数组的长度是在定义时要给定的，如果存放的数据个数超过了数组的初始大小，则会出现溢出现象。
3.对数据的访问
链表方便数据的移动而访问数据比较麻烦；数组访问数据很快捷而移动数据比较麻烦。
链表和数组的差异决定了它们的不同使用场景，如果需要很多对数据的访问，则适合使用数组；如果需要对数据进行很多移位操作，则设和使用链表。