JavaSE-09-Java集合详解

「爱情、让人受尽委屈。」 2023-10-06 10:46 9阅读 0赞

**Table of Contents**

Java集合框架

1：基本概念

2：Conllection接口

3：List（列表）

4：Set(集)

5：Map

6：List的实现类

6.1：ArrayList（线性集合）

6.2：LinkedList 底层原理

7：Set接口的实现

7.1：HashSet 的底层原理

7.2：TreeSet 底层原理

8：排序:

8.1:自然排序---Comparable

8.2:客户化排序---Comparator

8：Map接口的实现

9：泛型

10：Collections 工具类

10.1：排序

10.2：最小元素

10.3：最大元素

10.4：没有交集

10.5：翻转

10.6：交换

10.7：替换

10.8：复制

10.9：统计次数

10：以前的历史集合

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

# Java集合框架 #

# 1：基本概念 #

集合是包含多个对象的简单对象，所包含的对象称为元素。集合的典型应用是用来处理多种类型的对象，这些类型必须有共同的父类。

“集合框架”由一组用来操作对象的接口组成。不同接口描述不同类型的组。在很大程度上，一旦你理解了接口，就理解了框架。

虽然总要创建接口特定的实现，但访问实际集合的方法应该限制在接口方法的使用上；因此，允许更改基本的数据结构而不必改变其它代码。框架接口层次结构如下图所示。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 1][]

# 2：Conllection接口 #

在 Collection 接口中声明了适用于 Java 集合（只包含 Set 和 List）的通用方法。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 3][]

# 3：List（列表） #

与集合父类重复的不再赘述

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>void add(E e)</td> 
   <td>将指定元素加在列表的末尾</td> 
  </tr> 
  <tr> 
   <td>void add (int index,E.element)</td> 
   <td>向list中指定位置插入元素</td> 
  </tr> 
  <tr> 
   <td>boolean addAll (Collection c)</td> 
   <td>将指定集合的所有元素都加载改集合末尾</td> 
  </tr> 
  <tr> 
   <td>E get(int index)</td> 
   <td>返回列表中指定元素</td> 
  </tr> 
  <tr> 
   <td>int indexOf(Object o)</td> 
   <td>返回列表中第一次出现元素的位置</td> 
  </tr> 
  <tr> 
   <td>int lastIndexOf()</td> 
   <td>返回列表中最后一次出现元素的位置</td> 
  </tr> 
  <tr> 
   <td>E remove(int index)</td> 
   <td>移除列表中指定位置的元素</td> 
  </tr> 
  <tr> 
   <td>E set(int index,E element)</td> 
   <td>用指定元素替换指定位置的元素</td> 
  </tr> 
  <tr> 
   <td>List&lt;E&gt; subList(int fromIndex,int toIndex)</td> 
   <td>返回列表中指定的 fromIndex(包括)和 toIndex(不包括)之间的部分视图</td> 
  </tr> 
 </tbody> 
</table>

# 4：Set(集) #

set的方法基本和list没有区别，只不过set是无序的

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>boolean add(E e)</td> 
   <td>如果 set 中尚未存在指定的元素，则添加此元素</td> 
  </tr> 
  <tr> 
   <td>boolean contains(Object o)</td> 
   <td>如果 set 包含指定的元素，则返回 &nbsp;true</td> 
  </tr> 
  <tr> 
   <td>Iterator iterator()</td> 
   <td>返回在此 set 中的元素上进行迭代的迭代器</td> 
  </tr> 
  <tr> 
   <td>boolean remove(Object o)</td> 
   <td>如果 set 中存在指定的元素，则将其移除</td> 
  </tr> 
  <tr> 
   <td>Object[] toArray()</td> 
   <td>返回一个包含 set 中所有元素的数组</td> 
  </tr> 
 </tbody> 
</table>

遍历set，利用迭代器Iterator

public class TestMain {
    
        public static void main(String[] args) {
            Set<String> set = new TreeSet<>();
            //获取迭代器
            Iterator<String> iterator = set.iterator();
            while(iterator.hasNext()){
                System.out.println("遍历的值："+iterator.next());
            }
        }
    }

# 5：Map #

Map(映射)是一种把键对象和值对象进行映射的集合，它的每一个元素都包含一对键对象和值对象，而值对象仍可以是Map类型，以此类推，这样就形成了多级映射。向Map集合中加入元素时，必须提供一对键对象和值对象，从 Map 集合中检索元素时，只要给出键对象，就会返回对应的值对象。

