32. 【Java教程】集合

news2024/11/17 23:46:22

在前面的小节中，我们学习了数组，本小节学习的集合同样用于存放一组数据，我们将学习什么是集合、集合的应用场景 ，在应用场景部分我们将对比 Java 数组与集合的区别，还将系统介绍 Java 集合的架构，也将结合实例来讲解集合的实际应用。

1. 什么是集合

在计算机科学中，集合是一组可变数量的数据项（也可能为 0 个）的组合，这些数据可能共享某些特征，需要以某种操作方式一起进行操作。

Java 中集合主要分为java.util.Collection和java.util.Map两大接口。

下图描绘了 Java 集合的框架：

Tips： 图表最下方的ArrayList、LinkedList、HashSet以及HashMap都是常用实现类，本小节将介绍具体使用。

1.1 Collection

java.util.Collection接口的实现可用于存储 Java 对象。例如，学校所有学生可以视为一个Collection。

Collection又可以分为三个子接口，分别是：

  1. List：序列，必须按照顺序保存元素，因此它是有序的，允许重复；
  2. Queue：队列，按照排队规则来确定对象产生的顺序，有序，允许重复；
  3. Set：集，不能重复。

1.2 Map

java.util.Map接口的实现可用于表示“键”（key）和“值”（value）对象之间的映射。一个映射表示一组“键”对象，其中每一个“键”对象都映射到一个“值”对象。因此可以通过键来查找值。例如，每一个学生都有他自己的账户积分，这个关联关系可以用Map来表示。

2. 集合的应用场景

2.1 数组与集合

在介绍集合的应用场景之前，我们先来看看数组和集合的对比。

我们知道数组和集合都用于存放一组数据，但数组的容量是固定大小的，而集合的容量是动态可变的；对于可存放的数据类型，数组既可以存放基本数据类型又可以存放引用数据类型，而集合只能存放引用数据类型，基本数据类型需要转换为对应的包装类才能存放到集合当中。

2.2 集合应用场景

  • 无法预测存储数据的数量：由于数组容量是固定大小，因此使用集合存储动态数量的数据更为合适；
  • 同时存储具有一对一关系的数据：例如存储学生的积分，为了方便检索对应学生的积分，可使用Map将学生的uid和对应的积分进行一对一关联；
  • 数据去重：使用数组实现需要遍历，效率低，而Set集合本身就具有不能重复的特性；
  • 需要数据的增删：使用数组实现增删操作需要遍历、移动数组中元素，如果操作频繁会导致效率降低。

3. List 集合

3.1 概念和特性

List 是元素有序并且可以重复的集合，称之为序列。序列可以精确地控制每个元素的插入位置或删除某个位置的元素。通过前面的学习，我们知道List是Collection的一个子接口，它有两个主要实现类，分别为ArrayList（动态数组）和LinkedList（链表）。

3.2 ArrayList 实现类

ArrayList 可以理解为动态数组，它的容量可以动态增长。当添加元素时，如果发现容量已满，会自动扩容为原始大小的 1.5 倍。

3.2.1 构造方法
  • ArrayList()：构造一个初始容量为 10 的空列表；
  • ArrayList(int initialCapacity)：构造一个指定容量的空列表；
  • ArrayList(Collection<? extends E> c)：构造一个包含指定集合元素的列表，其顺序由集合的迭代器返回。

在代码中，我们可以这样实例化ArrayList对象：

// 无参构造实例化，初始容量为10
List arrayList1 = new ArrayList();
// 实例化一个初始容量为20的空列表
List arrayList2 = new ArrayList(20);
// 实例化一个集合元素为 arrayList2 的列表（由于 arrayList2 为空列表，因此其实例化的对象也为空列表）
List arrayList3 = new ArrayList(arrayList2);
3.2.2 常用成员方法

  • void add(E e)：将指定的元素追加到此列表的末尾；

  • void add(int index, E element)：将指定的元素插入此列表中的指定位置；

  • E remove(int index)：删除此列表中指定位置的元素；

  • boolean remove(Object o)：如果存在指定元素，则从该列表中删除第一次出现的该元素；

  • void clear()：从此列表中删除所有元素；

  • E set(int index, E element)：用指定的元素替换此列表中指定位置的元素；

  • E get(int index)：返回此列表中指定位置的元素；

  • boolean contains(Object o)：如果此列表包含指定的元素，则返回 true，否则返回 false；

  • int size()：返回该列表中元素的数量；

  • Object[] toArray()：以正确的顺序（从第一个元素到最后一个元素）返回一个包含此列表中所有元素的数组。

