【集合】JAVA基础篇（二）

你的名字 2024-03-27 14:10 83阅读 0赞

#### 目录 ####

*   *  一、java常用集合
     *   *   *  1、Java集合接口的作用
             *  2、Java集合常用实现类的作用
     *  二、Collection 常用的方法
     *  三、List 集合接口
     *   *   *  1、ArrayList类的常用方法
             *  2、LinkList类中的方法
             *  3、Vector
             *  4、ArrayList 类和 LinkedList 类的区别
     *  四、Set 集合
     *   *   *  1、HashSet 类
             *  2、TreeSet 类
             *  3、HashSet 和 TreeSet 区别
     *  五、Map集合
     *   *   *  1、Map接口的常用方法
             *  2、Map的几种常用遍历方法
     *  六、Collections 类
     *   *   *  1、排序（正向和逆向）
             *  2、查找、替换操作
             *  3、复制
             *  4、线程安全
     *  七、集合实现类区别图

`集合类主要负责保存、盛装其他数据，因此集合类也被称为容器类`。Java 所有的集合类都位于 java.util 包下，提供了一个表示和操作对象集合的统一构架，包含大量集合接口，以及这些接口的实现类和操作它们的算法。

集合类和数组不一样，数组元素既可以是基本类型的值，也可以是对象（实际上保存的是对象的引用变量），`而集合里只能保存对象`（实际上只是保存对象的引用变量，但通常习惯上认为集合里保存的是对象）。

Java 集合类型分为 Collection 和 Map，它们是 Java 集合的根接口。  
![在这里插入图片描述][582e66b038394a1f93be8d754c163626.png]![在这里插入图片描述][4a59abdb05c940039905b27522abb2c5.png]

### 一、java常用集合 ###

##### 1、Java集合接口的作用 #####

<table> 
 <thead> 
  <tr> 
   <th>接口名称</th> 
   <th>作 用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Iterable 接口</td> 
   <td>集合的输出接口，主要用于遍历输出（即迭代访问）Collection 集合中的元素，Iterator 对象被称之为迭代器。Iterable 的iterator()方法可用于获取一个迭代器</td> 
  </tr> 
  <tr> 
   <td>Collection 接口</td> 
   <td>是 List、Set 和 Queue 的父接口，是存放一组单值的最大接口。所谓的单值是指集合中的每个元素都是一个对象。一般很少直接使用此接口直接操作。</td> 
  </tr> 
  <tr> 
   <td>Queue 接口</td> 
   <td>Queue 是 Java 提供的队列实现，有点类似于 List。</td> 
  </tr> 
  <tr> 
   <td>Dueue 接口</td> 
   <td>是 Queue 的一个子接口，为双向队列。</td> 
  </tr> 
  <tr> 
   <td>List 接口</td> 
   <td>是最常用的接口。是有序集合，允许有相同的元素。使用 List 能够精确地控制每个元素插入的位置，用户能够使用索引（元素在 List 中的位置，类似于数组下标）来访问 List 中的元素，与数组类似。</td> 
  </tr> 
  <tr> 
   <td>Set 接口</td> 
   <td>不能包含重复的元素。</td> 
  </tr> 
  <tr> 
   <td>Map 接口</td> 
   <td>是存放一对值的最大接口，即接口中的每个元素都是一对，以 key➡value 的形式保存。</td> 
  </tr> 
 </tbody> 
</table>

对于 Set、List、Queue 和 Map 这 4 种集合，Java 最常用的实现类分别是 HashSet、TreeSet、ArrayList、ArrayDueue、LinkedList 和 HashMap、TreeMap 等。表 2 介绍了集合中这些常用的实现类。

##### 2、Java集合常用实现类的作用 #####

<table> 
 <thead> 
  <tr> 
   <th>类名称</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>HashSet</td> 
   <td>为优化査询速度而设计的 Set。它是基于 HashMap 实现的，HashSet 底层使用 HashMap 来保存所有元素，实现比较简单</td> 
  </tr> 
  <tr> 
   <td>TreeSet</td> 
   <td>实现了 Set 接口，是一个有序的 Set，这样就能从 Set 里面提取一个有序序列</td> 
  </tr> 
  <tr> 
   <td>ArrayList</td> 
   <td>一个用数组实现的 List，能进行快速的随机访问，效率高而且实现了可变大小的数组</td> 
  </tr> 
  <tr> 
   <td>ArrayDueue</td> 
   <td>是一个基于数组实现的双端队列，按“先进先出”的方式操作集合元素</td> 
  </tr> 
  <tr> 
   <td>LinkedList</td> 
   <td>对顺序访问进行了优化，但随机访问的速度相对较慢。此外它还有 addFirst()、addLast()、getFirst()、getLast()、removeFirst() 和 removeLast() 等方法，能把它当成栈（Stack）或队列（Queue）来用</td> 
  </tr> 
  <tr> 
   <td>HsahMap</td> 
   <td>按哈希算法来存取键对象</td> 
  </tr> 
  <tr> 
   <td>TreeMap</td> 
   <td>可以对键对象进行排序</td> 
  </tr> 
 </tbody> 