JDK中API的方法

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>方法</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>void clear()</td> 
   <td>从此映射中移除所有映射关系</td> 
  </tr> 
  <tr> 
   <td>boolean containsKey(Object key)</td> 
   <td>如果此映射包含指定键的映射关系，则返回 true</td> 
  </tr> 
  <tr> 
   <td>boolean containsValue(Object value)</td> 
   <td>如果此映射将一个或者多个见映射到此值上，返回true</td> 
  </tr> 
  <tr> 
   <td>Set&lt;Map.Entry&gt; entrySet()</td> 
   <td>返回此映射中包含的映射关系的 Set 视图</td> 
  </tr> 
  <tr> 
   <td>boolean equals(Object o)</td> 
   <td>比较指定的对象与此映射是否相等</td> 
  </tr> 
  <tr> 
   <td>V get(Object key)</td> 
   <td>通过键值（key）来得到相应的value值，如果没有这个key，那么返回null</td> 
  </tr> 
  <tr> 
   <td>boolean isEmpty()</td> 
   <td>判断该映射关系是否为空</td> 
  </tr> 
  <tr> 
   <td>Set&lt;K&gt; keySet()</td> 
   <td>返回该映射（map）所有key组成的set</td> 
  </tr> 
  <tr> 
   <td>V put(K key,V value)</td> 
   <td>为此map添加关系映射</td> 
  </tr> 
  <tr> 
   <td>void putAll(Map m)</td> 
   <td>将指定映射中的所有映射关系复制到此映射</td> 
  </tr> 
  <tr> 
   <td>V remove(Object key)</td> 
   <td>删除此映射中对应key的关系</td> 
  </tr> 
  <tr> 
   <td>int size()</td> 
   <td>返回这个映射中的key-value的对数</td> 
  </tr> 
  <tr> 
   <td>Collection values()</td> 
   <td>返回此映射中包含的值（value）的 Collection 视图</td> 
  </tr> 
  <tr> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

# 6：List的实现类 #

## 6.1：ArrayList（线性集合） ##

ArrayList 是一种线性数据结构,它的底层是用数组实现的,相当于动态数组。

## 6.2：LinkedList 底层原理 ##

LinkedList 底层是通过一个双向链表实现。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 4][]

所以linkedlist的寻找元素很快

# 7：Set接口的实现 #

## 7.1：HashSet 的底层原理 ##

HashSet 类按照哈希算法来存取集合中的对象，具有很好的存取和查找性能。当向集合中加入一个对象时，HashSet 会调用对象的 hashCode()方法来获得哈希码，然后根据这个哈希码进一步计算出对象在集合中的存放位置。

在 Object 类中定义了 hashCode()和 equals()方法，Object 类的 equals()方法按照内存地址比较对象是否相等，因此如果 object1.equals(object2)为 true，则表明object1 和 object2 变量实际上引用同一个对象，那么两个对象的哈希码也肯定相等。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 5][]

## 7.2：TreeSet 底层原理 ##

TreeSet 底层使用平衡二叉树（红黑树）实现。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 6][]

# 8：排序: #

## 8.1:自然排序---Comparable ##

他在java.lang包下

Comparable可以认为是一个**内比较器**，实现了Comparable接口的类有一个特点，就是这些 类是可以和自己比较的，至于具体和另一个实现了Comparable接口的类如何比较，则依赖compareTo方法的实现，compareTo方法也被称为自然比较方法。

对于表达式x.compareTo(y)，如果返回值为 0，则表示 x 和 y相等，如果返回值大于0，则表示 x 大于 y，如果返回值小于 0，则表示 x 小于 y。

在JDK类库中，有一部分类实现Comparable接口，如Integer、Double和String等。Comparable 接口有一个 compareTo(Object o)方法，它返回整数类型。所以这些都是可以直接排序比较的；

如何使用：