更多成员方法请翻阅官方文档，下面我们将结合实例来介绍以上成员方法的使用。

3.3 实例

3.3.1 新增元素

请查看如下实例：

import java.util.ArrayList;
import java.util.List;

public class ArrayListDemo1 {

    public static void main(String[] args) {
        // 实例化一个空列表
        List arrayList = new ArrayList();
        for (int i = 0; i < 5; i ++) {
            // 将元素 i 追加到列表的末尾
            arrayList.add(i);
            // 打印列表内容
            System.out.println(arrayList);
        }
    }
}

运行结果：

[0]
[0, 1]
[0, 1, 2]
[0, 1, 2, 3]
[0, 1, 2, 3, 4]

代码中，首先实例化了一个ArrayList对象，然后使用 for 循环语句循环 5 次，每次都向arrayList对象中追加变量i，并打印列表内容，运行结果清晰的展示了每次新增元素的过程。

Tips：由于ArrayList的父类AbstractCollection重写了toString()方法，因此直接打印列表，可以直观地展示出列表中的元素。

3.3.2 泛型初识

Tips：泛型（Genericity）**将在下一小节详细介绍，此处我们只简要介绍一下泛型以及其使用方法。如果你比较了解泛型，可直接跳过此知识点。

如果你使用IDEA编写如上代码，将会有下图所示的 3 处黄色警告：

既然IDE有了警告，我们就尝试来解决一下，将鼠标光标放置到警告处，会提示“Unchecked call to ‘add(E)’ as a member of raw type ‘java.util.List’ ”，这是IDE的泛型检查，可点击Try to generify 'ArrayListDemo1.java'按钮：

此时会出现一个Generify的弹窗，直接点击Refactor按钮：

代码变成了下图所示的样子，那 3 处警告被成功消除了：

我们观察到代码第 8 行的List类型后面多了一对尖括号“<>”，<>里面是 Java 的包装类型Integer，在ArrayList类型后面也多了一对尖括号，这里的<>中承载的就是 Java 的泛型的类型参数，它表示arrayList对象用于存放Integer类型的数据。这样的目的和好处这里不详细展开讨论，本小节我们只需知道这样做就可以消除IDEA的警告即可。

由于前面List已经指定了泛型的参数类型为Integer，后面的ArrayList就不需要再重复指定了。当然你也可以这样写（但是没必要）：

List<Integer> arrayList = new ArrayList<Integer>();

同理，如果你想向arrayList存放String类型的元素，只需将<Integer>改为<String>，我们再来看一个实例：

import java.util.ArrayList;
import java.util.List;

public class ArrayListDemo2 {
    public static void main(String[] args) {
        // 实例化一个空列表
        List<String> arrayList = new ArrayList<>();
        // 将字符串元素 Hello 追加到此列表的末尾
        arrayList.add("Hello");
        // 将字符串元素 World 追加到此列表的末尾
        arrayList.add("World");
        // 打印列表
        System.out.println(arrayList);
        // 将字符串元素 Java 插入到此列表中的索引为 1 的位置
        arrayList.add(1, "Java");
        // 打印列表
        System.out.println(arrayList);
    }
}

运行结果：

[Hello, World]
[Hello, Java, World]

代码中，首先实例化了一个ArrayList的对象，调用了两次add(E e)方法，依次向列表尾部插入了Hello和World元素，列表中元素为[Hello, World]，此时调用add(int index, E element)方法，将字符串元素 Java 插入到此列表中的索引为 1 的位置，因此列表中的元素为[Hello, Java, World]。

3.3.3 删除元素

请查看如下实例：

import java.util.ArrayList;
import java.util.List;

public class ArrayListDemo3 {

    public static void main(String[] args) {
        // 实例化一个空列表
        List<String> arrayList = new ArrayList<>();
        // 将字符串元素 Hello 追加到此列表的末尾
        arrayList.add("Hello");
        // 将字符串元素 World 追加到此列表的末尾
        arrayList.add("World");
        // 将字符串元素 Hello 追加到此列表的末尾
        arrayList.add("Hello");
        // 将字符串元素 Java 追加到此列表的末尾
        arrayList.add("Java");
        // 打印列表
        System.out.println(arrayList);

        // 删除此列表中索引位置为 3 的元素
        arrayList.remove(3);
        // 打印列表
        System.out.println(arrayList);

        // 删除此列表中第一次出现的 Hello 元素
        arrayList.remove("Hello");
        System.out.println(arrayList);
    }
}

运行结果：

[Hello, World, Hello, Java]
[Hello, World, Hello]
[World, Hello]

