Map系列集合

已于 2024-07-13 16:28:35 修改
阅读量1.1k 收藏 28
点赞数 26
分类专栏： JAVA 文章标签： java 开发语言
于 2024-07-13 16:09:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65752158/article/details/140381606
版权

1.Map集合

1.1Map集合概述和特点

Map集合概述

interface Map<K,V>  K：键的类型；V：值的类型

  • Map集合的特点

    • 双列集合,一个键对应一个值

    • 键不可以重复,值可以重复

Map集合的基本使用

public class MapDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

        //V put(K key, V value) 将指定的值与该映射中的指定键相关联
        map.put("itheima001","林青霞");
        map.put("itheima002","张曼玉");
        map.put("itheima003","王祖贤");
        map.put("itheima003","柳岩");

        //输出集合对象
        System.out.println(map);
    }
}

发现有二个itheima003，之前说过键和值是一 一对应关系，且键不可以重复，值可以重复

itheima003（键）重复了，所以没有打印出来，从上到下覆盖

1.2Map集合的基本功能

方法介绍

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

package Map;

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

/*
  put(K key,V   value)                | 添加元素                             |
| remove(Object key)                  | 根据键删除键值对元素                 |
| void   clear()                      | 移除所有的键值对元素                 |
| boolean containsKey(Object key)     | 判断集合是否包含指定的键             |
| boolean containsValue(Object value) | 判断集合是否包含指定的值             |
| boolean isEmpty()                   | 判断集合是否为空                     |
| int size()                          | 集合的长度，也就是集合中键值对的个数 |
 */
public class demo2 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<>();
        //V put(K key,V value)：添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "张三");
        String value1 = map.put("杨过", "小龙女");
        //2.添加元素
        //put方法的细节：
        //添加/覆盖
        //在添加数据的时候，如果键不存在，那么直接把键值对对象添加到map集合当中,方法返回null
        //在添加数据的时候，如果键是存在的，那么会把原有的键值对对象覆盖，会把被覆盖的值进行返回。
        System.out.println(value1);//如果键是存在的，那么会把原有的键值对对象覆盖，会把被覆盖的值进行返回。
        String value2 = map.put("王五", "小龙女");
        System.out.println(value2);//null 如果键不存在，那么直接把键值对对象添加到map集合当中,方法返回null

        //删除
        boolean result = map.remove("郭靖", "黄蓉");
        System.out.println(result);
        //清空
        //map.clear();

        //判断是否包含
        boolean keyresult = map.containsKey("郭靖");
        System.out.println(keyresult);

        boolean valueresult = map.containsValue("小龙女");
        System.out.println(valueresult);
        int size = map.size();
        System.out.println(size);

        //3.打印集合
        System.out.println(map);


    }
}

1.3Map集合的获取功能

方法介绍

方法名说明
V get(Object key)根据键获取值
Set<K> keySet()获取所有键的集合
Collection<V> values()获取所有值的集合
Set<Map.Entry<K,V>> entrySet()获取所有键值对对象的集合

方法1（遍历）

把所有的键存储再单列集合里面，然后通过键找到与之对应的值，通过get方法获取值即可 

  • 遍历思路

    • 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合

      • 把所有的丈夫给集中起来

      • 遍历丈夫的集合，获取到每一个丈夫

      • 根据丈夫去找对应的妻子

  • 步骤分析

    • 获取所有键的集合。用keySet()方法实现

    • 遍历键的集合，获取到每一个键。用增强for实现

      • 根据键去找值。用get(Object key)方法实现

 

package Map;

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

public class demo3 {
    public static void main(String[] args) {
        //map的第一种遍历方式
        //1.创建map集合对象
        Map<String, String> map = new HashMap<>();
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");
        //2.通过键找值
        //2.1 获取所有的键，把这些键放入单列集合当中
        Set<String> keySet = map.keySet();
        //2.2遍历单列集合，得到每一个键;
        for (String s : keySet) {
            //System.out.println(s);
            //2.3 利用Map集合中的键获取对应的值 Get
            String value = map.get(s);
            System.out.println(s + "=" + value);
        }
    }
}

