2022-08-06 java之集合汇总

女爷i 2023-09-30 14:43 56阅读 0赞

#### 目录 ####

*  一、Collection集合接口
 *  二、List集合
 *   *  1.ArrayList
     *  2.LinkedList
     *  3.Vector
 *  三、Set集合
 *   *  1.HashSet
     *   *  1.1向HashSet中添加元素的过程
         *  1.2重写 equals() 方法的基本原则
     *  2.TreeSet
     *  3.LinkedHashSet
     *  4.排序
     *   *  4.1自然排序
         *  4.2定制排序
 *  四、Map集合
 *   *  Map接口概述：
     *  1.HashMap
     *  2.LinkedHashMap
     *  3.HashTabel
     *  4.TreeMap
     *  5.Properties
 *  五、Collections工具类
 *  六、遍历
 *   *  1.遍历 ArrayList
     *  2.遍历Map
 *  面试题

前言：  
集合、数组都是对多个数据进行存储操作的结构，简称Java容器。  
说明：此时的存储，主要是指的内存层面的存储，不涉及到持久化的存储 。

数组在存储多个数据方面的缺点：

*  一旦初始化以后，其长度就不可以修改。
 *  数组中提供的方法十分有限，对于添加，删除，插入数据等操作时非常不便，同时效率不高。
 *  获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用。
 *  数组存储数据的特点: 有序、可重复。对于无序、不可重复的需求，不能满足。
 *  于是有了集合（相当于动态开辟内存空间的数组）

## 一、Collection集合接口 ##

![在这里插入图片描述][d4003764c9ca46b4b5ff43986b8578ec.png]  
![在这里插入图片描述][6a4616bdbcf34fbcb471931f459ac452.png]

*  Set和List的区别

1.  Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。
2.  Set **检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变** <实现类有HashSet,TreeSet>。
3.  List 和数组类似，可以动态增长，根据实际存储的数据的长度自动增长 List 的长度。**查找元素效率高，插入删除效率低，因为会引起其他元素位置改变** <实现类有ArrayList,LinkedList,Vector> 。

## 二、List集合 ##

### 1.ArrayList ###

ArrayList子类是在使用List接口最常用的一个子类，该类利用数组实现List集合操作

通过有参构造方法发现，在ArrayList里面包含的数据实际上就是一个对象数组。

方法：

<table> 
 <thead> 
  <tr> 
   <th align="center">Column 1</th> 
   <th align="right">Column 2</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">add()</td> 
   <td align="right">将元素插入到指定位置的 arraylist 中</td> 
  </tr> 
  <tr> 
   <td align="center">addAll()</td> 
   <td align="right">添加集合中的所有元素到 arraylist 中</td> 
  </tr> 
  <tr> 
   <td align="center">clear()</td> 
   <td align="right">删除 arraylist 中的所有元素</td> 
  </tr> 
  <tr> 
   <td align="center">clone()</td> 
   <td align="right">复制一份 arraylist</td> 
  </tr> 
  <tr> 
   <td align="center">contains()</td> 
   <td align="right">判断元素是否在 arraylist</td> 
  </tr> 
  <tr> 
   <td align="center">get()</td> 
   <td align="right">通过索引值获取 arraylist 中的元素</td> 
  </tr> 
  <tr> 
   <td align="center">indexOf()</td> 
   <td align="right">返回 arraylist 中元素的索引值</td> 
  </tr> 
  <tr> 
   <td align="center">removeAll()</td> 
   <td align="right">删除存在于指定集合中的 arraylist 里的所有元素</td> 
  </tr> 
  <tr> 
   <td align="center">remove()</td> 
   <td align="right">删除 arraylist 里的单个元素</td> 
  </tr> 
  <tr> 
   <td align="center">size()</td> 
   <td align="right">返回 arraylist 里元素数量</td> 
  </tr> 
  <tr> 
   <td align="center">isEmpty()</td> 
   <td align="right">判断 arraylist 是否为空</td> 
  </tr> 
  <tr> 
   <td align="center">set()</td> 
   <td align="right">替换 arraylist 中指定索引的元素</td> 
  </tr> 
  <tr> 
   <td align="center">sort()</td> 
   <td align="right">对 arraylist 元素进行排序</td> 
  </tr> 
  <tr> 
   <td align="center">toArray()</td> 
   <td align="right">将 arraylist 转换为数组</td> 
  </tr> 
  <tr> 
   <td align="center">toString()</td> 
   <td align="right">将 arraylist 转换为字符串</td> 
  </tr> 
  <tr> 
   <td align="center">retainAll()</td> 
   <td align="right">保留 arraylist 中在指定集合中也存在的那些元素</td> 
  </tr> 
  <tr> 
   <td align="center">forEach()</td> 
   <td align="right">遍历 arraylist 中每一个元素并执行特定操作</td> 
  </tr> 
 </tbody> 