代码中，我们首先添加了 4 个字符串元素，列表内容为[Hello, World, Hello, Java]，然后调用remove(int index)方法删除了索引位置为 3 的元素（即Java），此时列表内容为[Hello, World, Hello] ，再次调用remove(Object o)方法，删除了列表中第一次出现的Hello元素，此时列表内容为[World, Hello]。

3.3.4 修改元素

可使用set()方法修改列表中元素，实例如下：

import java.util.ArrayList;
import java.util.List;

public class ArrayListDemo4 {

    public static void main(String[] args) {
        // 实例化一个空列表
        List<String> arrayList = new ArrayList<>();
        arrayList.add("Hello");
        // 将字符串元素 World 追加到此列表的末尾
        arrayList.add("World");
        // 打印列表
        System.out.println(arrayList);
        // 用字符串元素 Hello 替换此列表中索引位置为 1 的元素
        arrayList.set(1, "Java");
        System.out.println(arrayList);
    }
}

运行结果：

[Hello, World]
[Hello, Java]
3.3.5 查询元素

可使用get()方法来获取列表中元素，实例如下：

import java.util.ArrayList;
import java.util.List;

public class ArrayListDemo5 {

    public static void main(String[] args) {
        // 实例化一个空列表
        List<String> arrayList = new ArrayList<String>();
        arrayList.add("Hello");
        arrayList.add("Immoc");
        for (int i = 0; i < arrayList.size(); i ++) {
            System.out.println("索引位置" + i + "的元素为"  + arrayList.get(i));
        }
    }
}

运行结果：

索引位置0的元素为Hello
索引位置1的元素为Immoc

我们在使用for循环遍历列表的时候，让限定条件为i < arrayList.size();，size()方法可获取该列表中元素的数量。

3.2.7 自定义类的常用操作

请查看如下实例：

import java.util.ArrayList;
import java.util.List;

public class ArrayListDemo6 {

    static class MybjStudent {
        private String nickname;
        
        private String position;

        public MybjStudent() {
        }
        
        public MybjStudent(String nickname, String position) {
            this.setNickname(nickname);
            this.setPosition(position);
        }

        public String getNickname() {
            return nickname;
        }

        public void setNickname(String nickname) {
            this.nickname = nickname;
        }

        public String getPosition() {
            return position;
        }

        public void setPosition(String position) {
            this.position = position;
        }

        @Override
        public String toString() {
            return "MybjStudent{" +
                    "nickname='" + nickname + '\'' +
                    ", position='" + position + '\'' +
                    '}';
        }
    }

    public static void main(String[] args) {
        // 实例化一个空列表
        List<MybjStudent> arrayList = new ArrayList<>();
        // 实例化3个学生对象
        MybjStudent mybjStudent1 = new MybjStudent("Colorful", "服务端工程师");
        MybjStudent mybjStudent2 = new MybjStudent("Lillian", "客户端工程师");
        MybjStudent mybjStudent3 = new MybjStudent("小张", "架构师");
        // 新增元素
        arrayList.add(mybjStudent1);
        arrayList.add(mybjStudent2);
        arrayList.add(mybjStudent3);
        System.out.println(arrayList);
        // 删除元素
        arrayList.remove(mybjStudent2);
        System.out.println("删除 mybjStudent2 后：arrayList 内容为：" + arrayList);
        arrayList.remove(1);
        System.out.println("删除列表中索引位置为 1 的元素后，arrayList 内容为：" + arrayList);
        // 实例化一个新的学生对象
        MybjStudent mybjStudent4 = new MybjStudent("小李", "UI设计师");
        // 修改元素
        arrayList.set(0, mybjStudent4);
        System.out.println("修改后：arrayList 内容为" + mybjStudent4);
        // 查询元素，将 get() 方法得到的 Object 类型强制转换为 MybjStudent 类型
        MybjStudent student = arrayList.get(0);
        System.out.println("索引位置 0 的学生的昵称为：" + student.getNickname());
        System.out.println("索引位置 0 的学生的职位为：" + student.getPosition());
    }
}

运行结果：

[MybjStudent{nickname='Colorful', position='服务端工程师'}, MybjStudent{nickname='Lillian', position='客户端工程师'}, MybjStudent{nickname='小张', position='架构师'}]
删除 mybjStudent2 后：arrayList 内容为：[MybjStudent{nickname='Colorful', position='服务端工程师'}, MybjStudent{nickname='小张', position='架构师'}]
删除列表中索引位置为 1 的元素后，arrayList 内容为：[MybjStudent{nickname='Colorful', position='服务端工程师'}]
修改后：arrayList 内容为MybjStudent{nickname='小李', position='UI设计师'}
索引位置 0 的学生的昵称为：小李
索引位置 0 的学生的职位为：UI设计师

