[Java] 集合类的使用，你学会了吗

程序喵正在路上

已于 2022-07-20 15:02:18 修改

阅读量1k

点赞数 26

文章标签： java intellij idea

于 2022-06-05 08:00:00 首次发布

本文链接：https://blog.csdn.net/weixin_62511863/article/details/124993153

版权

🔥一个人走得远了，就会忘记自己为了什么而出发，希望你可以不忘初心，不要随波逐流，一直走下去🎶
🦋 欢迎关注🖱点赞👍收藏🌟留言🐾
🦄 本文由程序喵正在路上原创，CSDN首发！
💖 系列专栏：Java入门
🌠 首发时间：2022年6月5日
✅ 如果觉得博主的文章还不错的话，希望小伙伴们三连支持一下哦

写在前面

java.util 包中提供了一些集合类，常用的有 List、Set 和 Map，其中，List 和 Set 继承 Collection 接口。这些集合类又称为容器，它们与数组不同，数组的长度是固定的，集合的长度是可变的，数组用来存放基本类型的数据，集合用来存放类对象的引用。

List 接口、Set 接口、Map 接口及 Collection 接口的主要特征如下：

接口	描述
Collection	List 接口和 Set 接口的父接口，通常情况下不被直接使用
List	继承自 Collection 接口，允许存放重复的对象，排序方式按照对象的插入顺序
Set	继承自 Collection 接口，不允许存放重复的对象，排序方式按照自身内部的排序规则
Map	以键值对（key-value）的形式存放对象，其中，键（key）对象不可以重复，值（value）对象可以重复，排序方式按照自身内部的排序规则

Collection接口的常用方法

Collection 接口是 List 接口和 Set 接口的父接口，通常情况下不被直接使用，不过，Collection 接口定义了一些通用的方法，通过这些方法可以实现对集合的基本操作，因为 List 接口和 Set 接口继承自 Collection 接口，所以这些方法对 List 集合和 Set 集合是通用的。

下面是几个 Collection 接口中常用的方法。

addAll()

addAll() 方法将指定 Collection 中的所有元素都添加到此 Collection 中。如果在进行此操作的同时修改了指定的 Collection，那么将不能保证此操作的正确性。

实例：在项目中创建类 TestCollection，在该类的主方法中定义 Collection 集合，并通过 add() 方法向集合中添加 String 类型对象，通过 addAll() 方法将该集合中的所有对象都添加到另一个 Collection 集合中。

import java.util.*;

public class TestCollection {
    public static void main(String[] args) {
        String red = "red";
        String green = "green";
        String blue = "blue";

        Collection<String> list1 = new ArrayList<>();
        //通过add()方法添加指定对象到集合中
        list1.add(red);
        list1.add(blue);

        Collection<String> list2 = new ArrayList<>();
        //通过addAll()方法添加指定集合中的所有对象到该集合中
        list2.addAll(list1);
        list2.add(green);

        //通过iterator()方法序列化集合中的所有对象
        Iterator<String> it = list2.iterator();
        while (it.hasNext()) {
            //获取集合中各个元素
            String str = it.next().toString();
            //输出元素
            System.out.println(str);
        }
    }
}

注意
由于 Collection 是接口，因此不能对其实例化，因为 ArrayList 类是 Collection 接口的间接实现类，所以通过 ArrayList 类实例化。

执行上面的代码，结果如下：
在这里插入图片描述

removeAll()方法

从指定的集合中移除包含在另一个集合中的元素，返回值为 boolean 类型，如果包含要移除的对象则返回 true，否则返回 false。

下面我们来看一个例子，在项目中创建类 TestCollection，在该类的主方法中定义 Collection 集合 list1 与 list2，并分别向这两个集合添加 String 类型对象。

import java.util.*;

public class TestCollection {
    public static void main(String[] args) {
        String red = "红色";
        String green = "绿色";
        String blue = "蓝色";

        //定义Collection集合对象
        Collection<String> list1 = new ArrayList<>();
        //添加指定对象到集合中
        list1.add(red);
        list1.add(blue);

        Collection<String> list2 = new ArrayList<>();
        list2.add(green);
        list2.add(blue);

        //从集合中移除同时包含在另一个集合中的元素
        boolean isContains = list1.removeAll(list2);

        //输出结果
        System.out.println("集合list1与list2是否包含有重复元素：" + isContains);

        //创建集合的迭代器
        Iterator<String> it = list1.iterator();

        System.out.println("执行removeAll()方法后list1集合中的元素：");
        while (it.hasNext()) {
            //获取集合中各个元素
            String str = it.next();
            //输出元素
            System.out.print(str + " ");
        }
    }
}