</table>

### 2.LinkedList ###

LinkedList 继承了 AbstractSequentialList 类。  
LinkedList 实现了 Queue 接口，可作为队列使用。  
LinkedList 实现了 List 接口，可进行列表的相关操作。  
LinkedList 实现了 Deque 接口，可作为队列使用。  
LinkedList 实现了 Cloneable 接口，可实现克隆。  
LinkedList 实现了 java.io.Serializable 接口，即可支持序列化，能通过序列化去传输。  
![在这里插入图片描述][d6636d4e2e55419cbe53553b807d9be4.png]

*  以下情况使用 ArrayList :

频繁访问列表中的某一个元素。  
只需要在列表末尾进行添加和删除元素操作。

*  以下情况使用 LinkedList :

你需要通过循环迭代来访问列表中的某些元素。  
需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。

--------------------

ArrayList在使用的时候默认的初始化对象数组的大小长度为10，如果空间不足采用2倍形式进行容量的扩充，如果保存大数据的时候有可能造成垃圾的产生以及性能的下降，但是这个时候可以使用LinkedList子类保存。

*  面试题

ArrayList和LinkedList的异同？  
答：二者都线程不安全，相对线程安全的Vector，执行效率高。此外，ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。对于随机访问get和set，ArrayList优于LinkedList，因为LinkedList要移动指针。对于新增和删除操作add(特指插入)和remove，LinkedList比较占优势，因为ArrayList要移动数据。

ArrayList和Vector的区别？  
Vector和ArrayList几乎是完全相同的,唯一的区别在于Vector是同步类(synchronized)，属于强同步类。因此开销就比ArrayList要大，访问要慢。正常情况下,大多数的Java程序员使用ArrayList而不是Vector,因为同步完全可以由程序员自己来控制。Vector每次扩容请求其大小的2倍空间，而ArrayList是1.5倍。Vector还有一个子类Stack。

### 3.Vector ###

## 三、Set集合 ##

### 1.HashSet ###

1.  HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时都使用这个实现类。
2.  HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存取、查找、删除性能。
3.  HashSet 具有以下特点：不能保证元素的排列顺序、HashSet 不是线程安全的、集合元素可以是 null
4.  HashSet 集合判断两个元素相等的标准：两个对象通过 hashCode() 方法比较相等，并且两个对象的 equals() 方法返回值也相等。
5.  对于**存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则**。即：“相等的对象必须具有相等的散列码”。

#### 1.1向HashSet中添加元素的过程 ####

*  当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值，然后根据 hashCode 值，通过某种散列函数决定该对象在 HashSet 底层数组中的存储位置。（这个散列函数会与底层数组的长度相计算得到在数组中的下标，并且这种散列函数计算还尽可能保证能均匀存储元素，越是散列分布，该散列函数设计的越好）
 *  如果两个元素的hashCode()值相等，会再继续调用equals方法，如果equals方法结果为true，添加失败；如果为false，那么会保存该元素，但是该数组的位置已经有元素了，那么会通过链表的方式继续链接。
 *  如果两个元素的 equals() 方法返回 true，但它们的 hashCode() 返回值不相等，hashSet 将会把它们存储在不同的位置，但依然可以添加成功。  
    重写 equals() 方法的基本原则

当一个类有自己特有的“逻辑相等”概念,当改写equals()的时候，总是要改写hashCode()，根据一个类的equals方法（改写后），两个截然不同的实例有可能在逻辑上是相等的，但是，根据Object.hashCode()方法，它们仅仅是两个对象。因此，违反了“相等的对象必须具有相等的散列码”。  
结论：复写equals方法的时候一般都需要同时复写hashCode方法。通常参与计算hashCode的对象的属性也应该参与到equals()中进行计算。

#### 1.2重写 equals() 方法的基本原则 ####

### 2.TreeSet ###

TreeSet 是 SortedSet 接口的实现类，TreeSet 可以确保集合元素处于排序状态。  
TreeSet底层使用红黑树结构存储数据  
TreeSet 两种排序方法：自然排序和定制排序。默认情况下，TreeSet 采用自然排序。

### 3.LinkedHashSet ###

*  LinkedHashSet 是 HashSet 的子类
 *  LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，但它同时使用双向链表维护- 元素的次序，这使得元素看起来是以插入顺序保存的。
 *  LinkedHashSet插入性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。
 *  LinkedHashSet 不允许集合元素重复。