为了方便演示，我们定义了一个静态内部类MybjStudent，它有两个属性nickname和position，定义了属性的getter和setter，并重写了toString()方法。在main()方法中，我们实现了自定义类在ArrayList中的增删改查。

3.4 LinkedList 实现类

LinkedList 是一个以双向链表实现的List。和ArrayList一样，也按照索引位置排序，但它的元素是双向连接的，因此顺序访问的效率非常高，而随机访问的效率比较低。

3.4.1 构造方法
  • LinkedList()：构造一个空列表；
  • LinkedList(Collection<? extends E> c)：构造一个包含指定集合元素的列表，其顺序由集合的迭代器返回。
3.4.2 常用成员方法
  • void add(E e)：将指定的元素追加到此列表的末尾；
  • void add(int index, E element)：将指定的元素插入此列表中的指定位置；
  • void addFirst(E e)：将指定的元素插入此列表的开头；
  • vod addLast(E e)：将指定的元素添加到此列表的结尾；
  • E remove(int index)：删除此列表中指定位置的元素；
  • boolean remove(Object o)：如果存在指定元素，则从该列表中删除第一次出现的该元素；
  • void clear()：从此列表中删除所有元素；
  • E set(int index, E element)：用指定的元素替换此列表中指定位置的元素；
  • E get(int index)：返回此列表中指定位置的元素；
  • E getFirst()：返回此列表的第一个元素；
  • E getLast()：返回此列表的最后一个元素；
  • boolean contains(Object o)：如果此列表包含指定的元素，则返回 true，否则返回 false；
  • int size()：返回该列表中元素的数量；
  • Object[] toArray()：以正确的顺序（从第一个元素到最后一个元素）返回一个包含此列表中所有元素的数组。

更多成员方法请翻阅官方文档，对于成员方法的使用，与ArrayList大同小异，这里不再赘述。

4. Set 集合

4.1 概念和特性

Set是元素无序并且不可以重复的集合，我们称之为集。Set是Collection的一个子接口，它的主要实现类有：HashSet、TreeSet、LinkedHashSet、EnumSet等，下面我们将详细介绍最常用的HashSet实现类。

4.2 HashSet 实现类

HashSet类依赖于哈希表（实际上是HashMap实例，下面将会介绍）。HashSet中的元素是无序的、散列的。

4.2.1 构造方法
  • HashSet()：构造一个新的空集；默认的初始容量为 16（最常用），负载系数为 0.75；
  • HashSet(int initialCapacity)：构造一个新的空集； 具有指定的初始容量，负载系数为 0.75；
  • HashSet(int initialCapacity, float loadFactor)：构造一个新的空集； 支持的 HashMap 实例具有指定的初始容量和指定的负载系数；
  • HashSet(Collection<? extends E> c)：构造一个新集合，其中包含指定集合中的元素。
4.2.2 常用成员方法

HashSet的常用成员方法如下：

  • boolean add(E e)：如果指定的元素尚不存在，则将其添加到该集合中；
  • boolean contains(Object o)：如果此集合包含指定的元素，则返回 true，否则返回 false；
  • boolean isEmpty()：如果此集合不包含任何元素，则返回 true，否则返回 false；
  • Iterator<E> iterator()：返回此集合中元素的迭代器；
  • boolean remove(Object o)：从该集合中删除指定的元素（如果存在）；
  • int size()：返回此集合中的元素数量。

更多成员方法请翻阅官方文档，下面我们将结合实例来介绍以上成员方法的使用。

4.3 实例

4.3.1 新增元素

可使用add()方法向集中添加元素，实例如下：

import java.util.HashSet;
import java.util.Set;

public class HashSetDemo1 {
    public static void main(String[] args) {
        // 实例化一个新的空集
        Set<String> hashSet = new HashSet<String>();
        // 向 hashSet 集中依次添加元素：Python、Java、PHP、TypeScript、Python
        hashSet.add("Python");
        hashSet.add("Java");
        hashSet.add("PHP");
        hashSet.add("TypeScript");
        hashSet.add("Python");
        // 打印 hashSet 的内容
        System.out.println("hashSet中的内容为：" + hashSet);
    }
}

运行结果：

hashSet中的内容为：[TypeScript, Java, PHP, Python]

在实例中，我们先后向hashSet中添加了两次Python元素，由于集的元素不可重复特性，因此集中只允许出现一个Python元素。我们还观察到，打印结果的元素顺序和我们添加的顺序是不同的，这验证了集的无序特性。

