Java之集合实例（ArrayList、Set、Map）详解

超、凢脫俗 2022-03-07 07:40 233阅读 0赞

**目录直通车**

一、 重点

二、 Java的集合框架

概述

Collection接口：

Map接口：

三、 Collection接口API

四、 Iterator迭代器

1、 Iterator

2、 增强型for循环

五、 Collection 子接口：List和Set

六、 Map接口

七、 Collections工具类

1、 Collection 与 Collections的区别是什么？

2、 Collections的使用

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

**学习Java语言就必须学习Java集合类。在Java中的集合类就像是一个容器，专门用来存储Java类的对象。**List接口继承自Collection接口，是单列集合的一个重要分支。只是我们一直习惯性的把实现了List接口的对象称为List集合。

# 一、 重点 #

在Java的集合里面最重要的是以下几点：

1、 常用的集合类

2、 Iterator迭代器

3、 泛型

4、 Collections、Arrays 工具类

# 二、 Java的集合框架 #

## 概述 ##

Java集合分为Collection和Maps两种体系。

### **Collection接口：** ###

1） Set：元素无序、不可重复的集合。

2） List：元素有序、可重复的集合 。就相当与动态数组（长度可变化的）。

### **Map接口：**  ###

具有映射关系“key-Value”（键值对）的集合。

# 三、 Collection接口API #

这张图先放在这里，简单的看一下，学完下面的函数在回来理解这张图就很容易了。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjQ3OTk5_size_16_color_FFFFFF_t_70][]

以下表格中的内容来自官网JDK1.8 ：