</table>

### 二、Collection 常用的方法 ###

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>boolean add(E e)</td> 
   <td>向集合中添加一个元素，如果集合对象被添加操作改变了，则返回 true。E 是元素的数据类型</td> 
  </tr> 
  <tr> 
   <td>boolean addAll(Collection c)</td> 
   <td>向集合中添加集合 c 中的所有元素，如果集合对象被添加操作改变了，则返回 true。</td> 
  </tr> 
  <tr> 
   <td>void clear()</td> 
   <td>清除集合中的所有元素，将集合长度变为 0。</td> 
  </tr> 
  <tr> 
   <td>boolean contains(Object o)</td> 
   <td>判断集合中是否存在指定元素</td> 
  </tr> 
  <tr> 
   <td>boolean containsAll(Collection c)</td> 
   <td>判断集合中是否包含集合 c 中的所有元素</td> 
  </tr> 
  <tr> 
   <td>boolean isEmpty()</td> 
   <td>判断集合是否为空</td> 
  </tr> 
  <tr> 
   <td>Iteratoriterator()</td> 
   <td>返回一个 Iterator 对象，用于遍历集合中的元素</td> 
  </tr> 
  <tr> 
   <td>boolean remove(Object o)</td> 
   <td>从集合中删除一个指定元素，当集合中包含了一个或多个元素 o 时，该方法只删除第一个符合条件的元素，该方法将返回 true。</td> 
  </tr> 
  <tr> 
   <td>boolean removeAll(Collection c)</td> 
   <td>从集合中删除所有在集合 c 中出现的元素（相当于把调用该方法的集合减去集合 c）。如果该操作改变了调用该方法的集合，则该方法返回 true。</td> 
  </tr> 
  <tr> 
   <td>boolean retainAll(Collection c)</td> 
   <td>从集合中删除集合 c 里不包含的元素（相当于把调用该方法的集合变成该集合和集合 c 的交集），如果该操作改变了调用该方法的集合，则该方法返回 true。</td> 
  </tr> 
  <tr> 
   <td>int size()</td> 
   <td>返回集合中元素的个数</td> 
  </tr> 
  <tr> 
   <td>Object[] toArray()</td> 
   <td>把集合转换为一个数组，所有的集合元素变成对应的数组元素。</td> 
  </tr> 
 </tbody> 
</table>

### 三、List 集合接口 ###

List 是一个`有序、可重复`的集合，集合中每个元素都有其对应的顺序索引。List 集合允许使用重复元素，可以通过索引来访问指定位置的集合元素。List 集合默认按元素的添加顺序设置元素的索引，第一个添加到 List 集合中的元素的索引为 0，第二个为 1，依此类推。

List 实现了 Collection 接口，它主要有两个常用的实现类：`ArrayList 类和 LinkedList 类`。

##### 1、ArrayList类的常用方法 #####

ArrayList 类实现了可变数组的大小,提供了快速基于索引访问元素的方式，对尾部成员的增加和删除支持较好。向中间位置插入与删除元素的速度相对较慢

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>E get(int index)</td> 
   <td>获取此集合中指定索引位置的元素，E 为集合中元素的数据类型</td> 
  </tr> 
  <tr> 
   <td>int indexOf(Object o)</td> 
   <td>返回此集合中第一次出现指定元素的索引，如果此集合不包含该元素，则返回 -1</td> 
  </tr> 
  <tr> 
   <td>int lastIndexOf(Object o)</td> 
   <td>返回此集合中最后一次出现指定元素的索引，如果此集合不包含该元素，则返回 -1</td> 
  </tr> 
  <tr> 
   <td>E set(int index, Eelement)</td> 
   <td>将此集合中指定索引位置的元素修改为 element 参数指定的对象。此方法返回此集合中指定索引位置的原元素</td> 
  </tr> 
  <tr> 
   <td>List subList(int fromlndex, int tolndex)</td> 
   <td>返回一个新的集合，新集合中包含 fromlndex 和 tolndex 索引之间的所有元素。包含 fromlndex 处的元素，不包含 tolndex 索引处的元素</td> 
  </tr> 
 </tbody> 
</table>