执行上面的代码，结果如下：
在这里插入图片描述

retainAll()方法

retainAll() 方法仅保留该集合中同时包含在指定集合中的对象，其他的全部移除，与 removeAll() 方法正好相反。返回值为 boolean 型，如果存在符合移除条件的对象则返回 true，否则返回 false。

下面我们来看一个例子，在项目中创建类 TestCollection，在该类的主方法中定义两个 Collection 集合，并分别向这两个集合中添加对象，使用 retainAll() 方法保留在集合1中与集合2中都存在的对象，其实也就是在前面的程序上稍微改一下就行了。

import java.util.*;

public class TestCollection {
    public static void main(String[] args) {
        String red = "红色";
        String green = "绿色";
        String blue = "蓝色";

        //定义Collection集合对象
        Collection<String> list1 = new ArrayList<>();
        //添加指定对象到集合中
        list1.add(red);
        list1.add(blue);

        Collection<String> list2 = new ArrayList<>();
        list2.add(green);
        list2.add(blue);

        //保留list1集合中同时包含在list2中的元素
        boolean isContains = list1.retainAll(list2);

        //输出结果
        System.out.println("集合list1与list2是否包含有重复元素：" + isContains);

        //创建集合的迭代器
        Iterator<String> it = list1.iterator();

        System.out.println("执行retainAll()方法后list1集合中的元素：");
        while (it.hasNext()) {
            //获取集合中各个元素
            String str = it.next();
            //输出元素
            System.out.print(str + " ");
        }
    }
}

执行上面的代码，结果如下：
在这里插入图片描述

containsAll()方法

containsAl() 方法用来查看在该集合中是否存在指定集合中的所有对象，返回值为 boolean 型，如果存在则返回 true，否则返回 false。

下面我们来看一个例子，在项目中创建类 TestCollection，在该类中定义两个 Collection 集合，分别向这两个集合中添加 String 类型对象，通过调用 containsAll() 方法判断指定的集合中是否包含另一个集合中的全部对象。

import java.util.*;

public class TestCollection {
    public static void main(String[] args) {
        String red = "红色";
        String green = "绿色";
        String blue = "蓝色";

        //定义Collection集合对象
        Collection<String> list1 = new ArrayList<>();
        //添加指定对象到集合中
        list1.add(red);
        list1.add(blue);

        Collection<String> list2 = new ArrayList<>();
        list2.add(green);
        list2.add(blue);

        //调用containsAll()方法
        boolean isContains = list1.containsAll(list2);
        //输出结果
        System.out.println("集合list1是否包含集合list2中所有元素：\n" + isContains);

        list1.add(green);

        //调用containsAll()方法
        boolean isContains1 = list1.containsAll(list2);
        //输出结果
        System.out.println("集合list1是否包含集合list2中所有元素：\n" + isContains1);
    }
}

执行上面的代码，结果如下：
在这里插入图片描述

toArray()方法

如果要将一个集合转变为数组形式，可以使用 Collection 接口的 toArray() 方法。toArray() 方法用来获得一个包含所有对象的指定类型的数组。toArray() 方法的入口参数必须为数组类型的实例，并且必须已经被初始化，它的作用是用来指定欲获得数组的类型。

下面我们来看一个例子，在项目中创建类 TestCollection，在该类的主方法中定义 Collection 集合，并向集合中添加 String 类型对象，通过 toArray() 方法输出数组。

import java.util.*;

public class TestCollection {
    public static void main(String[] args) {
        //定义3个字符串对象
        String red = "红色";
        String green = "绿色";
        String blue = "蓝色";

        //定义Collection集合对象
        Collection<String> list = new ArrayList<>();

        //向集合中添加对象
        list.add(red);
        list.add(green);
        list.add(blue);

        //通过toArray()方法获得一个包含所有对象的指定类型的数组
        Object[] arr = list.toArray();

        //循环遍历数组对象
        for (int i = 0; i < arr.length; i++) {
            //将数组中的元素输出
            System.out.println(arr[i]);
        }
    }
}