<table> 
 <tbody> 
 <tr> 
 <td>修饰类型</td> 
 <td> 方法以及描述 </td> 
 </tr> 
 <tr> 
 <td><code>boolean</code></td> 
 <td><code><a rel="nofollow">add</a>(<a rel="nofollow">E</a>&nbsp;e)</code> 确保此集合包含指定的元素（可选操作）。 </td> 
 </tr> 
 <tr> 
 <td><code>boolean</code></td> 
 <td><code><a rel="nofollow">addAll</a>(<a rel="nofollow">Collection</a>&lt;? extends <a rel="nofollow">E</a>&gt;&nbsp;c)</code> 将指定集合中的所有元素添加到此集合（可选操作）。 </td> 
 </tr> 
 <tr> 
 <td><code>void</code></td> 
 <td><code><a rel="nofollow">clear</a>()</code> 从此集合中删除所有元素（可选操作）。 </td> 
 </tr> 
 <tr> 
 <td><code>boolean</code></td> 
 <td><code><a rel="nofollow">contains</a>(<a rel="nofollow">Object</a>&nbsp;o)</code> 如果此集合包含指定的元素，则返回 true 。 </td> 
 </tr> 
 <tr> 
 <td><code>boolean</code></td> 
 <td><code><a rel="nofollow">containsAll</a>(<a rel="nofollow">Collection</a>&lt;?&gt;&nbsp;c)</code> 如果此集合包含指定 集合中的所有元素，则返回true。 </td> 
 </tr> 
 <tr> 
 <td><code>boolean</code></td> 
 <td><code><a rel="nofollow">equals</a>(<a rel="nofollow">Object</a>&nbsp;o)</code> 将指定的对象与此集合进行比较以获得相等性。 </td> 
 </tr> 
 <tr> 
 <td><code>int</code></td> 
 <td><code><a rel="nofollow">hashCode</a>()</code> 返回此集合的哈希码值。 </td> 
 </tr> 
 <tr> 
 <td><code>boolean</code></td> 
 <td><code><a rel="nofollow">isEmpty</a>()</code> 如果此集合不包含元素，则返回 true 。 </td> 
 </tr> 
 <tr> 
 <td><code><a rel="nofollow">Iterator</a>&lt;<a rel="nofollow">E</a>&gt;</code></td> 
 <td><code><a rel="nofollow">iterator</a>()</code> 返回此集合中的元素的迭代器。 </td> 
 </tr> 
 <tr> 
 <td><code>default <a rel="nofollow">Stream</a>&lt;<a rel="nofollow">E</a>&gt;</code></td> 
 <td><code><a rel="nofollow">parallelStream</a>()</code> 返回可能并行的 <code>Stream</code>与此集合作为其来源。 </td> 
 </tr> 
 <tr> 
 <td><code>boolean</code></td> 
 <td><code><a rel="nofollow">remove</a>(<a rel="nofollow">Object</a>&nbsp;o)</code> 从该集合中删除指定元素的单个实例（如果存在）（可选操作）。 </td> 
 </tr> 
 <tr> 
 <td><code>boolean</code></td> 
 <td><code><a rel="nofollow">removeAll</a>(<a rel="nofollow">Collection</a>&lt;?&gt;&nbsp;c)</code> 删除指定集合中包含的所有此集合的元素（可选操作）。 </td> 
 </tr> 
 <tr> 
 <td><code>default boolean</code></td> 
 <td><code><a rel="nofollow">removeIf</a>(<a rel="nofollow">Predicate</a>&lt;? super <a rel="nofollow">E</a>&gt;&nbsp;filter)</code> 删除满足给定谓词的此集合的所有元素。 </td> 
 </tr> 
 <tr> 
 <td><code>boolean</code></td> 
 <td><code><a rel="nofollow">retainAll</a>(<a rel="nofollow">Collection</a>&lt;?&gt;&nbsp;c)</code> 仅保留此集合中包含在指定集合中的元素（可选操作）。 </td> 
 </tr> 
 <tr> 
 <td><code>int</code></td> 
 <td><code><a rel="nofollow">size</a>()</code> 返回此集合中的元素数。 </td> 
 </tr> 
 <tr> 
 <td><code>default <a rel="nofollow">Spliterator</a>&lt;<a rel="nofollow">E</a>&gt;</code></td> 
 <td><code><a rel="nofollow">spliterator</a>()</code> 创建一个<a rel="nofollow"><code>Spliterator</code></a>在这个集合中的元素。 </td> 
 </tr> 
 <tr> 
 <td><code>default <a rel="nofollow">Stream</a>&lt;<a rel="nofollow">E</a>&gt;</code></td> 
 <td><code><a rel="nofollow">stream</a>()</code> 返回以此集合作为源的顺序 <code>Stream</code> 。 </td> 
 </tr> 
 <tr> 
 <td><code><a rel="nofollow">Object</a>[]</code></td> 
 <td><code><a rel="nofollow">toArray</a>()</code> 返回一个包含此集合中所有元素的数组。 </td> 
 </tr> 
 <tr> 
 <td><code>&lt;T&gt;&nbsp;T[]</code></td> 
 <td><code><a rel="nofollow">toArray</a>(T[]&nbsp;a)</code> 返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。 </td> 
 </tr> 
 </tbody> 
</table>

**举一个全家套的实例（附详解注释）：**

