Map接口

最新推荐文章于 2021-02-21 17:04:59 发布
最新推荐文章于 2021-02-21 17:04:59 发布
阅读量164 收藏 2
点赞数
文章标签： java
原文链接：http://www.itheima.com/
版权

在这里插入图片描述

1. 概述

现实生活中，我们常会看到这样的一种集合：IP地址与主机名，身份证号与个人，系统用户名与系统用户对象等，这种一一对应的关系，就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象，即java.util.Map接口。

我们通过查看Map接口描述，发现Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同，如下图。

Collection 和 Map 的区别

  • Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。
  • Map中的集合，元素是成对存在的（理解为夫妻）。每个元素由键与值两部分组成，通过键可以找对所对应的值。
  • Collection中的集合称为单列集合，Map中的集合称为双列集合。
  • Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

特点

java.util.Map<k,v>集合

  1. Map集合是一个双列集合，一个元素包含两个值(一个key,一个value)
  2. Map集合中的元素，key和value的数据类型可以相同，也可以不同
  3. Map集合中的元素，key是不可以重复的，value可以
  4. Map集合中的元素，key和value是一一对应的

2. 常用实现类

通过查看Map接口描述，看到Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。

由于保证的键的唯一、不重复，需要重写hashCode()方法、equals()方法。

特点

HashMap集合

java.util.HashMap<k,v>集合 implements Map<k,v>接口

  1. 底层是哈希表:查询的速度特别的快

    JDK1.8之前:数组+单向链表

    JDK1.8之后:数组+单向链表|红黑树(链表的长度超过8):提高查询的速度

  2. 是一个无序的集合,存储元素和取出元素的顺序有可能不一致

LinkedHashMap集合

java.util.LinkedHashMap<k,v>集合 extends HashMap<k,v>集合

  1. 底层是哈希表+链表(保证迭代的顺序)
  2. 是一个有序的集合，保证元素的存取顺序一致

3. Map接口常用方法

Map接口中定义了很多方法，常用的如下：

  • public V put(K key, V value): 把指定的键与值添加到Map集合中。

  • public V remove(Object key): 删除集合中指定的键所对应的键值对元素，返回被删除元素的值。

  • public V get(Object key) ：获取集合中指定的键对应的值。

  • boolean containsKey(Object key) 判断集合中是否包含指定的键。

  • public Set<K> keySet(): 获取Map集合中所有的键（key），存储到Set集合中。

    可以结合getKey方法取value，即遍历Map集合。

  • public Set<Map.Entry<K,V>> entrySet(): 获取Map集合中所有的键值对对象的集合(Set集合)。

方法演示

1. map.put()：把指定的键和值添加到Map集合中。

返回值：V

存储键值对的时候：

  • key不重复，返回值是 null

  • key重复，会使用新的value替换map中重复的value，并返回被替换的value值

代码：

 private static void show01() {
        // 创建Map集合对象，多态
        Map<String,String> map = new HashMap<>();
        String v1 = map.put("李晨", "范冰冰1");
        System.out.println(v1);  // null
        String v2 = map.put("李晨", "范冰冰2");
        System.out.println(v2); 
        System.out.println(map); 

        map.put("冷锋", "龙小云");
        map.put("杨过", "小龙女");
        map.put("尹志平", "小龙女");
        System.out.println(map); 
    }

结果：

null
范冰冰1
{李晨=范冰冰2}
{杨过=小龙女, 尹志平=小龙女, 李晨=范冰冰2, 冷锋=龙小云}
2. map.remove()： 删除指定的键对应的键值对元素，返回被删除元素的值。

返回值:V

  • key存在，返回被删除的值

  • key不存在，返回 null

    private static void show02() {
        // 创建Map集合对象，多态
        Map<String,Integer> map = new HashMap<>();
        map.put("赵丽颖",168);
        map.put("杨颖",165);
        map.put("林志玲",178);
        System.out.println(map);  // {林志玲=178, 赵丽颖=168, 杨颖=165}

        //Integer v1 = map.remove("林志玲");
        System.out.println(v1);  // 178
        System.out.println(map);  // {赵丽颖=168, 杨颖=165}

        //int v2 = map.remove("林志颖");  //自动拆箱  但是空值不能赋值给int类型 空指针异常
        Integer v2 = map.remove("光头强"); // 但是可以赋值给包装类
        System.out.println(v2);  // null，没有这个key
        System.out.println(map);  // {赵丽颖=168, 杨颖=165}

    }