执行上面的代码，结果如下：
在这里插入图片描述

List集合

List 集合包括 List 接口及 List 接口的所有实现类。List 集合中的元素允许重复，各元素的顺序就是对象插入的顺序。类似于 Java 数组，我们可以通过使用索引来访问集合中的元素。

List接口的实现类

List 接口的常用实现类有 ArrayList 与 LinkedList。

ArrayList 类实现了可变的数组，允许所有元素，包括 null，可以根据索引位置对集合进行快速的随机访问，缺点是向指定的索引位置插入对象或删除对象的速度比较慢。

LinkedList 类采用链表结构保存对象。这种结构的优点就是便于向集合中插入和删除对象，如果需要经常向集合中插入、删除对象，使用 LinkedList 类实现的 List 集合的效率更高，但对于要随机访问集合中的对象，使用 LinkedList 类实现的 List 集合的效率较低。

使用 List 集合时，通常声明为 List 类型，可通过不用的实现类来实例化集合。例如下面的代码：

List list = new ArrayList();
List list1 = new LinkedList();

List的用法

List 接口继承了 Collection 接口，所以 List 接口拥有 Collection 接口提供的所有常用方法，又因为 List 是列表类型，所以 List 接口还提供了一些适用自身的常用方法，如下表所示。

方法	描述
add(int index, Object obj)	用来向集合的指定索引位置添加对象，其他对象的索引位置相对后移一位，索引位置从0开始
addAll(int index, Collection coll)	用来向集合的指定索引位置添加指定集合中的所有对象
remove(int index)	用来清除集合中指定索引位置的对象
set(int index,Object obj)	用来将集合中指定索引位置的对象修改为指定的对象
get(int index)	用来获得指定索引位置的对象
indexOf(Object obj)	用来获得指定对象的索引位置。当存在多个时，返回第一个的索引位置；当不存在时，返回 -1
lastIndexOf(Object obj)	用来获得指定对象的索引位置。当存在多个时，返回最后一个的索引位置；当不存在时，返回 -1
listIterator()	用来获得一个包含所有对象的 ListIterator 型实例
listIterator(int index)	用来获得一个包含从指定索引位置到最后的 Listlterator 型实例
subList(int fromIndex, int toIndex)	通过截取从起始索引位置 fromIndex（包含）到终止索引位置 toIndex (不包含) 的对象，重新生成一个 List 集合并返回

从上表我们可以看出，List 接口提供的适合自身的常用方法均与索引有关，这是因为 List 集合为列表类型，以线性方式存储对象，可以通过对象的索引操作对象。

List 接口的常用实现类有 ArrayList 和 LinkedList。在使用 List 集合时，通常声明为 List 类型，实例化时根据实际需要实例化为 ArrayList 或 LinkedList，例如：

//利用ArrayList类实例化List集合
List<String> list1 = new ArrayList<>();

//利用LinkedList类实例化List集合
List<String> list2 = new LinkedList<>();

add(int index, Object obj)方法和set(int index, Object obj)方法的区别

在使用 List 集合时，需要注意区分 add(int index, Object obj) 方法和 set(int index, Object obj) 方法，前者是向指定索引位置添加对象，而后者是修改指定索引位置的对象。

import java.util.*;

public class TestCollection {
    public static void main(String[] args) {
        //定义3个字符串对象
        String red = "红色";
        String green = "绿色";
        String blue = "蓝色";
        String cyan = "青蓝色";
        String white = "白色";

        //定义集合对象
        List<String> list = new LinkedList<>();

        //向集合中添加对象
        list.add(red);
        list.add(green);
        list.add(blue);

        //创建集合迭代器
        Iterator<String> itList = list.iterator();

        System.out.println("集合中的对象：");
        //循环遍历集合
        while(itList.hasNext()){
            System.out.print(" " + itList.next() + " ");
        }

        //修改索引位置为1的对象
        list.set(1,cyan);

        //创建新的集合迭代器
        Iterator<String> itList1 = list.iterator();
        System.out.println("\n修改索引位置为1的对象后，集合中的对象：");
        //循环遍历集合
        while(itList1.hasNext()){
            System.out.print(" " + itList1.next() + " ");
        }

        //添加对象到索引位置为2的地方
        list.add(2,white);

        Iterator<String> itList2 = list.iterator();
        System.out.println("\n添加对象到索引位置为2的地方后，集合中的对象：");
        //循环遍历集合
        while(itList2.hasNext()){
            System.out.print(" " + itList2.next() + " ");
        }
    }
}