package List;
 
 import java.util.*;
 
 public class TestCollection {
 public static void testCollection1(){
 Collection coll1 = new ArrayList();
 // size() 返回集合个数
 System.out.println("集合元素个数"+coll1.size());
 
 // add(Object o) 像集合添加一个元素
 coll1.add("djun");
 coll1.add(new Date());
 System.out.println("集合元素个数"+coll1.size());
 
 Collection coll2 = Arrays.asList(1,2,3);
 coll1.add(coll2);
 System.out.println("集合元素个数"+coll1.size());
 
 // 直接打印集合的元素名可以直接查看集合的元素
 System.out.println("集合的元素有："+coll1);
 
 // isEmpty() 集合是否为空
 System.out.println("集合为空 ? "+coll1.isEmpty());
 // clear() 清空集合
 coll1.clear();
 System.out.println("集合为空 ? "+coll1.isEmpty());
 
 }
 public static void testCollection2(){
 Collection coll1 = new ArrayList();
 coll1.add("djun");
 coll1.add(123);
 coll1.add(new Date());
 coll1.add("AAA");
 // contains(object obj) 判断集合中是否包含obj元素，返回boolen
 boolean b1 = coll1.contains(123);
 System.out.println(b1);
 }
 public static void testCollection3(){
 Collection coll1 = new ArrayList();
 coll1.add(new Person("Djun",21));
 coll1.add(123);
 coll1.add("AA");
 System.out.println("集合中的元素有："+coll1);
 boolean b1 = coll1.contains(new Person("Djun",21));
 System.out.println(b1);
 /*
 集合中明明有[Person{name='Djun', age=21}]，但为啥还是false？
 先卖个关子。现在到Person里面通过快捷键重写equals方法之后重新运行查看结果。
 
 一般都会重写equals方法。因为contains的判断的依据如下：
 1、 根据自定义的equals方法进行判断。
 2、 如果存入集合中的元素是自定义类的对象，要求：自定义类要重写equals方法。
 */
 Collection coll2 = new ArrayList();
 coll2.add(123);
 coll2.add("BB");
 // containsAll判断当前集合coll1是否包含coll2中所有的元素
 boolean b2 = coll1.containsAll(coll2);
 System.out.println("coll1中是否包含coll2所有的元素？"+b2);
 
 // retainAll(Collection coll) 将coll1与coll2中共有的元素返回给当前集合
 coll1.retainAll(coll2);
 System.out.println("coll1的所有元素为： " + coll1);
 
 // remove可以删除指定元素和指定下标
 boolean b3 = coll1.remove("BB");
 System.out.println("删除是否成功？" + b3);
 
 // removeAll 删除全部是否成功
 boolean b4 = coll1.removeAll(coll1);
 System.out.println("删除是否成功？" + b4);
 System.out.println("coll2中的元素：" + coll2);
 }
 public static void testCollection4(){
 Collection c1 = new ArrayList();
 Collection c2 = new ArrayList();
 
 c1.add(123);
 c1.add("BB");
 
 c2.add(123);
 c2.add("AA");
 
 // equals 判断c1和c2是否完全相同，有一个不同都为false
 System.out.println("c1 和 c2是否完全相同？ " + c1.equals(c2));
 
 // hashcode() 可以得到集合的hash值
 /*
 这个值是怎么得到的呢？
 hashCode把集合中的每一个元素计算成hash值，通过迭代的方式
 加起来最终的一个数字。
 */
 System.out.println("hash:" + c1.hashCode());
 
 // toArray 集合转数组
 Object[] obj = c1.toArray();
 for (int i = 0; i < obj.length; i++) {
 System.out.println("obj的元素"+ obj[i]);
 }
 // iterator() 返回一个Iterator接口实现类的对象
 Iterator iterator = c1.iterator();
 // 方式1 : 不用hashNext
 // System.out.println("不用hashNext: "+iterator.next());
 // System.out.println("不用hashNext: "+iterator.next());
 
 // 方式2 : 不用hashNext
 // for (int i = 0; i < c1.size(); i++) {
 // System.out.println("不用hashNext: "+iterator.next());
 // }
 
 // 方式3: 用hashNext
 while (iterator.hasNext()){
 System.out.println("hashNext: "+iterator.next());
 }
 }
 
 public static void main(String[] args) {
 testCollection1();
 testCollection2();
 testCollection3();
 testCollection4();
 }
 }
 
 class Person{
 private String name;
 private Integer age;
 
 public String getName() {
 return name;
 }
 
 public void setName(String name) {
 this.name = name;
 }
 
 @Override
 public String toString() {
 return "Person{" +
 "name='" + name + '\'' +
 ", age=" + age +
 '}';
 }
 
 public Integer getAge() {
 return age;
 }
 
 public Person(String name, Integer age) {
 this.name = name;
 this.age = age;
 }
 
 public void setAge(Integer age) {
 this.age = age;
 }
 
 @Override
 public boolean equals(Object o) {
 if (this == o) return true;
 if (!(o instanceof Person)) return false;
 Person person = (Person) o;
 return Objects.equals(getName(), person.getName()) &&
 Objects.equals(getAge(), person.getAge());
 }
 
 @Override
 public int hashCode() {
 return Objects.hash(getName(), getAge());
 }
 }

# 四、 Iterator迭代器 #