### 4.排序 ###

#### 4.1自然排序 ####

*  TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系，然后将集合元素按升序(默认情况)排列。
 *  如果试图把一个对象添加到 TreeSet 时，则该对象的类必须实现 Comparable 接口。实现 Comparable 的类必须实现 compareTo(Object obj) 方法，两个对象即通过compareTo(Object obj) 方法的返回值来比较大小。

实现Comparable接口

public class Person implements Comparable<Person>{
        ...}

重写compare(T o1,T o2)方法

@Override
        public int compareTo(Person p) {
        
            if (this.id>p.id){
        
                return -1;
            }
            if (this.id.equals(p.id)){
        
                return 0;
            }
            return 1;
        }

*  Comparable 的典型实现：  
    \-BigDecimal、BigInteger 以及所有的数值型对应的包装类：按它们对应的数值大小进行比较  
    Character：按字符的 unicode值来进行比较  
    Boolean：true 对应的包装类实例大于 false 对应的包装类实例  
    String：按字符串中字符的 unicode 值进行比较  
    Date、Time：后边的时间、日期比前面的时间、日期大
 *  向 TreeSet 中添加元素时，只有第一个元素无须比较compareTo()方法，后面添加的所有元素都会调用compareTo()方法进行比较。
 *  因为只有相同类的两个实例才会比较大小，所以向 TreeSet 中添加的应该是同一个类的对象。
 *  对于 TreeSet 集合而言，它判断两个对象是否相等的唯一标准是：两个对象通过 compareTo(Object obj) 方法比较返回值。
 *  当需要把一个对象放入 TreeSet 中，重写该对象对应的 equals() 方法时，应保证该方法与 compareTo(Object obj) 方法有一致的结果：如果两个对象通过equals() 方法比较返回 true，则通过 compareTo(Object obj) 方法比较应返回 0。否则，让人难以理解。

#### 4.2定制排序 ####