方法2（遍历）

  • 遍历思路

    • 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合

      • 获取所有结婚证的集合

      • 遍历结婚证的集合，得到每一个结婚证

      • 根据结婚证获取丈夫和妻子

  • 步骤分析

    • 获取所有键值对对象的集合

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

      • 遍历键值对对象的集合，得到每一个键值对对象

        • 用增强for实现，得到每一个Map.Entry

    • 根据键值对对象获取键和值

      • 用getKey()得到键

      • 用getValue()得到值

 

获取getkey方法和getvalue方法

//通过键值对对象进行遍历
//3.1通过一个方法获取所有的键值对对象 ，返回一个Set集合
//获取getkey方法和getvalue方法即可
Set<Map.Entry<String, String>> entries = m.entrySet();
//3.2遍历entries这个集合，去得到里面的每一个键值对对象

 第二种方法的lambda表达式

package Map;

import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

public class demo4 {
    public static void main(String[] args) {
        //map的第二种遍历方式
        Map<String, String> m = new HashMap<>();
        m.put("张无忌", "赵敏");
        m.put("郭靖", "黄蓉");
        m.put("杨过", "小龙女");
        //通过键值对对象进行遍历
        //3.1通过一个方法获取所有的键值对对象 ，返回一个Set集合
        //获取getkey方法和getvalue方法即可
        Set<Map.Entry<String, String>> entries = m.entrySet();
        //3.2遍历entries这个集合，去得到里面的每一个键值对对象
        //1.增强for
        /*for (Map.Entry<String, String> entry : entries) {
            System.out.println(entry.getKey() + "=" + entry.getValue());
        }*/
 //entry 第一次循环的时候代表的是张无忌", "赵敏这个键值对对象，以此类推
        //迭代器
        /*Iterator<String> it= m.keySet().iterator();
        while(it.hasNext()){
            String key = it.next();
            String value = m.get(key);
            System.out.println(key+"="+value);
        }*/

        //lambda表达式
  //方法的底层其实就是利用增强for进行遍历，依次得到每一个键和值
        //再调用accept方法
        m.forEach(( s1,  s2)-> System.out.println(s1+"="+s2));

    }
}

2.HashMap集合

2.1HashMap集合概述和特点

  • HashMap底层是哈希表结构的

  • 依赖hashCode方法和equals方法保证键的唯一

  • 如果键要存储的是自定义对象，需要重写hashCode和equals方法

练习1

package HashMap;

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

public class demo1 {
    public static void main(String[] args) {
        HashMap<Student, String> m = new HashMap<>();
        Student s1 = new Student("张三", 18);
        Student s2 = new Student("李四", 20);
        Student s3 = new Student("王五", 19);
        m.put(s1, "湖北省");
        m.put(s2, "重庆");
        m.put(s3, "江苏省");
       /* //获取迭代器对象
        //迭代器对象好比是一个指针,默认指向集合的0索引处
        Iterator<Student> it = m.keySet().iterator();
        // 利用循环不断的去获取集合中的每一个元素
        while (it.hasNext()) {
            //next方法的二件事情:获取指针指向的元素并且移动指针
            Student key = it.next();//键
            String value = m.get(key);//值
            System.out.println(key + "\t" + value);
        }*/

       /* //增强for方法1
        //先获取所有键的对象
        Set<Student> keys = m.keySet();//遍历单列集合，得到每一个键;
        for (Student key : keys) {
            String value = m.get(key);//根据键去找值
         System.out.println(key + "\t" + value);
        }*/
        //增强for方法2
        for (Map.Entry<Student, String> entry : m.entrySet()) {//获取所有键值对对象的集合
            //遍历键值对对象的集合，得到每一个键值对对象--entry
            Student key = entry.getKey();//利用entry对象去获取键
            String value = entry.getValue();//利用entry对象去获取值
            System.out.println(key + "\t" + value);
        }

    }
}

因为要求是说的键，键存储的是自定义对象，所以要重写方法 

package HashMap;

import java.util.Objects;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{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);
    }
}

练习2

package HashMap;

import java.util.*;