##### 2、LinkList类中的方法 #####

LinkedList 类采用链表结构保存对象，这种结构的优点是便于向集合中插入或者删除元素。

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>void addFirst(E e)</td> 
   <td>将指定元素添加到此集合的开头</td> 
  </tr> 
  <tr> 
   <td>void addLast(E e)</td> 
   <td>将指定元素添加到此集合的末尾</td> 
  </tr> 
  <tr> 
   <td>E getFirst()</td> 
   <td>返回此集合的第一个元素</td> 
  </tr> 
  <tr> 
   <td>E getLast()</td> 
   <td>返回此集合的最后一个元素</td> 
  </tr> 
  <tr> 
   <td>E removeFirst()</td> 
   <td>删除此集合中的第一个元素</td> 
  </tr> 
  <tr> 
   <td>E removeLast()</td> 
   <td>删除此集合中的最后一个元素</td> 
  </tr> 
 </tbody> 
</table>

##### 3、Vector #####

Vector 同 ArrayList 一样，都是基于数组实现的，只不过 Vector 是一个`线程安全`的容器，它对内部的每个方法都简单粗暴的上锁,避免多线程引起的安全性问题,但是通常这种同步方式需要的开销比较大,因此,访问元素的效率要远远低于ArrayList。还有一点在于扩容上，`ArrayList 扩容后的数组长度会增加 50%，而 Vector 的扩容长度后数组会增加一倍。`

##### 4、ArrayList 类和 LinkedList 类的区别 #####

ArrayList 与 LinkedList 都是 List 接口的实现类，因此都实现了 List 的所有未实现的方法，只是实现的方式有所不同。

ArrayList 是基于`动态数组数据结构`的实现，`访问元素速度优于 LinkedList`。LinkedList 是基于`链表数据结构`的实现，`占用的内存空间比较大，但在批量插入或删除数据时优于 ArrayList`。

对于`快速访问`对象的需求，使用 ArrayList 实现执行效率上会比较好。需要频繁向集合中`插入和删除`元素时，使用 LinkedList 类比 ArrayList 类效果高。

### 四、Set 集合 ###

Set 集合类似于一个罐子，程序可以依次把多个对象“丢进”Set 集合，而 Set 集合通常不能记住元素的添加顺序。也就是说 `Set 集合中的对象不按特定的方式排序`，只是简单地把对象加入集合。`Set 集合中不能包含重复的对象`。如果添加相同的数据会被覆盖。

Set 实现了 Collection 接口，它主要有两个常用的实现类：`HashSet 类和 TreeSet类`。

##### 1、HashSet 类 #####

HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时就是使用这个实现类。HashSet 是按照 Hash 算法来存储集合中的元素。因此具有很好的存取和查找性能。

##### 2、TreeSet 类 #####

TreeSet 类同时实现了 `Set 接口和 SortedSet 接口`。SortedSet 接口是 Set 接口的子接口，可以实现对集合进行自然排序，因此使用 TreeSet 类实现的 Set 接口默认情况下是自然排序的，这里的自然排序指的是升序排序。

`TreeSet 只能对实现了 Comparable 接口的类对象进行排序`，因为 Comparable 接口中有一个 compareTo(Object o) 方法用于比较两个对象的大小。所以`TreeSet中元素不能为空，不然会报NullPointerException异常`，因为执行compareTo方法时任意一个为null就会抛出NullPointerException异常

**实现Comparable接口类对象的比较方式：**

<table> 
 <thead> 
  <tr> 
   <th>类</th> 
   <th>比较方式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>包装类（BigDecimal、Biglnteger、 Byte、Double、Float、Integer、Long 及 Short)</td> 
   <td>按数字大小比较</td> 
  </tr> 
  <tr> 
   <td>Character</td> 
   <td>按字符的 Unicode 值的数字大小比较</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>按字符串中字符的 Unicode 值的数字大小比较</td> 
  </tr> 
 </tbody> 
</table>

**TreeSet 类除了实现 Collection 接口的所有方法之外，还提供了如下所示的方法：**

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>E first()</td> 
   <td>返回此集合中的第一个元素。其中，E 表示集合中元素的数据类型</td> 
  </tr> 
  <tr> 
   <td>E last()</td> 
   <td>返回此集合中的最后一个元素</td> 
  </tr> 
  <tr> 
   <td>E pollFirst()</td> 
   <td>获取并移除此集合中的第一个元素</td> 
  </tr> 
  <tr> 
   <td>E pollLast()</td> 
   <td>获取并移除此集合中的最后一个元素</td> 
  </tr> 
  <tr> 
   <td>SortedSet subSet(E fromElement,E toElement)</td> 
   <td>返回一个新的集合，新集合包含原集合中 fromElement 对象与 toElement对象之间的所有对象。包含 fromElement 对象，不包含 toElement 对象</td> 
  </tr> 
  <tr> 
   <td>SortedSet headSet(E toElement)</td> 
   <td>返回一个新的集合，新集合包含原集合中 toElement 对象之前的所有对象。不包含 toElement 对象</td> 
  </tr> 
  <tr> 
   <td>SortedSet tailSet(E fromElement)</td> 
   <td>返回一个新的集合，新集合包含原集合中 fromElement 对象之后的所有对象。包含 fromElement 对象</td> 
  </tr> 
 </tbody> 