## 1、 Iterator ##

集合遍历都可以使用这款迭代器。具体如何使用，请看下例：

import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Date;
    import java.util.Iterator;
    
    public class TestIterator {
    
        public void test1(){
            Collection c1 = new ArrayList();
            c1.add(123);
            c1.add("AA");
            c1.add(new Date());
    
            Iterator i = c1.iterator();
            /*
             hasNext() 判断集合的下一个是否为空，
             不为空则接着下移
              */
    
            while(i.hasNext()){
                System.out.println(i.next());
            }
        }
    }

除此遍历集合的方式，是否还有其它可靠的方式来取值呢？

## 2、 增强型for循环 ##

import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Date;
    
    public class TestIterator {
        public static void main(String[] args) {
            Collection c1 = new ArrayList();
            c1.add(123);
            c1.add("AA");
            c1.add(new Date());
    
            // 增强型for循环实现遍历集合
            for(Object i : c1){
                System.out.println(i);
            }
            
            // 增强型for循环实现遍历集合
            String [] str = new String[]{"AA","BB","CC"};
            // s是一个新的局部变量，不会对str造成影响
            for (String s : str){
                System.out.println(s);
            }
        }
    }

#  五、 Collection 子接口：List和Set #

内容有点长就不挤在一篇文章里面了，分开详细写了一篇：

[https://blog.csdn.net/qq\_41647999/article/details/88806372][https_blog.csdn.net_qq_41647999_article_details_88806372]

# 六、 Map接口 #

详细的另外写了一篇：

[https://blog.csdn.net/qq\_41647999/article/details/88823947][https_blog.csdn.net_qq_41647999_article_details_88823947]

# 七、 Collections工具类 #

## **1、 Collection 与 Collections的区别是什么？** ##

（1） Collection 是接口。

（2） Collections是一个工具类可以操作Collection 与 Map 的工具类，提供了一系列**静态方法**，用于对集合中元素进行排序、搜索以及线程安全等各种操作。

## 2、 Collections的使用 ##

（1） reverse(List)   // 逆置List元素

（2） shuffle(List)    // 对List元素随机排序

（3） sort(List)        // 对List元素自然顺序升序排序

（4） sort(List. Comparator)  // 对List元素自定义排序

（5） swap(List.int, int)   // 将两个指定的List的元素 i 和 j 处元素进行交换

（6） Object max(Collection )  // 根据自然顺序，返回给集合最大的元素

（7） Object max(Collection.Comparator )  // 根据自定义顺序，返回给集合最大的元素

（8） Object min(Collection )

（9） Object min(Collection )

（10） int frequency(Collection ,Object )    // 返回指定集合中的元素出现的次数

（11）void copy(List list1 , List list2) // 将 list1 的元素复制到 list2 中

既然都是静态方法，直接调用就是了，这边还是举一个调用的栗子吧~

import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Date;
    import java.util.List;
    
    public class TestCollections {
        public static void main(String[] args) {
            List list = new ArrayList();
            list.add(123);
            list.add("AA");
            list.add(new Date());
            list.add("BB");
            System.out.println(list);
            Collections.reverse(list);
            System.out.println(list);
    
        }
    }

最后在说一个**同步线程安全的控制**方法：

通过 List list2 =  Collections.synchronizedList(list1); 来获取线程安全的 list2

最后最后在提一个接口，叫做Enumeration。

它是Iterator迭代器的一个古老版本，知道有这么个东西就可以了。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjQ3OTk5_size_16_color_FFFFFF_t_70 1][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjQ3OTk5_size_16_color_FFFFFF_t_70]: /images/20220307/779b2fae47ca4018bfee948c9b904b4c.png
[https_blog.csdn.net_qq_41647999_article_details_88806372]: https://blog.csdn.net/qq_41647999/article/details/88806372
[https_blog.csdn.net_qq_41647999_article_details_88823947]: https://blog.csdn.net/qq_41647999/article/details/88823947
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjQ3OTk5_size_16_color_FFFFFF_t_70 1]: /images/20220307/aadb1220008f49e589349bfda7cf58e9.png