执行上面的代码，结果如下：
在这里插入图片描述

indexOf(Object obj)方法和lastIndexOf(Object obj)方法的区别

在使用 List 集合时，需要注意区分 indexOf(Object obj) 方法和 lastIndexOf (Object obj) 方法。前者是获得指定对象的最小的索引位置，而后者是获得指定对象的最大的索引位置。前提条件是指定的对象在 List 集合中具有重复的对象，否则如果在 List 集合中有且仅有一个指定的对象，则通过这两个方法获得的索引位置是相同的。

import java.util.*;

public class TestCollection {
    public static void main(String[] args) {
        //定义3个字符串对象
        String red = "红色";
        String green = "绿色";
        String blue = "蓝色";
        String cyan = "青蓝色";
        String white = "白色";

        //定义集合对象
        List<String> list = new ArrayList<>();

        //向集合中添加对象
        list.add(red);          //索引位置为 0
        list.add(cyan);         //索引位置为 1
        list.add(green);        //索引位置为 2
        list.add(cyan);         //索引位置为 3
        list.add(blue);         //索引位置为 4
        list.add(cyan);         //索引位置为 5
        list.add(white);        //索引位置为 6

        System.out.println("对象cyan第一次出现的位置为：" + list.indexOf(cyan));
        System.out.println("对象cyan最后一次出现的位置为：" + list.lastIndexOf(cyan));

        System.out.println("对象red第一次出现的位置为：" + list.indexOf(red));
        System.out.println("对象red最后一次出现的位置为：" + list.lastIndexOf(red));
    }
}

执行上面的代码，结果如下：
在这里插入图片描述

subList(int fromIndex, int toIndex)方法

在使用 subList(int fromIndex, int toIndex) 方法截取现有 List 集合中的部分对象生成新的 List 集合时，需要注意的是，新生成的集合中包含起始索引位置代表的对象，但是不包含终止索引位置代表的对象。

import java.util.*;

public class TestCollection {
    public static void main(String[] args) {
        //定义3个字符串对象
        String red = "红色";
        String green = "绿色";
        String blue = "蓝色";
        String cyan = "青蓝色";
        String white = "白色";

        //定义集合对象
        List<String> list = new ArrayList<>();

        //向集合中添加对象
        list.add(red);          //索引位置为 0
        list.add(cyan);         //索引位置为 1
        list.add(green);        //索引位置为 2
        list.add(cyan);         //索引位置为 3
        list.add(blue);         //索引位置为 4
        list.add(cyan);         //索引位置为 5
        list.add(white);        //索引位置为 6

        //创建集合迭代器
        Iterator<String> it = list.iterator();

        System.out.println("集合中的元素为：");
        //循环遍历迭代器
        while (it.hasNext()) {
            //输出集合中的对象
            System.out.print(" " + it.next() + " ");
        }

        //利用从索引位置 1 到 4 的对象重新生成一个 List 集合
        list = list.subList(1, 4);

        System.out.println("\n截取集合后的元素为：");
        for (int i = 0; i < list.size(); i++) {
            System.out.print(" " + list.get(i) + " ");
        }
    }
}

执行上面的代码，结果如下：
在这里插入图片描述

Set集合

Set 集合为集类型，集是最简单的一种集合，存放于集中的对象不按特定方式排序，只是简单地把对象加入到集合中，类似于向口袋里放东西。对集中对象的访问等操作是通过对象的引用进行的，所以在集中不能存放重复对象。

Set 包括 Set 接口及 Set 接口的所有实现类。因为 Set 接口继承了 Collection 接口，所以 Set 接口拥有 Collection 接口提供的所有常用方法。

HashSet类

由 HashSet 类实现的 Set 集合的优点是能够快速定位集合中的元素。由 HashSet 类实现的 Set 集合中的对象必须是唯一的，所以添加到由 HashSet 类实现的 Set 集合中的对象需要重新实现 equals() 方法，从而保证插入集合中对象的标识的唯一性。