public class demo2 {
    public static void main(String[] args) {
        //定义一个数组存储景点
        String[] arr = {"A", "B", "C", "D"};
        //创建一个集合存储学生投票选择的景点
        ArrayList<String> list = new ArrayList<>();

        Random r = new Random();
        for (int i = 0; i < 80; i++) {
            int index = r.nextInt(arr.length);
            //把学生随机投的票存入集合当中
            list.add(arr[index]);
        }
        //利用map集合统计景点次数
        HashMap<String, Integer> map = new HashMap<>();
        for (String s : list) {
            //map集合里面存在学生头的景点
            boolean containsKey = map.containsKey(s);
            int count = 0;
            //判断map集合里面是否包含该景点
            if (containsKey) {
                //存在count++;
                //先获取当前景点已经被投了多少次数
                count = map.get(s);
                //当前景点又被投了一次
                count++;
                //把当前景点加新的次数再次添加到map集合当中
                map.put(s, count);

            } else {
                //不存在count为1
                map.put(s, 1);
            }

        }
        //求次数最多的景点
        int max=0;
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            String key = entry.getKey();
            int count = entry.getValue();
            if(count>max){
                max=count;
            }
            System.out.println(key+":"+count);

        }
        //判断哪个景点的次数跟最大值一样，一样就打印出来
        for (Map.Entry<String, Integer> entry : entries) {
            String key = entry.getKey();
            int count = entry.getValue();
            if(count==max){
                System.out.println(key);
            }

        }
        
    }
}

3.LinkedHashMap集合

package LinkedHashMap;

import java.util.LinkedHashMap;

public class demo1 {
    public static void main(String[] args) {
  /*
           LinkedHashMap:
               由键决定：
                   有序、不重复、无索引。
               有序：
                   保证存储和取出的顺序一致
               原理：
                   底层数据结构是依然哈希表，只是每个键值对元素又额外的多了一个双链表的机制记录存储的顺序。
         */
        LinkedHashMap<String, Integer> lhm = new LinkedHashMap<>();
        lhm.put("c", 001);
        lhm.put("b", 002);
        lhm.put("a", 001);
        System.out.println(lhm);
        //存取顺序一致
    }
}

4.TreeMap集合

package TreeMap;
import java.util.Set;
import java.util.TreeMap;

public class demo1 {
    public static void main(String[] args) {
    //            采取第二种排序方式：比较器排序  因为第一种方法是默认升序,所以不能满足需求
        //Integer Double 默认情况下都是按照升序排列的
        //String 按照字母再ASCII码表中对应的数字升序进行排列
        TreeMap<Integer, String> tm1 = new TreeMap<>((o1, o2) -> o1 - o2);
        //o1是当前要添加的元素,
        //o2表示红黑树中存在的元素
        tm1.put(1, "可乐");
        tm1.put(3, "雪碧");
        tm1.put(2, "红牛");
        //要求1 按照id的升序排列;
        method01(tm1);
        System.out.println("-----------");
        //要求2 按照id降序排列
        TreeMap<Integer, String> tm2 = new TreeMap<>((o1, o2) -> o2 - o1);
        tm2.put(1, "可乐");
        tm2.put(3, "雪碧");
        tm2.put(2, "红牛");
        method01(tm2);
    }

    private static void method01(TreeMap<Integer, String> tm) {
        //获取所有的键,并存入单列集合当中
        Set<Integer> keys = tm.keySet();
        //遍历单列集合,得到每一个键(id) 升序
        for (Integer key : keys) {
            String value = tm.get(key);
            System.out.println(key+"--"+value);
        }
    }
}


   @Override
    public int compareTo(Student o) {
        //要求: 按照学生的年龄排序,年龄一样按照姓名和字母排序,同姓名和年龄视为同一个人
//this表示当前要添加的元素
//o表示红黑树存在的元素
//返回值:
//负数: 认为要添加的元素在左边
//正数:认为要添加的元素在右边
//0:认为要添加的元素存在,舍弃
        int tmp=this.getAge()-o.getAge();
        tmp= tmp==0? this.getName().compareTo(o.getName()):tmp;
        return tmp;
    }
package TreeMap;

import java.util.TreeMap;

public class demo2 {
    public static void main(String[] args) {
        Student s1 = new Student("zhangsan", 18);
        Student s2 = new Student("lisi", 17);
        Student s3 = new Student("wangwu", 20);
        TreeMap<Student, String> tm = new TreeMap<>();
        tm.put(s1, "湖北省");
        tm.put(s3, "广东省");
        tm.put(s2, "江苏省");
        //要求: 按照学生的年龄排序,年龄一样按照姓名和字母排序,同姓名和年龄视为同一个人
        System.out.println(tm);


    }
}


