Java 集合 List接口

青旅半醒 2022-02-12 11:29 424阅读 0赞

### 文章目录 ###

*  List接口
 *  Set
 *  ArrayList
 *  Vector
 *  Stack
 *  Queue

# 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 listIterator() 通过列表迭代器遍历集合中的每一个元素  
ListIterator listIterator(int index) 通过列表迭代器从指定索引处开始正向或者逆向遍历集合中的元素

**获取**

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

**List接口的遍历方式**

1.  toArray
2.  Iterator
3.  foreach
4.  普通for
5.  ListIterator

**List接口去除重复元素**

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

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

**并发修改异常的处理**

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

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

解决办法：

1.  使用 toArray 方法
2.  使用 普通 for 遍历
3.  使用 ListIterator 遍历集合并且使用 列表迭代器修改元素

# Set #

Set接口的特点:

1.无序 【存储无序】

2.唯一

3.可以存储null值,但是null不能重复

# 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 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**

# Queue #

**概述**

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

**特点**

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

**常用方法**

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>抛出异常</th> 
   <th>返回特殊值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>插入</td> 
   <td>add(e)</td> 
   <td>offer(e)</td> 
  </tr> 
  <tr> 
   <td>移除</td> 
   <td>remove()</td> 
   <td>poll()</td> 
  </tr> 
  <tr> 
   <td>检查</td> 
   <td>element()</td> 
   <td>peek()</td> 
  </tr> 
 </tbody> 
</table>