Set 集合中的对象是无序的，这里所谓的无序并不是完全无序，只是不像 List 集合按对象的插入顺序保存对象。

例如，在下面的例子中，遍历集合输出对象的顺序与向集合插入对象的顺序并不相同。

我们新建一个 Student 类，该类需要重新实现 equals(Object obj) 方法和 hashCode() 方法，以保证对象标识的唯一性和存储分布的合理性。

import java.util.*;

public class Student {
    private String name;
    private long id;

    public Student(String name, long id) {
        this.name = name;
        this.id = id;
    }

    public String getName() { return name; }

    public void setName(String name) { this.name = name; }

    public long getId() { return id; }

    public void setId(long id) { this.id = id; }

    //实现hashCode()方法
    public int hashCode() {
        final int PRIME = 31;
        int result = 1;

        result = PRIME * result + (int) (id ^ (id >>> 32));
        result = PRIME * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    //实现equals()方法
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return id == student.id && Objects.equals(name, student.name);
    }
}

然后我们定义一个测试类来测试，如下

import java.util.*;

public class Test {
    public static void main(String[] args) {
        //定义Set集合对象
        Set<Student> hashSet = new HashSet<>();

        //向集合中添加对象
        hashSet.add(new Student("小明", 202201));
        hashSet.add(new Student("小红", 202202));
        hashSet.add(new Student("小刚", 202203));

        //获取集合迭代器
        Iterator<Student> it = hashSet.iterator();

        //循环遍历集合
        while (it.hasNext()) {
            //获取集合对象
            Student student = it.next();

            //将对象信息输出
            System.out.println(student.getName() + " " + student.getId());
        }
    }
}

执行上面的代码，结果如下：
在这里插入图片描述

TreeSet类

TreeSet 类不仅实现了 Set 接口，还实现了 java.util.SortedSet 接口，从而保证在遍历集合时按照递增的顺序获得对象。遍历对象时，可能是按照自然顺序递增排列，所以存入用 TreeSet 类实现的 Set 集合的对象必须实现 Comparable 接口；也可能是按照指定比较器递增排列，因此可以通过比较器对用 TreeSet 类实现的 Set 集合中的对象进行排序。

TreeSet 类通过实现 java.util.SortedSet 接口增加的方法如下表所示。

方法	描述
comparator()	获得对该集合采用的比较器，返回值为 Comparator 类型，如果未采用任何比较器，则返回 null
first()	返回在集合中的排序位于第一的对象
last()	返回在集合中的排序位于最后的对象
headSet(E toElement)	截取在集合中的排序位于对象 toElement（不包含）之前的所有对象，重新生成一个 Set 集合并返回
subSet(E fromElement, E toElement)	截取在集合中的排序位于对象 fromElement (包含）和对象 toElement（不包含) 之间的所有对象，重新生成一个 Set 集合并返回
tailSet(E fromElement)	截取在集合中的排序位于对象 fromElement（包含）之后的所有对象，重新生成一个 Set 集合并返回

下面我们通过一个例子来详细介绍比较难以理解的 headSet()、subSet() 和 tailSet() 三个方法，以及在使用时需要注意的事项。

首先新建一个 Student 类，用 TreeSet 类实现的 Set 集合要求该类必须实现 java.lang.Comparable 接口，这里实现的排序方式为按编号升序排列。

public class Student implements Comparable {
    private String name;
    private long id;

    public Student(String name, long id) {
        this.name = name;
        this.id = id;
    }

    public String getName() { return name; }

    public void setName(String name) { this.name = name; }

    public long getId() { return id; }

    public void setId(long id) { this.id = id; }

    //默认按学号升序排序
    public int compareTo(Object o) {
        Student student = (Student) o;

        return Long.compare(id, student.id);
    }
}

然后编写一个用来测试的 main() 方法。在 main() 方法中首先初始化一个集合（并对集合进行遍历，然后通过 headSet() 方法截取集合前面的部分对象得到一个新的集合，并遍历新的集合（注意，在新集合中不包含指定的对象），接着通过 subSet() 方法截取集合中间部分的对象得到一个新的集合，并遍历新的集合（注意，在新集合中包含指定的起始对象，但是不包含指定的终止对象），最后通过 tailSet() 方法截取集合后面的部分对象得到一个新的集合，并遍历新的集合（注意，在新集合中包含指定的对象）。