结果：

{林志玲=178, 赵丽颖=168, 杨颖=165}
178
{赵丽颖=168, 杨颖=165}
null
{赵丽颖=168, 杨颖=165}
3. map.get()：在Map集合中获取对应的值

返回值:V

  1. key存在，返回对应的value值
  2. key不存在，返回 null
    private static void show03() {
        //创建Map集合对象
        Map<String,Integer> map = new HashMap<>();
        map.put("赵丽颖",168);
        map.put("杨颖",165);
        map.put("林志玲",178);

        Integer v1 = map.get("杨颖");
        System.out.println("v1:"+v1);

        Integer v2 = map.get("迪丽热巴");
        System.out.println("v2:"+v2);
    }

结果：

v1:165
v2:null
4. map.contains()：判断集合中是否包含指定的键

返回值：

  • 包含返回true
  • 不包含返回false
    private static void show04() {
        //创建Map集合对象
        Map<String,Integer> map = new HashMap<>();
        map.put("赵丽颖",168);
        map.put("杨颖",165);
        map.put("林志玲",178);

        boolean b1 = map.containsKey("赵丽颖");
        System.out.println("b1:"+b1);

        boolean b2 = map.containsKey("赵颖");
        System.out.println("b2:"+b2);
    }

结果：

b1:true
b2:false

4. Entry：键值对对象

Map.Entry<K,V>在Map接口中有一个内部接口Entry，当Map集合一创建，在Map集合中会创建一个Entry对象，也叫做键值对对象，用来记录键与值（键与值的映射关系）。

我们已经知道，Map中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在在Map中是一一对应关系，这一对对象又称做Map中的一个Entry(项)。

Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值得方法：

  • public K getKey()：获取Entry对象中的键。
  • public V getValue()：获取Entry对象中的值。

在Map集合中也提供了获取所有Entry对象的方法：

  • public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

5. Map集合遍历

第一种：遍历键找值方式

键找值方式：即通过元素中的键，获取键所对应的值

  • public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
分析步骤
  1. 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示:keyset()
  2. 遍历键的Set集合，得到每一个键。
  3. 根据键，获取键所对应的值。方法提示:get(K key)
HashMap<String, String> map = new HashMap<String,String>();
        Set<String> set = map.keySet();  
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            String key = it.next();
            String value = map.get(key);
            System.out.println(key + ":" + value);
        }

代码演示：

public class MapDemo01 {
    public static void main(String[] args) {
        //创建Map集合对象 
        HashMap<String, String> map = new HashMap<String,String>();
        //添加元素到集合 
        map.put("胡歌", "霍建华");
        map.put("郭德纲", "于谦");
        map.put("薛之谦", "大张伟");

        //获取所有的键  获取键集
       // 1
        Set<String> set = map.keySet();
        // 2
        System.out.println("=========迭代器=========");
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            String key = it.next();
            String value = map.get(key);
            System.out.println(key + ":" + value);
        }
        System.out.println("===========增强for=======");
        for (String key : set) {
            String value = map.get(key);
            System.out.println(key + ":" + value);
        }
        System.out.println("===========增强for=======");
        for (String key : map.keySet()) { // Set<String> set = map.keySet();
            String value = map.get(key);
            System.out.println(key + ":" + value);
        }
    }
}

结果：

郭德纲:于谦
薛之谦:大张伟
胡歌:霍建华
====================
郭德纲:于谦
薛之谦:大张伟
胡歌:霍建华
====================
郭德纲:于谦
薛之谦:大张伟
胡歌:霍建华

遍历图解：

第二种：遍历键值对方式

键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。

操作步骤
  1. 获取Map集合中，所有的键值对对象，以Set集合形式返回。方法：entrySet()。
  2. 遍历Set集合,获取每一个Entry对象
  3. 获取Entry对象中的键与值。 方法：getkey() getValue()
 Map<String,Integer> map = new HashMap<>();     
        Set<Map.Entry<String, Integer>> set = map.entrySet();
       Iterator<Map.Entry<String, Integer>> it = set.iterator();
        while (it.hasNext()) {
            Map.Entry<String, Integer> entry = it.next();
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key+ ":" +value);
        }
注意

Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了

代码：

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