Tips： 由于HashSet的父类AbstractCollection重写了toString()方法，因此直接打印集，可以直观地展示出集中的元素。

4.3.2 删除元素

可使用remove()方法删除集中元素，实例如下：

实例演示

import java.util.HashSet;
import java.util.Set;

public class HashSetDemo2 {
    public static void main(String[] args) {
        // 实例化一个新的空集
        Set<String> hashSet = new HashSet<>();
        // 向 hashSet 集中依次添加元素：Python、Java
        hashSet.add("Python");
        hashSet.add("Java");
        // 打印 hashSet 的内容
        System.out.println(hashSet);
        // 删除 hashSet 中的 Python 元素
        hashSet.remove("Python");
        // 打印 hashSet 的内容
        System.out.println("删除 Python 元素后，hashSet中的内容为：" + hashSet);
    }
}

运行结果：

[Java, Python]
删除 Python 元素后，hashSet中的内容为：[Java]
4.3.3 查询元素

我们知道了ArrayList 通过 get方法来查询元素，但HashSet没有提供类似的get方法来查询元素。

这里我们介绍一个迭代器（Iterator）接口，所有的Collection都实现了Iterator接口，它可以以统一的方式对各种集合元素进行遍历。我们来看下Iterator接口的常用方法：

  • hasNaxt() 方法检测集合中是否还有下一个元素；

  • next()方法返回集合中的下一个元素；

  • iterator()：返回此集合中元素的迭代器。