import java.util.*;

public class Test {
    public static void main(String[] args) {
        //定义Set集合对象
        TreeSet<Student> treeSet = new TreeSet<>();

        //创建学生对象
        Student student1 = new Student("小明", 202201);
        Student student2 = new Student("小红", 202202);
        Student student3 = new Student("小刚", 202203);
        Student student4 = new Student("小华", 202204);
        Student student5 = new Student("小李", 202205);
        Student student6 = new Student("小丽", 202206);

        //向集合中添加对象
        treeSet.add(student1);
        treeSet.add(student2);
        treeSet.add(student3);
        treeSet.add(student4);
        treeSet.add(student5);
        treeSet.add(student6);

        //获取集合迭代器
        System.out.println("初始化的集合：");
        Iterator<Student> it = treeSet.iterator();

        //循环遍历集合
        while (it.hasNext()) {
            //获取集合对象
            Student student = it.next();

            //将对象信息输出
            System.out.println("---" + student.getId() + " " + student.getName());
        }

        System.out.println("截取小刚前面部分得到的集合：");

        //截取在集合中排在小刚（不包括）之前的学生
        it = treeSet.headSet(student3).iterator();
        //循环遍历集合
        while (it.hasNext()) {
            //获取集合对象
            Student student = it.next();

            //将对象信息输出
            System.out.println("---" + student.getId() + " " + student.getName());
        }

        System.out.println("截取小红和小李中间部分得到的集合：");

        //截取在集合中排在小红（包括）和小李（不包括）之间的学生
        it = treeSet.subSet(student2,student5).iterator();
        //循环遍历集合
        while (it.hasNext()) {
            //获取集合对象
            Student student = it.next();

            //将对象信息输出
            System.out.println("---" + student.getId() + " " + student.getName());
        }

        System.out.println("截取小刚后面部分得到的集合：");

        //截取在集合中排在小刚（包括）之后的学生
        it = treeSet.tailSet(student3).iterator();
        //循环遍历集合
        while (it.hasNext()) {
            //获取集合对象
            Student student = it.next();

            //将对象信息输出
            System.out.println("---" + student.getId() + " " + student.getName());
        }
    }
}

执行上面的代码，结果如下：
在这里插入图片描述

Map集合

Map 集合为映射类型。映射与集和列表有明显的区别，映射中的每个对象都是成对存在的。映射中存储的每个对象都有一个相应的键（key）对象，在检索对象时，必须通过相应的键对象来获取值（value）对象，这个操作类似于在字典中查找单词，所以要求键对象必须是唯一的。

Map接口

Map 接口提供了将键映射到值的对象。一个映射不能包含重复的键，每个键最多只能映射到一个值。Map 接口中同样提供了集合的常用方法，如 clear()、isEmpty()、size() 等。

Map接口中的常用方法如下表所示。

方法	描述
put(key k, value v)	向集合中添加指定的 key 与 value 的映射关系
containsValue(Object key)	如果此映射包含指定键的映射关系，则返回 true
containsValue(Object value)	如果此映射将一个或多个键映射到指定值，则返回 true
get(Object key)	如果存在指定的键对象，则返回该对象对应的值，否则返回 null
keySet()	返回该集合中的所有键对象形成的 Set 集合
values()	返回该集合中所有值对象形成的 Collection 集合

下面我们通过一个实例来了解 Map 接口中部分方法的使用。

首先在项目中创建类 GetMonth，在该类的主方法中定义 Map 集合，通过该类的 put() 方法将月份的信息添加到集合中，并遍历集合中的所有 value 集合。

import java.util.*;

