Java—— 双列集合 Map

双列集合体系结构

 

双列集合的特点

1.双列集合一次需要存一对数据，分别为键和值
2.键不能重复，值可以重复
3. 键和值是一一对应的，每一个键只能找到自己对应的值
4. 键+值这个整体我们称之为“键值对”或者“键值对对象”，在Java中叫做“Entry对象”

Map的常见API

Map是双列集合的顶层接口，它的功能是全部双列集合都可以继承使用的

方法名称	说明
V put(K key，V value)	添加元素，键相同时会覆盖值
V remove(0bject key)	根据键删除键值对元素，返回值
void clear()	移除所有的键值对元素
boolean containsKey(0bject key)	判断集合是否包含指定的键
boolean containsValue(Objectvalue)	判断集合是否包含指定的值
boolean isEmpty()	判断集合是否为空
int size()	集合的长度， 也就是集合中键值对的个数

代码演示 

import java.util.HashMap;
import java.util.Map;

public class Test1 {
    public static void main(String[] args) {
       
        //创建集合，有两个泛型，一个是键的，一个是值的
        Map<String, String> m = new HashMap<>();

        //添加元素
        m.put("甄嬛", "菀嫔");
        m.put("乌拉那拉", "皇后");
        m.put("年世兰", "华妃");
        System.out.println(m);//{年世兰=华妃, 甄嬛=菀嫔, 乌拉那拉=皇后}

        //键相同时会覆盖值，并返回被覆盖的值
        System.out.println(m.put("甄嬛", "熹妃"));//菀嫔
        System.out.println(m);//{年世兰=华妃, 甄嬛=熹妃, 乌拉那拉=皇后}

        //根据键删除键值对元素，返回值
        System.out.println(m.remove("乌拉那拉"));//皇后

        //判断集合是否包含指定的键
        System.out.println(m.containsKey("乌拉那拉"));//false
        System.out.println(m.containsKey("甄嬛"));//true

        //判断集合是否包含指定的值
        System.out.println(m.containsValue("皇后"));//false
        System.out.println(m.containsValue("熹妃"));//true

        //集合的长度
        System.out.println(m.size());//2

        //移除所有的键值对元素
        m.clear();

        //判断集合是否为空
        System.out.println(m.isEmpty());//true

    }
}

Map的遍历方式

键找值

先用keySet方法获取所有的键，再遍历键，用键找值

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

public class Test2 {
    public static void main(String[] args) {

        Map<String, String> m = new HashMap<>();

        m.put("甄嬛", "菀嫔");
        m.put("乌拉那拉", "皇后");
        m.put("年世兰", "华妃");

        //获取所有键
        Set<String> keys = m.keySet();

        //通过键找值
        for (String key : keys) {
            String value = m.get(key);
            System.out.println(key +" = "+ value);
        }
        //年世兰 = 华妃
        //甄嬛 = 菀嫔
        //乌拉那拉 = 皇后
    }
}

键值对

先通过entrySet方法获取键值对对象，再通过getKey和getValue方法分别获取键和值

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

public class Test3 {
    public static void main(String[] args) {

        Map<String, String> m = new HashMap<>();

        m.put("甄嬛", "菀嫔");
        m.put("乌拉那拉", "皇后");
        m.put("年世兰", "华妃");

        //获取所有键值对，该集合存入的数据是键值对对象，泛型是Entry，
        //而键值对对象里的第一个元素是String类型，第二个元素也是String类型
        //所以有如下泛型的嵌套
        Set<Map.Entry<String, String>> entries = m.entrySet();

        //遍历获取键和值
        for (Map.Entry<String, String> entry : entries) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + " = " + value);
        }
        //年世兰 = 华妃
        //甄嬛 = 菀嫔
        //乌拉那拉 = 皇后

    }
}

Lambda表达式

方法名称	说明
default void forEach(BiConsumer ...)	结合lambda遍历

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class Test4 {
    public static void main(String[] args) {

        Map<String, String> m = new HashMap<>();

        m.put("甄嬛", "菀嫔");
        m.put("乌拉那拉", "皇后");
        m.put("年世兰", "华妃");

        m.forEach(new BiConsumer<String, String>() {
            @Override
            public void accept(String key, String value) {
                //第一个形参代表键，第二个形参代表值
                System.out.println(key + " = " + value);
            }
        });
        //年世兰 = 华妃
        //甄嬛 = 菀嫔
        //乌拉那拉 = 皇后

        //Lambda表达式
        m.forEach((key, value) -> System.out.println(key + " = " + value));
        //年世兰 = 华妃
        //甄嬛 = 菀嫔
        //乌拉那拉 = 皇后

    }
}