</table>

**TreeSet集合数据类型必须相同**  
TreeSet集合数据类型不同时会抛出 ClassCastException 异常  
![在这里插入图片描述][6f1f49141e7343508897bbfdfdeddf90.png]

##### 3、HashSet 和 TreeSet 区别 #####

1.  HashSet 无序，TreeSet 有序。
2.  HashSet 元素可以为null，TreeSet 元素不能null。
3.  未指定具体泛型时，HashSet 元素可以不同数据类型，TreeSet 必须相同数据类型。

### 五、Map集合 ###

`Map 是一种键-值对（key-value）集合`，key 和 value 都可以是任何引用类型的数据。`Map 的 key 不允许重复，value 可以重复`，Map 中的 key 和 value 之间存在单向一对一关系，即通过指定的 key，总能找到唯一的、确定的 value。

Map 接口主要有两个实现类：HashMap 类和 TreeMap 类。其中，HashMap 类按哈希算法来存取键对象，而 TreeMap 类可以对键对象进行排序。

##### 1、Map接口的常用方法 #####

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>void clear()</td> 
   <td>删除该 Map 对象中的所有 key-value 对。</td> 
  </tr> 
  <tr> 
   <td>boolean containsKey(Object key)</td> 
   <td>查询 Map 中是否包含指定的 key，如果包含则返回 true。</td> 
  </tr> 
  <tr> 
   <td>boolean containsValue(Object value)</td> 
   <td>查询 Map 中是否包含一个或多个 value，如果包含则返回 true。</td> 
  </tr> 
  <tr> 
   <td>V get(Object key)</td> 
   <td>返回 Map 集合中指定键对象所对应的值。V 表示值的数据类型</td> 
  </tr> 
  <tr> 
   <td>V put(K key, V value)</td> 
   <td>向 Map 集合中添加键-值对，如果当前 Map 中已有一个与该 key 相等的 key-value 对，则新的 key-value 对会覆盖原来的 key-value 对。</td> 
  </tr> 
  <tr> 
   <td>void putAll(Map m)</td> 
   <td>将指定 Map 中的 key-value 对复制到本 Map 中。</td> 
  </tr> 
  <tr> 
   <td>V remove(Object key)</td> 
   <td>从 Map 集合中删除 key 对应的键-值对，返回 key 对应的 value，如果该 key 不存在，则返回 null</td> 
  </tr> 
  <tr> 
   <td>boolean remove(Object key, Object value)</td> 
   <td>这是 Java 8 新增的方法，删除指定 key、value 所对应的 key-value 对。如果从该 Map 中成功地删除该 key-value 对，该方法返回 true，否则返回 false。</td> 
  </tr> 
  <tr> 
   <td>Set entrySet()</td> 
   <td>返回 Map 集合中所有键-值对的 Set 集合，此 Set 集合中元素的数据类型为 Map.Entry</td> 
  </tr> 
  <tr> 
   <td>Set keySet()</td> 
   <td>返回 Map 集合中所有键对象的 Set 集合</td> 
  </tr> 
  <tr> 
   <td>boolean isEmpty()</td> 
   <td>查询该 Map 是否为空（即不包含任何 key-value 对），如果为空则返回 true。</td> 
  </tr> 
  <tr> 
   <td>int size()</td> 
   <td>返回该 Map 里 key-value 对的个数</td> 
  </tr> 
  <tr> 
   <td>Collection values()</td> 
   <td>返回该 Map 里所有 value 组成的 Collection</td> 
  </tr> 
 </tbody> 
</table>

注：`TreeMap 类的使用方法与 HashMap 类相同，唯一不同的是 TreeMap 类可以对键对象进行排序`

##### 2、Map的几种常用遍历方法 #####

[点击跳转][Link 1]

### 六、Collections 类 ###

Collections 类是 Java 提供的一个操作 `Set、List 和 Map 等集合的工具类`。Collections 类提供了许多操作集合的静态方法，借助这些静态方法可以实现集合`元素的排序、查找替换和复制`等操作。下面介绍 Collections 类中操作集合的常用方法。