package TreeMap;

import java.util.*;
  //利用map集合来添加字符出现的次数
        /*
        新的统计思想,如果题目没有要求对结果排序默认使用HaShMap
        如果有排序就使用TreeMap 因为 a(5) b(4) c(3) d(2) e(1)按照Ascll码值排好了
         */
public class demo3 {
    public static void main(String[] args) {
      String str="aababcabcdabcde";
        char[] arr = str.toCharArray();
        ArrayList<Character> list = new ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            list.add(arr[i]);
        }
        //利用map集合来添加字符出现的次数
        TreeMap<Character, Integer> tm = new TreeMap<>();
        for (char s : list) {//遍历每一个键
            //判断tm集合里面是否存在字符
            if (tm.containsKey(s)) {
                //存在count++;
                int count = 0;
                //先获取当前字符已经出现了多少次数
                count = tm.get(s);
                //当前字符又出现一次
                count++;
                tm.put(s, count);
            } else {
                //不存在count为1
                tm.put(s, 1);
            }
        }
        Set<Map.Entry<Character, Integer>> entries = tm.entrySet();
        for (Map.Entry<Character, Integer> entry : entries) {
            char key = entry.getKey();
            int value = entry.getValue();
            System.out.print(key +"("+ value+")"+" ");
        }
    }
}

 TreeMap<Character, Integer> tm = new TreeMap<>();
        for (int i = 0; i < str.length(); i++) {
            char s = str.charAt(i);//得到每一个键(字符)
            //判断tm集合里面是否存在字符
            if (tm.containsKey(s)) {
                //存在count++;
                int count = 0;
                //先获取当前字符已经出现了多少次数
                count = tm.get(s);
                //当前字符又出现一次
                count++;
                tm.put(s, count);
            } else {
                //不存在count为1
                tm.put(s, 1);
            }
        }

什么叫不能满足默认排序规则

如:需要要降序,或者按照字符长度来排序等,这种情况才使用第二种排序规则