//定义一个实体类，这个类自己实现了Comparable接口
    public class Person implements Comparable<Person> {
    
        String name;
        int age;
    
    
        //重写排序方法
        @Override
        public int compareTo(Person o) {
            int i = 0;
            
            i = name.compareTo(o.name); // 使用字符串的比较
            if (i == 0) { // 如果名字一样,比较年龄, 返回比较年龄结果
                return age - o.age;
            } else {
                return i; // 名字不一样, 返回比较名字的结果.
            }
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 7][]

## 8.2:客户化排序---Comparator ##

他在java.util包下

Comparator 是在集合外部实现的排序，所以，如想实现排序，就需要在集合外定义 Comparator 接口的方法或在集合内实现 Comparable 接口的方法。

用 Comparator 是策略模式（strategy design pattern），就是不改变对象自身，而用一个策略对象（strategy object）来改变它的行为。  
  
比如：你想对整数采用绝对值大小来排序，Integer 是不符合要求的，你不需要去修改 Integer 类（实际上你也不能这么做）去改变它的排序行为，只要使用一个实现了 Comparator 接口的对象来实现控制它的排序就行了。

//定义一个实体类
    public class Person {
    
        String name;
        int age;
    
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
    }

第一中方式：定义外部比较器；

//在类的外部自定义比较器
    public class MyConparator implements Comparator<Person> {
        @Override
        public int compare(Person one, Person two) {
            int i = 0;
            i = one.name.compareTo(two.name); // 使用字符串的比较
            if(i == 0) { // 如果名字一样,比较年龄,返回比较年龄结果
                return one.age - two.age;
            } else {
                return i; // 名字不一样, 返回比较名字的结果.
            }
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 8][]

第二种，直接使用匿名内部类

public class TestMain {
    
        public static void main(String[] args) {
            Person p1 = new Person("张三",12);
            Person p2 = new Person("张三",16);
            Person p3 = new Person("李四",12);
    
            List<Person> plist = new ArrayList<>();
            plist.add(p2);
            plist.add(p3);
            plist.add(p1);
            System.out.println(""+ plist);
    
            Collections.sort(plist, new Comparator<Person>() {
                @Override
                public int compare(Person one, Person two) {
                    int i = 0;
                    i = one.name.compareTo(two.name); // 使用字符串的比较
                    if(i == 0) { // 如果名字一样,比较年龄,返回比较年龄结果
                        return one.age - two.age;
                    } else {
                        return i; // 名字不一样, 返回比较名字的结果.
                    }
                }
            });
            System.out.println(""+ plist);
    
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 9][]

# 8：Map接口的实现 #

如果 Set 中的元素是由两个值组合成的对象，那么就是 Map 了。

实际上 HashSet 的实现都是通过封装了一个 HashMap 的成员变量来实现的。TreeSet 也不例外。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 10][]

# 9：泛型 #

1：集合中的元素，可以是任意类型的元素；（如果是对象，就是对象的引用）

2：泛型则是规定了某一个集合只可以存放特定类型的对象，设置了泛型的集合会在编译期间进行类型检查，可以按特定类型获取集合元素

List<String> list = new ArrayList<>();
    String s = list.get(0);

# 10：Collections 工具类 #

Collections 是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，是一个工具类，服务于 Java 的 Collection 框架

## 10.1：排序 ##

public static <T extends Comparable<? super T>> void sort(List<T>  
list)

【排序】根据元素的自然顺序对指定列表按升序进行排序。返回集合

## 10.2：最小元素 ##

public static <T extends Object & Comparable<? super T>> T min (Collection<? extends T> coll)  
【最小元素】  
根据元素的自然顺序返回给定 Collection 的最小元素，**Collection 中的所有元素必须实现 Comparable 接口**，也可传入外置比较器，此外，collection 中的所有元素都必须是可相互比较的。

## 10.3：最大元素 ##

public static <T extends Object & Comparable<? super T>> T max (Collection<? extends T> coll)  
【最大元素】根据元素的自然顺序，返回给定 collection 的最大元素

## 10.4：没有交集 ##

public static boolean disjoint(Collection<?> c1,Collection<?> c2)  
【没有交集】如果两个指定 collection 中没有相同的元素，则返回 true

## 10.5：翻转 ##

public static void reverse(List<?> list)  
【反转】反转指定列表中元素的顺序。

## 10.6：交换 ##

public static void swap(List<?> list,int i ，int j)  
【交换】在指定列表的指定位置处交换元素。

## 10.7：替换 ##

public static <T> void fill(List<? super T> list,T obj)  
【填充】使用指定元素替换指定列表中的所有元素。

## 10.8：复制 ##

public static <T> void copy(List<? super T> dest,List<? extendsT> src)  
【复制】将所有元素从一个列表复制到另一个列表。执行此操作后，目标列表中每个已复制元素的索引将等同于源列表中该元素的索引，目标列表的长度至少必须等于源列表。

## 10.9：统计次数 ##

public static int frequency(Collection<?> c,Object o)  
【次数】返回指定 collection 中等于指定对象的元素数。指定 object o 在 c 中出现的次数。

# 10：以前的历史集合 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 11][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200609163959106.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200609164041833.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200609164148544.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200609164209257.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200609221517865.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200609221843773.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200609221935301.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200609230214850.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/2020060923082155.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200609231247762.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/2020060922211033.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20200609232051258.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2,size_16,color_FFFFFF,t_70