public class Demo03EntrySet {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();
        map.put("赵丽颖",168);
        map.put("杨颖",165);
        map.put("林志玲",178);
        // 1
        Set<Map.Entry<String, Integer>> set = map.entrySet();
        // 2
        System.out.println("=========迭代器=========");
        Iterator<Map.Entry<String, Integer>> it = set.iterator();
        while (it.hasNext()) {
            //  Map.Entry<String, Integer>: entry的变量类型
            Map.Entry<String, Integer> entry = it.next();
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key+ ":" +value);
        }
        System.out.println("===========增强for=======");
        // 3
        for (Map.Entry<String, Integer> entry : set) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key+ "=" +value);
        }
        System.out.println("===========增强for=======");
        // 4
        for (Map.Entry<String, Integer> entry :  map.entrySet()) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key+ "*" +value);
        }
    }
}

结果：

林志玲:178
赵丽颖:168
杨颖:165
=====================
林志玲=178
赵丽颖=168
杨颖=165
=====================
林志玲*178
赵丽颖*168
杨颖*165

遍历图解：

6. HashMap存储自定义类型键值

每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。

注意，学生姓名相同并且年龄相同视为同一名学生。

前提：保证key唯一

  • 保证key元素唯一，必须重写hashCode方法和equals方法

  • 如果要保证map中存放的key和取出的顺序一致，可以使用java.util.LinkedHashMap集合来存放。

代码：

编写学生类：

public class Student {
    private String name;
    private int age;
    
	@Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o)
            return true;
        if (o == null || getClass() != o.getClass())
            return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
    // ...
}

编写测试类：

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

public class Demo01HashMapSavePerson {
    public static void main(String[] args) {
        show01();
        show02();
    }

    /*
        HashMap存储自定义类型键值
        key:Person类型
            Person类就必须重写hashCode方法和equals方法,以保证key唯一
        value:String类型
            可以重复
     */
    private static void show02() {
        //创建HashMap集合
        HashMap<Person,String> map = new HashMap<>();
        //往集合中添加元素
        map.put(new Person("女王",18),"英国");
        map.put(new Person("秦始皇",18),"秦国");
        map.put(new Person("普京",30),"俄罗斯");
        map.put(new Person("女王",18),"毛里求斯");
        //使用entrySet和增强for遍历Map集合
        Set<Map.Entry<Person, String>> set = map.entrySet();
        for (Map.Entry<Person, String> entry : set) {
            Person key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"-->"+value);
        }
    }

    /*
        HashMap存储自定义类型键值
        key:String类型
            String类重写hashCode方法和equals方法,保证key唯一
        value:Person类型
            value可以重复(同名同年龄的人视为同一个)
     */
    private static void show01() {
        //创建HashMap集合
        HashMap<String,Person> map = new HashMap<>();
        //往集合中添加元素
        map.put("北京",new Person("张三",18));
        map.put("上海",new Person("李四",19));
        map.put("广州",new Person("王五",20));
        map.put("北京",new Person("赵六",18));
        //使用keySet加增强for遍历Map集合
        Set<String> set = map.keySet();
        for (String key : set) {
            Person value = map.get(key);
            System.out.println(key+"-->"+value);
        }
         System.out.println("===================================");
    }
}

结果：

上海-->Person{name='李四', age=19}
广州-->Person{name='王五', age=20}
北京-->Person{name='赵六', age=18}
===================================
Person{name='女王', age=18}-->毛里求斯
Person{name='秦始皇', age=18}-->秦国
Person{name='普京', age=30}-->俄罗斯

7. LinkedHashMap集合

我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的。

在HashMap下面有一个子类LinkedHashMap，它是链表和哈希表组合的一个数据存储结构。而且可以保证map中存放的key和取出的顺序一致。

特点

java.util.LinkedHashMap<K,V> entends HashMap<K,V>

Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。

底层原理：哈希表+链表(记录元素的顺序)

代码：

import java.util.HashMap;
import java.util.LinkedHashMap;

public class Demo01LinkedHashMap {
    public static void main(String[] args) {
        HashMap<String,String> map = new HashMap<>();
        map.put("a","a");
        map.put("c","c");
        map.put("b","b");
        map.put("a","d");
        System.out.println(map);// key不允许重复,无序

        LinkedHashMap<String,String> linked = new LinkedHashMap<>();
        linked.put("a","a");
        linked.put("c","c");
        linked.put("b","b");
        linked.put("a","d");
        System.out.println(linked);// key不允许重复,有序
    }
}

结果:

{a=d, b=b, c=c}
{a=d, c=c, b=b}

8. Hashtable 【了解】

java.util.Hashtable<K,V>集合 implements Map<K,V>接口

与HashMap对比

HashMap 【JDK 1.2才有的】

  • 多线程集合，速度快，线程不安全

  • 底层是哈希表

  • 键和值都可以为空（null），【之前学的所有集合都可为空】

Hashtable 【JDK 1.0】

  • 单线程集合，速度慢，线程安全

  • 键和值都不允许为空

  • Hashtable和Vector集合一样，在【jdk1.2】版本之后被更先进的集合HashMap,ArrayList取代

  • 子类Properties集合是一个唯一和IO流相结合的集合

代码：

import java.util.HashMap;
import java.util.Hashtable;

public class Demo02Hashtable {
    public static void main(String[] args) {
        HashMap<String,String> map = new HashMap<>();
        map.put(null,"a");
        map.put(null,null);
        map.put("b",null);
        System.out.println(map);

        Hashtable<String,String> table = new Hashtable<>();
        //table.put(null,"a"); // NullPointerException
        //table.put("b",null); // NullPointerException
        table.put(null,null); // NullPointerException
    }
}

结果：

{null=null, b=null}

9. Map集合案例

计算一个字符串中每个字符出现次数。

分析：

  1. 获取一个字符串对象

  2. 创建一个Map集合，键代表字符，值代表次数。

  3. 遍历字符串得到每个字符。

  4. 判断Map中是否有该键。

  5. 如果没有，第一次出现，存储次数为1；如果有，则说明已经出现过，获取到对应的值进行++，再次存储。

  6. 打印最终结果

代码：

import java.util.HashMap;
import java.util.Scanner;
/*
    练习:
        计算一个字符串中每个字符出现次数

    分析:
        1.使用Scanner获取用户输入的字符串
        2.创建Map集合,key是字符串中的字符,value是字符的个数
        3.遍历字符串,获取每一个字符
        4.使用获取到的字符,去Map集合判断key是否存在
            key存在:
                通过字符(key),获取value(字符个数)
                value++
                put(key,value)把新的value存储到Map集合中
            key不存在:
                put(key,1)
        5.遍历Map集合,输出结果
 */
public class Demo01MapTest {
    public static void main(String[] args) {
        // 1
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串:");
        String str = sc.next();

        // 2
        HashMap<Character,Integer> map = new HashMap<>();

        // 3
        for (char c : str.toCharArray()) {
            // 4
            if (map.containsKey(c)) {
                Integer value = map.get(c);
                value++;
                map.put(c,value); // 新的value
            } else {
                map.put(c,1);
            }
        }
        // 5
        for (Character key : map.keySet()) {
            Integer value = map.get(key);
            System.out.println(key + " 出现了 " + value + " 次");
        }
    }
}

结果：