public class GetMonth {
    public static void main(String[] args) {
        //创建Map实例
        Map map = new HashMap();

        //向集合中添加对象
        map.put("1月","January");
        map.put("2月","February");
        map.put("3月","March");

        //构建Map集合中所有key对象的集合
        Set set = map.keySet();

        //构建Map集合中所有values对象的集合
        Collection coll = map.values();

        Iterator it = coll.iterator();
        System.out.println("values集合中的元素：");

        //遍历集合
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

该实例运行结果如下：
在这里插入图片描述

Map接口的实现类

Map 接口常用的实现类有 HashMap 和 TreeMap。建议使用 HashMap 实现类实现 Map 集合，因为由 HashMap 类实现的 Map 集合对于添加和删除映射关系效率更高。

HashMap 是基于哈希表的 Map 接口的实现，HashMap 通过哈希码对其内部的映射关系进行快速查找。TreeMap 中的映射关系存在一定的顺序，如果希望 Map 集合中的对象存在一定的顺序，应该使用 TreeMap 类实现 Map 集合。

HashMap 类：基于哈希表的 Map 接口的实现，此实现提供所有可选的映射操作，并允许使用 null 值和 null 键，但必须保证键的唯一性。HashMap 通过哈希码对其内部的映射关系进行快速查找。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

TreeMap 类：不仅实现了 Map 接口，还实现了 java.util.SortedMap 接口，因此集合中的映射关系具有一定的顺序。但在添加、删除和定位映射关系上，TreeMap 类比 HashMap 类的性能差一些。由于 TreeMap 类实现的 Map 集合中的映射关系是根据键对象按照一定的顺序排列的，因此不允许键对象是 null。

可以通过 HashMap 类创建 Map 集合，当需要顺序输出时，再创建一个完成相同映射关系的 TreeMap 类实例。

通过 HashMap 类实例化 Map 集合，并遍历该 Map 集合，然后创建 TreeMap 实例，实现将集合中的元素顺序输出。

首先，我们创建一个 Student 类，如下

public class Student {
    private String id;
    private String name;

    public Student(String id,String name) {
        this.id = id;
        this.name = name;
    }
    public String getId() { return id; }

    public void setId(String id) { this.id = id; }

    public String getName() { return name; }

    public void setName(String name) { this.name = name; }
}

然后，创建一个用于测试的主类。首先新建一个 Map 集合，并添加集合对象，分别遍历由 HashMap 与 TreeMap 类实现的 Map 集合，观察两者的不同点。

import java.util.*;

public class Test {
    public static void main(String[] args) {
        //创建由HashMap实现的Map对象
        Map map = new HashMap<>();

        //创建学生对象
        Student student1 = new Student("202201", "小明");
        Student student2 = new Student("202205", "小红");
        Student student3 = new Student("202204", "小刚");
        Student student4 = new Student("202202", "小华");

        //向集合中添加对象
        map.put(student1.getId(), student1.getName());
        map.put(student2.getId(), student2.getName());
        map.put(student3.getId(), student3.getName());
        map.put(student4.getId(), student4.getName());

        //获取Map集合中的key对象集合
        Set set = map.keySet();

        Iterator it = set.iterator();
        System.out.println("HashMap类实现的Map集合，无序：");
        while (it.hasNext()) {
            String id = (String) it.next();
            String name = (String) map.get(id);
            System.out.println(id + " " + name);
        }

        //创建TreeMap集合对象向集合中添加对象
        TreeMap treeMap = new TreeMap(map);

        Iterator it1 = treeMap.keySet().iterator();
        System.out.println("TreeMap类实现的Map集合，键对象升序：");
        while (it1.hasNext()) {
            String id = (String) it1.next();
            String name = (String) map.get(id);
            System.out.println(id + " " + name);
        }
    }
}

执行上面的代码，结果如下：
在这里插入图片描述

🧸这次的分享就到这里啦，继续加油哦^^
🍭有出错的地方欢迎在评论区指出来，共同进步，谢谢啦

程序喵正在路上

关注

26
点赞
踩
29

收藏

觉得还不错? 一键收藏
打赏
49
评论
[Java] 集合类的使用，你学会了吗

java.util 包中提供了一些集合类，常用的有 List、Set 和 Map，其中，List 和 Set 继承 Collection 接口。这些集合类又称为容器，它们与数组不同，数组的长度是固定的，集合的长度是可变的，数组用来存放基本类型的数据，集合用来存放类对象的引用。List 接口、Set 接口、Map 接口及 Collection 接口的主要特征如下：Collection 接口是 List 接口和 Set 接口的父接口，通常情况下不被直接使用，不过，Collection 接口定义了一些通用的方法，
复制链接

扫一扫