1.  TreeSet的自然排序要求元素所属的类实现Comparable接口，如果元素所属的类没有实现Comparable接口，或不希望按照升序(默认情况)的方式排列元素或希望按照其它属性大小进行排序，则考虑使用定制排序。定制排序，通过Comparator接口来实现。需要重写compare(T o1,T o2)方法。
2.  利用int compare(T o1,T o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。
3.  要实现定制排序，需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器。
4.  此时，仍然只能向TreeSet中添加类型相同的对象。否则发生ClassCastException异常。
5.  使用定制排序判断两个元素相等的标准是：通过Comparator比较两个元素返回了0。

## 四、Map集合 ##

### Map接口概述： ###

*  Map与Collection并列存在。用于保存具有映射关系的数据:key-value
 *  Map 中的 key 和 value 都可以是任何引用类型的数据
 *  Map 中的 key 用Set来存放，不允许重复，即同一个 Map 对象所对应的类，须重写 hashCode()和equals() 方法
 *  常用String类作为Map的“键”
 *  key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value
 *  Map接口的常用实现类：HashMap、TreeMap、LinkedHashMap和Properties。其中，HashMap是 Map 接口使用频率最高的实现类

### 1.HashMap ###

HashMap是 Map 接口使用频率最高的实现类。  
允许使用null键和null值，与HashSet一样，不保证映射的顺序。  
所有的key构成的集合是Set:无序的、不可重复的。所以，key所在的类要重写：equals()和hashCode()  
所有的value构成的集合是Collection:无序的、可以重复的。所以，value所在的类要重写：equals()  
一个key-value构成一个entry  
所有的entry构成的集合是Set:无序的、不可重复的  
HashMap 判断两个 key 相等的标准是：两个 key 通过 equals() 方法返回 true，hashCode 值也相等。  
HashMap 判断两个 value相等的标准是：两个 value 通过 equals() 方法返回 true。

### 2.LinkedHashMap ###

LinkedHashMap 是 HashMap 的子类  
在HashMap存储结构的基础上，使用了一对双向链表来记录添加元素的顺序  
与LinkedHashSet类似，LinkedHashMap 可以维护 Map 的迭代顺序：迭代顺序与 Key-Value 对的插入顺序一致

### 3.HashTabel ###

Hashtable是个古老的 Map 实现类，JDK1.0就提供了。不同于HashMap，Hashtable是线程安全的。  
Hashtable实现原理和HashMap相同，功能相同。底层都使用哈希表结构，查询速度快，很多情况下可以互用。  
与HashMap不同，Hashtable 不允许使用 null 作为 key 和 value  
与HashMap一样，Hashtable 也不能保证其中 Key-Value 对的顺序  
Hashtable判断两个key相等、两个value相等的标准，与HashMap一致。

### 4.TreeMap ###

TreeMap存储 Key-Value 对时，需要根据 key-value 对进行排序。TreeMap 可以保证所有的 Key-Value 对处于有序状态。  
TreeSet底层使用红黑树结构存储数据  
TreeMap 的 Key 的排序：  
自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException  
定制排序：创建 TreeMap 时，传入一个 Comparator 对象，该对象负责对TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现Comparable 接口  
TreeMap判断两个key相等的标准：两个key通过compareTo()方法或者compare()方法返回0。

### 5.Properties ###

Properties 类是 Hashtable 的子类，该对象用于处理属性文件  
由于属性文件里的 key、value 都是字符串类型，所以 Properties 里的 key 和 value 都是字符串类型  
存取数据时，建议使用setProperty(String key,String value)方法和getProperty(String key)方法

Properties pros = new Properties();
    pros.load(new FileInputStream("jdbc.properties"));
    String user = pros.getProperty("user");
    System.out.println(user);

## 五、Collections工具类 ##

Collections 是一个操作 Set、List 和 Map 等集合的工具类

Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，  
还提供了对集合对象设置不可变、对集合对象实现同步控制等方法

排序操作：（均为static方法）

reverse(List)：反转 List 中元素的顺序  
shuffle(List)：对 List 集合元素进行随机排序  
sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序  
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序  
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换  
Collections常用方法（查找、替换）

Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素  
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素  
Object min(Collection)  
Object min(Collection，Comparator)  
int frequency(Collection，Object)：返回指定集合中指定元素的出现次数  
void copy(List dest,List src)：将src中的内容复制到dest中 boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换List 对象的所有旧值

## 六、遍历 ##

### 1.遍历 ArrayList ###

import java.util.*;
     
    public class Test{
        
     public static void main(String[] args) {
        
         List<String> list=new ArrayList<String>();
         list.add("Hello");
         list.add("World");
         list.add("HAHAHAHA");
         //第一种遍历方法使用 For-Each 遍历 List
         for (String str : list) {
                    //也可以改写 for(int i=0;i<list.size();i++) 这种形式
            System.out.println(str);
         }
     
         //第二种遍历，把链表变为数组相关的内容进行遍历
         String[] strArray=new String[list.size()];
         list.toArray(strArray);
         for(int i=0;i<strArray.length;i++) //这里也可以改写为  for(String str:strArray) 这种形式
         {
        
            System.out.println(strArray[i]);
         }
         
        //第三种遍历 使用迭代器进行相关遍历
         
         Iterator<String> ite=list.iterator();
         while(ite.hasNext())//判断下一个元素之后有值
         {
        
             System.out.println(ite.next());
         }
     }
    }

### 2.遍历Map ###

public class Test{
        
         public static void main(String[] args) {
        
          Map<String, String> map = new HashMap<String, String>();
          map.put("1", "value1");
          map.put("2", "value2");
          map.put("3", "value3");
          
          //第一种：普遍使用，二次取值
          System.out.println("通过Map.keySet遍历key和value：");
          for (String key : map.keySet()) {
        
           System.out.println("key= "+ key + " and value= " + map.get(key));
          }
          
          //第二种
          System.out.println("通过Map.entrySet使用iterator遍历key和value：");
          Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
          while (it.hasNext()) {
        
           Map.Entry<String, String> entry = it.next();
           System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
          }
          
          //第三种：推荐，尤其是容量大时
          System.out.println("通过Map.entrySet遍历key和value");
          for (Map.Entry<String, String> entry : map.entrySet()) {
        
           System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
          }
        
          //第四种
          System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
          for (String v : map.values()) {
        
           System.out.println("value= " + v);
          }
         }
    }

## 面试题 ##

详见：  
非常全，建议观看  
[点我看更多集合面试题][Link 1]

[d4003764c9ca46b4b5ff43986b8578ec.png]: https://img-blog.csdnimg.cn/d4003764c9ca46b4b5ff43986b8578ec.png
[6a4616bdbcf34fbcb471931f459ac452.png]: https://img-blog.csdnimg.cn/6a4616bdbcf34fbcb471931f459ac452.png
[d6636d4e2e55419cbe53553b807d9be4.png]: https://img-blog.csdnimg.cn/d6636d4e2e55419cbe53553b807d9be4.png
[Link 1]: https://blog.csdn.net/weixin_46129192/article/details/123285295