请输入一个字符串:
xcvaafaasdaads
a 出现了 6 次
c 出现了 1 次
s 出现了 2 次
d 出现了 2 次
v 出现了 1 次
f 出现了 1 次
x 出现了 1 次
LiuszZZ
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java map 接口_Java集合框架总结（5）——Map接口的使用
weixin_30969227的博客
02-19 88
Map用于保存具有映射关系的数据(key-vlaue)。Map的key不允许重复，即同一个Map对象的任何两个key通过equals方法比较总是返回falseMap中包含了一个keySet()方法，用于返回Map所以key组成的Set集合。Map集合与Set集合元素的存储形式很像，如Set接口下有HashSet、LinkedHashSet、SortedSet(接口)、TreeSet、EnumSet...
Java集合框架 ——Map接口
Racheil的博客
04-21 330
一、Map接口概述 Map接口是由一系列键值对组成的集合，提供了key到value之间的映射，并且不能存在相同的key值，value值可以相同。 Map接口继承关系： Map接口提供对一个值的集合与一个键的规则集进行查询、更新和读取等方法： 方法 描述 public V put(K key, V value); 向Map中添加数据 public V get(Ob...
Java Map接口及其实现类原理解析
08-19
Java Map接口及其实现类原理解析 Java Map接口是Java集合框架中的一种重要接口，它提供了键值对的存储和管理机制。Map接口的实现类有很多，包括HashMap、TreeMap、LinkedHashMap等，每种实现类都有其特点和使用场景...
Map接口整合
09-29
java.util.map接口，Java集合框架，hashmap、LinkedHashMap
List接口和Map接口
03-14
### List接口和Map接口详解 #### 一、Java集合框架概览 Java集合框架是Java标准库的一个核心组成部分，用于处理各种数据结构如列表、集合和映射等。该框架提供了一组统一的接口和实现，使开发人员能够高效地管理和...
Map接口的使用1
12-22
//Map没有规定泛型的类型，默认为Object Map players = new HashMap(); players.put("30", "Curry"); players.put("35", "Durant"); // 加入一个key为11（String类型），value为Thompson（String类型）的元素
手写简单的Map接口实现
weixin_43888267的博客
04-13 198
public interface Map<K,V> { V put(K k, V v); V get(K k); int size(); interface Entry<K,V> { K getKey(); V getValues(); } } public class HashMap&lt...
JAVA SE基础提要--13：Map接口（集合）
ATFWUS的博客
02-25 321
0x01.相关概念 映射：一一对应的关系。 java.util.Map接口是java专门提供的集合类，用来存放对象关系的对象。 Collection中的集合称为单列集合，Map中的集合称为双列集合。 Collection中的集合，元素是孤立存在的，向集合中存储元素采用一个个元素的方式存储。 Map中的集合，元素是成对存在的。每个元素由键与值两部分组成，通过键可以找对所对应的值。 Map中的集合不...
Map接口简介
chen404897439的博客
07-02 685
package cn.dali2.code14; /*Map接口：Map<K,V> * 类型参数： * K：此映射所维护的键的类型 * V：映射值的类型 * public interface Map<K,V> * 将键映射到值的对象，一个映射不可以包含重复的键，每个键最多映射一个值。 * 特点： * 键不可以重复，值可以重复 * 键和值一一对...
JAVA集合——Map接口常用方法总结以及循环遍历
gitets的博客
11-16 314
一.Map接口存储的是 一组成对的键（key）和值（value）对象，提供key到value的映射，主要是通过key来进行检索，因为key的要求是无序但是要唯一，而value也是无序，但是可以重复，所以就只能通过key来进行索引； 二.Map接口的常用方法： 1.添加数据，成对添加Object put (Object key,Object value),这里的key和value的类型可以为任何类型！ //Map接口中的key不要求有序，但是不能重复，重复就会被覆盖； //但是Map中的valu
java map返回值_Java NavigableMap ceilingKey()用法及代码示例
weixin_34055346的博客
02-21 328
Java中NavigableMap接口的ceilingKey()方法用于返回大于或等于给定键的最小键；如果不存在这样的键，则返回null。用法：K ceilingKey(K key)其中，K是此映射容器维护的Key的类型。参数：它接受单个参数Key，该参数是要映射的 key ，并且属于此collection接受的 key 类型。返回值：返回大于或等于给定键的最小键；如果不存在这样的键，则返回nul...
Java Map接口基本用法
python_god的博客
11-21 296
Java Map接口 java.util.Map 接口 查找表 ‘’’ Map 体现的结构是一个多行两列的表格,左列称为key 右列称为value. Map 总是根据key来获取对应的value.因此保存数据 时是成对保存的,并且应当将查询的数据作为value 查询条件作为key进行保存. Map要求key 不允许重复(equals 比较判定) 常用的实现类 java.util.HashMa...
Map接口及其常用方法
不动声色的小蜗牛的博客
04-13 445
Map集合基于键(key)和值(value)的映射，每个键只能映射一个值，也就是说key不可以重复（当然喽，重复的话就按最后一个为准）。键和值都可以是任何引用数据类型的值；且一对键值的存放是无序的。 Map常用的实现类有HashMap、LinkedHashMap、Properties。 这里以HashMap实现类为例演示Map接口方法： package gather; import java.ut...
hashmap的api
奔跑的蜗牛蒋
11-09 6925
方法摘要 void clear()  从此映射中移除所有映射关系（可选操作）。 boolean containsKey(Object key)  如果此映射包含指定键的映射关系，则返回 true。 boolean containsValue(Object value)  如果此映射将一个或多个键映射到指定值，则返回 true。
java实现map接口
最新发布
06-13
Java中的Map接口是用来存储键值对的，常用的实现类有HashMap、TreeMap、LinkedHashMap等。下面以HashMap为例，介绍如何实现Map接口。 首先定义一个HashMap对象： ```java Map, Integer> map = new HashMap(); ``` ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值