实例如下：

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class HashSetDemo3 {
    public static void main(String[] args) {
        // 实例化一个新的空集
        Set<String> hashSet = new HashSet<String>();
        // 向 hashSet 集中依次添加元素：Python、Java、PHP
        hashSet.add("Python");
        hashSet.add("Java");
        hashSet.add("PHP");
        // 打印 hashSet 的内容
        System.out.println(hashSet);

        // 获取 hashSet 中元素的迭代器
        Iterator<String> iterator = hashSet.iterator();
        System.out.println("迭代器的遍历结果为：");
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

运行结果：

[Java, PHP, Python]
迭代器的遍历结果为：
Java
PHP
Python
4.3.4 自定义类的常用操作

请查看如下实例：

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class HashSetDemo4 {

    /**
     * 静态内部类：学生
     */
    static class MybjStudent {
        private String nickname;

        private String position;

        public MybjStudent() {
        }

        public MybjStudent(String nickname, String position) {
            this.setNickname(nickname);
            this.setPosition(position);
        }

        public String getNickname() {
            return nickname;
        }

        public void setNickname(String nickname) {
            this.nickname = nickname;
        }

        public String getPosition() {
            return position;
        }

        public void setPosition(String position) {
            this.position = position;
        }

        @Override
        public String toString() {
            return "MybjStudent{" +
                    "nickname='" + nickname + '\'' +
                    ", position='" + position + '\'' +
                    '}';
        }
    }

    public static void main(String[] args) {
        Set<MybjStudent> hashSet = new HashSet<>();
        // 实例化3个学生对象
        MybjStudent mybjStudent1 = new MybjStudent("Colorful", "服务端工程师");
        MybjStudent mybjStudent2 = new MybjStudent("Lillian", "客户端工程师");
        MybjStudent mybjStudent3 = new MybjStudent("小张", "架构师");
        // 新增元素
        hashSet.add(mybjStudent1);
        hashSet.add(mybjStudent2);
        hashSet.add(mybjStudent3);
        // 使用Iterator遍历hashSet
        Iterator<MybjStudent> iterator = hashSet.iterator();
        System.out.println("迭代器的遍历结果为：");
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        // 查找并删除
        if (hashSet.contains(mybjStudent1)) {
            hashSet.remove(mybjStudent1);
        }
        System.out.println("删除nickname为Colorful的对象后，集合元素为：");
        System.out.println(hashSet);
    }
}

运行结果：

迭代器的遍历结果为：
MybjStudent{nickname='Lillian', position='客户端工程师'}
MybjStudent{nickname='Colorful', position='服务端工程师'}
MybjStudent{nickname='小张', position='架构师'}
删除nickname为Colorful的对象后，集合元素为：
[MybjStudent{nickname='Lillian', position='客户端工程师'}, MybjStudent{nickname='Colorful', position='服务端工程师'}, MybjStudent{nickname='小张', position='架构师'}]

为了方便演示，我们定义了一个静态内部类MybjStudent，它有两个属性nickname和position，定义了属性的getter和setter，并重写了toString()方法。在main()方法中，我们实现了自定义类在HashSet中的增删改查，使用迭代器可以遍历元素。

5. Map 集合

5.1 概念和特性

我们已经知道Map是以键值对（key-value）的形式存储的对象之间的映射，key-value是以java.util.Map.Entry类型的对象实例存在。

可以使用键来查找值，一个映射中不能包含重复的键，但值是可以重复的。每个键最多只能映射到一个值。

5.2 HashMap 实现类

HashMap是java.util.Map接口最常用的一个实现类，前面所学的HashSet底层就是通过HashMap来实现的，HashMap允许使用null键和null值。

5.2.1 构造方法

  • HashMap()：构造一个新的空映射；默认的初始容量为 16（最常用），负载系数为 0.75；

  • HashMap(int initialCapacity)：构造一个新的空映射； 具有指定的初始容量，负载系数为 0.75；

  • HashMap(int initialCapacity, float loadFactor)：构造一个新的空映射； 支持的 HashMap 实例具有指定的初始容量和指定的负载系数；

  • HashSet(Map<? extends K, ? extends V> m)：构造一个新映射，其中包含指定映射相同。

5.2.2 常用成员方法
  • void clear()：从该映射中删除所有映射；
  • Set<Map, Entry<K, V>> entrySet：返回此映射中包含的映射的集合；
  • V get(Object key)：返回指定键映射到的值，如果该映射不包含键的映射，则返回 null；
  • Set<K> keySet：返回此映射中包含的键的结合；
  • V put(K key, V value)：将指定值与此映射中指定键关联；
  • V remove(Object key)：如果存在，则从此映射中删除指定键的映射。
  • Collection<V> values：返回此映射中包含的集合。

5.3 实例

下面我们使用 HashMap 来实现一个英汉字典的例子。

实例演示

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class HashMapDemo1 {

    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        // 添加数据
        map.put("English", "英语");
        map.put("Chinese", "汉语");
        map.put("Java", "咖啡");
        // 打印 map
        System.out.println(map);
        // 删除 key 为 Java 的数据
        map.remove("Chinese");
        System.out.println("删除键为Chinese的映射后，map内容为：");
        // 打印 map
        System.out.println(map);
        // 修改元素：
        map.put("Java", "一种编程语言");
        System.out.println("修改键为Java的值后，Java=" + map.get("Java"));
        // 遍历map
        System.out.println("通过遍历entrySet方法得到 key-value 映射：");
        Set<Entry<String, String>> entries = map.entrySet();
        for (Entry<String, String> entry: entries) {
            System.out.println(entry.getKey() + " - " + entry.getValue());
        }
        // 查找集合中键为 English 对应的值
        Set<String> keySet = map.keySet();
        for (String key: keySet) {
            if (key.equals("English")) {
                System.out.println("English 键对应的值为：" + map.get(key));
                break;
            }
        }
    }
}

运行结果：

{English=英语, Java=咖啡, Chinese=汉语}
删除键为Chinese的映射后，map内容为：
{English=英语, Java=咖啡}
修改键为Java的值后，Java=一种编程语言
通过遍历entrySet方法得到 key-value 映射：
English - 英语
Java - 一种编程语言
English 键对应的值为：英语

实例中，Map 的 key 是字符串类型，value 也是字符串类型。值得注意的是，我们在创建HashMap的时候，在Map类型的后面有一个<String, String>，分别表示映射中将要存放的 key 和 value 的类型都为 String 类型。在遍历映射的时候，我们调用了entrySet方法，它返回了此映射中包含的映射的集合。通过键查找值，我们可以调用keySet方法来获取映射中的键的集合，并且遍历这个集合即可找到对应键，通过键就可以获取值了。

6. 小结

本小节我们学习了 Java 的集合，它们定义在java.util包中，Java 中的集合主要有Collection和Map两大接口。List集合是元素有序并且可以重复的集合；Set集合是元素无序并且不可以重复的集合；Map是以键值对（key-value）的形式存储的对象之间的映射，它们都支持泛型。我们分别介绍了 3 个接口常用的实现类的用法。同学们要多多进行编码练习。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1721307.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

调查问卷和考试系统SurveyKing

调查问卷和考试系统SurveyKing

什么是 SurveyKing &#xff1f; SurveyKing 是功能更强大的调查问卷、考试系统&#xff0c;很多功能体验超过问卷网、问卷星。支持在线考试/调查问卷/公开查询/题库刷题/投票。 软件特性 &#x1f947; 支持 20 多种题型&#xff0c;如填空、选择、下拉、级联、矩阵、分页、签…
阅读更多...
TCP的重传机制

TCP的重传机制

TCP 是一个可靠的传输协议&#xff0c;解决了IP层的丢包、乱序、重复等问题。这其中&#xff0c;TCP的重传机制起到重要的作用。 序列号和确认号 之前我们在讲解TCP三次握手时&#xff0c;提到过TCP包头结构&#xff0c;其中有序列号和确认号&#xff0c; 而TCP 实现可靠传输…
阅读更多...
FPGA高端项目：FPGA解码MIPI视频+图像缩放+视频拼接，基于MIPI CSI-2 RX Subsystem架构实现，提供4套工程源码和技术支持

FPGA高端项目：FPGA解码MIPI视频+图像缩放+视频拼接，基于MIPI CSI-2 RX Subsystem架构实现，提供4套工程源码和技术支持

目录 1、前言工程概述免责声明 2、相关方案推荐我这里已有的 MIPI 编解码方案本方案在Xilinx Artix7-35T上解码MIPI视频的应用本方案在Xilinx Artix7-100T上解码MIPI视频的应用本方案在Xilinx Kintex7上解码MIPI视频的应用本方案在Xilinx Zynq7000上解码MIPI视频的应用本方案在…
阅读更多...
小邪大佬最新版微信hook

小邪大佬最新版微信hook

目前小邪大佬已经更新到最新版本微信hook了。 /发送文件 BOOL SendCdnFilePbMsg(string sendId, string cdnkey, string aes_key,string file_name,string md5, int size, string syncKey) {FileMessage sfm;sfm.set_file_id(cdnkey);sfm.set_size(size);sfm.set_aes_key(aes_…
阅读更多...
内燃机智能制造工厂工业物联数字孪生平台，推进制造业数字化转型

内燃机智能制造工厂工业物联数字孪生平台，推进制造业数字化转型

内燃机智能制造工厂工业物联数字孪生平台&#xff0c;推进制造业数字化转型。随着科技的飞速发展&#xff0c;制造业正迎来一场深刻的数字化转型。内燃机智能制造工厂工业物联数字孪生平台&#xff0c;作为这一转型的重要推手&#xff0c;正逐渐改变着传统制造业的面貌。 内燃…
阅读更多...
《异常检测——从经典算法到深度学习》29 EasyTSAD: 用于时间序列异常检测模型的工业级基准

《异常检测——从经典算法到深度学习》29 EasyTSAD: 用于时间序列异常检测模型的工业级基准

《异常检测——从经典算法到深度学习》 0 概论1 基于隔离森林的异常检测算法 2 基于LOF的异常检测算法3 基于One-Class SVM的异常检测算法4 基于高斯概率密度异常检测算法5 Opprentice——异常检测经典算法最终篇6 基于重构概率的 VAE 异常检测7 基于条件VAE异常检测8 Donut: …
阅读更多...
LC 旋转 - 模拟对象

LC 旋转 - 模拟对象

原文链接 链接 液晶 (LC) 旋转网格属性允许您以 theta、phi 为单位指定空间变化的 LC 导向。 液晶由杆状分子结构组成&#xff0c;这些分子结构具有相对于长轴的旋转对称性。因此&#xff0c;液晶具有空间变化的单轴光学特性。 相对于分子长轴和分子短轴的折射率称为非寻常 ne …
阅读更多...
Mybatis数据加密解密

Mybatis数据加密解密

文章目录 Mybatis数据加密解密一、自定义注解二、自定义参数处理拦截器结果集拦截器加密解密 Mybatis数据加密解密 方案一&#xff1a;Mybatis拦截器之数据加密解密【Interceptor】 拦截器介绍 Mybatis Interceptor 在 Mybatis 中被当作 Plugin(插件)&#xff0c;不知道为什么…
阅读更多...
注意力可视化代码

注意力可视化代码

读取网络层输出的特征到txt文件&#xff0c;arr为文件名 def hot(self, feature, arr):# 在第二维&#xff08;通道维&#xff09;上相加summed_tensor torch.sum(feature, dim1, keepdimTrue) # 结果形状为 [1, 1, 64, 64]selected_matrix summed_tensor.squeeze(1) # 移除…
阅读更多...
【RS】哨兵系列新网站无法下载的问题及解决办法（Sentinel-2）

【RS】哨兵系列新网站无法下载的问题及解决办法（Sentinel-2）

最近有些小伙伴留言说哨兵数据无法下载&#xff0c;网站打开后会有一层蒙版&#xff0c;无法选取研究区等信息&#xff0c;今天就跟大家分享一下如何解决这个问题。还知道如何下载的小伙伴可以移步到之前的文章&#xff1a;【RS】欧空局Sentinel-2卫星数据下载(哨兵1、2、3、5P…
阅读更多...
shopee签名x-sap-ri、x-sap-sec算法还原

shopee签名x-sap-ri、x-sap-sec算法还原

最新版签名&#xff0c;免账号登录成功率百分百&#xff0c;需要可d 两种方式base64 MTQzMDY0OTc3OA QXVndXN0MjItZnF4
阅读更多...
JS【详解】快速排序

JS【详解】快速排序

快速排序的时间复杂度为 O(n2) 排序流程 1、首先设定一个分界值&#xff08;比如数组最中间的元素&#xff09;&#xff0c;通过该分界值将数组分成左右两部分。 2、将大于或等于分界值的数据集中到数组右边&#xff0c;小于分界值的数据集中到数组的左边。 3、对左侧和右侧的…
阅读更多...
【网络层】IP地址基础 与 子网掩码

【网络层】IP地址基础 与 子网掩码

文章目录 IP地址基础IP地址概念IP地址分类公网地址和私网地址 子网掩码子网掩码作用默认子网掩码网络地址、主机地址、广播地址 IP地址基础 IP地址概念 IP地址&#xff1a;IP Address 在网络中&#xff0c;通信节点都需要有一个IP地址 IP地址以点分十进制表示&#xff0c;有…
阅读更多...
【QEMU中文文档】1.1 支持的构建平台

【QEMU中文文档】1.1 支持的构建平台

本文由 AI 翻译&#xff08;ChatGPT-4&#xff09;完成&#xff0c;并由作者进行人工校对。如有任何问题或建议&#xff0c;欢迎联系我。联系方式&#xff1a;jelin-shoutlook.com。 原文&#xff1a;Supported build platforms — QEMU documentation QEMU 旨在支持在多个主机…
阅读更多...
prometheus docker部署

prometheus docker部署

1.安装Docker sudo mkdir -p /etc/docker sudo tee /etc/docker/daemon.json <<-EOF {"registry-mirrors":["https://hub-mirror.c.163.com"] } EOF export DOWNLOAD_URL"https://hub-mirror.163.com/docker-ce" curl -fsSL https://ge…
阅读更多...
携手亚马逊云科技，神州泰岳如何打通生成式AI落地最后三公里

携手亚马逊云科技，神州泰岳如何打通生成式AI落地最后三公里

导读&#xff1a;神州泰岳成为首批获得亚马逊云科技生成式AI能力认证的合作伙伴。 “过去6年来&#xff0c;在与亚马逊云科技的合作过程中&#xff0c;我们大概签约了300家以上的中国出海企业。”近日在一次沟通会上&#xff0c;神州泰岳副总裁兼云事业部总经理刘家歆这样向媒…
阅读更多...
springboot编写日志环境搭建过程

springboot编写日志环境搭建过程

AOP记录日志 AOP记录日志的主要优点包括&#xff1a; 1、低侵入性&#xff1a;AOP记录日志不需要修改原有的业务逻辑代码&#xff0c;只需要新增一个切面即可。 2、统一管理&#xff1a;通过AOP记录日志可以将各个模块中需要记录日志的部分进行统一管理&#xff0c;降低了代…
阅读更多...
Linux 深入讲解自动化构建工具

Linux 深入讲解自动化构建工具

各位大佬好 &#xff0c;这里是阿川的博客 &#xff0c; 祝您变得更强 个人主页&#xff1a;在线OJ的阿川 大佬的支持和鼓励&#xff0c;将是我成长路上最大的动力 阿川水平有限&#xff0c;如有错误&#xff0c;欢迎大佬指正 Linux一系列的文章&#xff08;质量分均在93分…
阅读更多...
水滴式粉碎机：多功能饲料粉碎设备

水滴式粉碎机：多功能饲料粉碎设备

饲料粉碎机是一种专门用于将各种饲料原料进行粉碎处理的机械设备。无论是玉米、小麦等谷物&#xff0c;还是豆粕、鱼粉等动物性原料&#xff0c;甚至是一些粗纤维含量较高的秸秆、牧草等&#xff0c;都可以经过饲料粉碎机的处理&#xff0c;变成适合畜禽消化吸收的精细饲料。这…
阅读更多...
solr-8.11.3

solr-8.11.3

https://solr.apache.org/downloads.html https://archive.apache.org/dist/solr/solr/ F:\Document_Solr.apache.org\solr-8.11.3\bin Microsoft Windows [版本 10.0.19045.2965] (c) Microsoft Corporation。保留所有权利。 C:\Users\Administrator>F: F:\> F:\>…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023