林的快手
关注
专栏目录
Map系列的遍历方式与Map系列集合及集合的嵌套
z2775640561的博客
11-17 653
如果键存储的是自定义类型的对象，也可以通过重写HashCode和equals方法，也可以保证多个对象内容一样时，LinkedHashMa集合就能认为是重复的。·如果键存储的是自定义类型的对象，可以通过重写HashCode和equals方法，这样可以保证多个对象内容一样时，HashMa集合就能认为是重复的。实际上：原来学的Set系列集合的底层就是基于Map实现的，只是Set集合中的元素只要键数据，不要值数据而已。2.原理：TreeMap跟TreeSet集合的底层原理是一样的，都是基于红黑树实现的排序。
集合框架Map系列集合
2303_80469270的博客
11-25 922
原理：底层数据结构依然是基于哈希表实现的，只是每个键值对元素又额外的多了一个双链表机制记录元素顺序。1.HashMap的底层原理：跟HashSet的底层原理是一模一样的，都是基于哈希表实现的。1.原理：TreeMap跟TreeSet集合的底层原理是一样的，都是基于红黑树实现的排序。2.TreeMap集合同样也支持两种方式来指定排序规则。先获取Map集合全部的键，再通过遍历键来找值。3.HashMap底层是基于哈希表实现的。4.HashMap如何实现键的唯一性。把“键值对”看成一个整体进行遍历。
JAVA基础：map系列集合
weixin_65346668的博客
08-15 1358
我们之前说map系列的集合每个元素存储的是一对数据我们称为键值对，其中键（key）的值是无序，没有索引，不能重复的。值（value）的值是无序，可重复的，没有索引的，我们上一次学习的set集合其实就是使用了map集合，我们常用的map集合有HashMap ， TreeMap ， Hashtable。
Set系列集合和Map系列集合
Ninelife19的博客
02-04 103
Set系列集合和Map系列集合
进阶JAVA篇- Map 系列集合的遍历方法与常用API
小扳手
10-23 908
使用keySet()方法遍历：通过Map的keySet()方法获取所有的键，然后使用for-each循环遍历键，并通过get()方法获取对应的值。使用entrySet()方法遍历：通过Map的entrySet()方法获取所有的键值对的Entry对象，然后使用for-each循环遍历Entry对象，通过getKey()和getValue()方法获取键和值。使用forEach()方法遍历（Java 8+）：通过Map的forEach()方法，传入一个BiConsumer函数接口来遍历键值对。
Map系列集合：概述
qq_53452521的博客
03-01 346
TreeMap:按照大小默认升序排序，不重复，无索引。LinkedHashMap 有序，不重复，无索引。HashMap无序，不重复，无索引。
Map集合体系
weixin_52943417的博客
02-10 785
话不多呗，咱直接上干货（此篇文章内容过于干燥，这边建议大家准备点水！！1.Map集合是一种双列集合，每个元素包含两个数据key=value（键值对元素）3.Map集合也称为“键值对集合”。Map集合的知识点到这里就结束啦！希望此笔记能对那些想步入IT行业和新手码农来说，提供一些微薄的帮助。
Map系列集合：常用方法
qq_53452521的博客
03-01 397
【代码】Map系列集合：常用方法。
Java集合—Map系列集合（习题二）
Java技术加油站的博客
08-28 394
4.现在有一个map集合如下： Map map = new HashMap(); map.put(1, "张三丰"); map.put(2, "周芷若"); map.put(3, "汪峰"); map.put(4, "灭绝师太"); 要求： (1)遍历集合，并将序号与对应人名打印。 (2)向该map集合中插入一个编码为5姓名为李晓红的信息
es6系列教程_ Map详解以及常用api介绍
08-29
Map中还有很多其他的方法，例如：has()方法用来判断键名是否存在，delete()方法用来删除键名以及对应的值，clear()方法用来移除map集合中所有的键值对:size属性用来获取map集合的元素个数。例如：let map = new Map...
【攻克java集合系列（四）】java集合中的Map系列集合全面分析
1+1=王的博客
12-06 1084
之前所介绍的List、Set、Queue系列集合都是由Collection派生出来的，今天我们来分析java集合的另一个分支——Map集合。 文章目录Map系列集合中的继承实现关系Map集合简介Map接口源码分析接口方法默认实现的方法Map.EntryHashMap、TreeMap与HashTableHashMapTreeMapHashTableHashMap、TreeMap、HashTable、LinkedHashMap之间的比较 Map系列集合中的继承实现关系 建议大家先看完本文再回过头来思考这张图。
【JavaSE系列】Java集合框架之Collection,Map接口
未见花闻的博客
01-16 1337
本篇文章带大家认识Java基础知识——集合框架，从本篇文章开始正式拉开数据结构的序幕，要深入了解一件事，那必然先得见个面，本文带大家认识Java集合框长什么样，以及怎么使用Collection和Map接口。
集合篇---Map集合
weixin_42107106的博客
09-20 396
Map系列概述
Java-网络
最新发布
2301_81543552的博客
09-14 456
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
上传文件到钉盘流程详解
jspyth的博客
09-14 492
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Java集合：Stack详解
yang_brother的博客
09-10 603
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
Java wrapperr打包springboot项目到linux和Windows
欢迎查阅
09-14 808
测试启动就是点击App.bat 就会有信息的输出 installApp就是注册为一个windows上的一个服务。上图文件复制的地方 全部复制过去 保留自己需要的 然后去掉后缀.in。下载：linux的目前免费的 windows 64位的好像收费的。前提： 一定要有Java环境（我使用的是jdk1.8）解压的目录，然后我们新建自己的项目目录java-jsw。前面是你解压的原文件 后边是你自己建的目录路径。步骤和上面的一样 不过复制的文件不一样。下载一个社区版本的应该就够用了。需要注意的点 有Java环境。
C#基础（11）函数重载
a6s686的博客
09-12 824
我们通过这些例子的学习，想毕你一定已经掌握了函数重载的相关内容，我相信你只要稍加练习，便能达到很熟练的程度。不过不管知识点难或者简单，还是那句话，学习路上，戒骄戒躁，脚踏实地。请期待我的下一篇博客！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值