##### 1、排序（正向和逆向） #####

Collections 提供了如下方法用于对 List 集合元素进行排序。

*  **void reverse(List list)**：对指定 List 集合元素进行逆向排序。
 *  **void shuffle(List list)**：对 List 集合元素进行随机排序（shuffle 方法模拟了“洗牌”动作）。
 *  **void sort(List list)**：根据元素的自然顺序对指定 List 集合的元素按升序进行排序。
 *  **void sort(List list, Comparator c)**：根据指定 Comparator 产生的顺序对 List集合元素进行排序。
 *  **void swap(List list, int i, int j)**：将指定 List 集合中的 i 处元素和 j 处元素进行交换。
 *  **void rotate(List list, int distance)**：当 distance 为正数时，将 list 集合的后distance 个元素“整体”移到前面；当 distance 为负数时，将 list 集合的前 distance个元素“整体”移到后面。该方法不会改变集合的长度。

##### 2、查找、替换操作 #####

Collections 还提供了如下常用的用于查找、替换集合元素的方法。

*  **int binarySearch(List list, Object key)**：使用二分搜索法搜索指定的 List 集合，以获得指定对象在List 集合中的索引。如果要使该方法可以正常工作，则必须保证 List 中的元素已经处于`有序状态`。
 *  **Object max(Collection coll)**：根据元素的自然顺序，返回给定集合中的最大元素。
 *  **Object max(Collection coll, Comparator comp)**：根据 Comparator指定的顺序，返回给定集合中的最大元素。
 *  **Object min(Collection coll)**：根据元素的自然顺序，返回给定集合中的最小元素。
 *  **Object min(Collection coll, Comparator comp)**：根据 Comparator指定的顺序，返回给定集合中的最小元素。
 *  **void fill(List list, Object obj)**：使用指定元素 obj 替换指定 List 集合中的所有元素。
 *  **int frequency(Collection c, Object o)**：返回指定集合中指定元素的出现次数。
 *  **int indexOfSubList(List source, List target)**：返回子 List 对象在父 List对象中第一次出现的位置索引；如果父 List 中没有出现这样的子 List，则返回 -1。
 *  **int lastIndexOfSubList(List source, List target)**：返回子 List 对象在父 List对象中最后一次出现的位置索引；如果父 List 中没有岀现这样的子 List，则返回 -1。
 *  **boolean replaceAll(List list, Object oldVal, Object newVal)**：使用一个新值newVal 替换 List 对象的所有旧值 oldVal。

##### 3、复制 #####

Collections 类的 copy() 静态方法用于将指定集合中的所有元素复制到另一个集合中。执行 copy() 方法后，目标集合中每个已复制元素的索引将等同于源集合中该元素的索引。

copy() 方法的语法格式如下：

void copy(List <? super T> dest,List<? extends T> src)

##### 4、线程安全 #####

Collections 类还为集合类提供了同步包装器将自动同步（线程安全性）添加到任意集合。 六个核心集合接口（Collection, Set, List,Map, SortedSet和SortedMap)中的每一个都有一个静态工厂方法。通过设计iterator为 fail-fast并抛出ConcurrentModificationException。

public static Collection synchronizedCollection(Collection c);
    public static Set synchronizedSet(Set s);
    public static List synchronizedList(List list);
    public static <K,V>  Map<K,V>  synchronizedMap(Map<K,V>  m);
    public static SortedSet synchronizedSortedSet(SortedSet s);
    public static <K,V>  SortedMap<K,V>  synchronizedSortedMap(SortedMap<K,V>  m);

### 七、集合实现类区别图 ###

![在这里插入图片描述][a18d9f34667a41f0a1593ef796859eeb.png]

参考地址：  
http://c.biancheng.net/view/6824.html

[582e66b038394a1f93be8d754c163626.png]: https://img-blog.csdnimg.cn/582e66b038394a1f93be8d754c163626.png
[4a59abdb05c940039905b27522abb2c5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/6651bd9defe942ebb12aab06c8930418.png
[6f1f49141e7343508897bbfdfdeddf90.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/5b26a1e1bc2b4b1f829989397d8140cf.png
[Link 1]: https://blog.csdn.net/weixin_44183847/article/details/118902665?csdn_share_tail=%7B%22type%22:%22blog%22,%22rType%22:%22article%22,%22rId%22:%22118902665%22,%22source%22:%22weixin_44183847%22%7D
[a18d9f34667a41f0a1593ef796859eeb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/99a4ec293d6b46e99248b1b2e149f63c.png