集合——Map

最新推荐文章于 2024-11-05 19:36:08 发布

wxk1241

最新推荐文章于 2024-11-05 19:36:08 发布

阅读量144

点赞数 1

分类专栏：集合文章标签： java intellij-idea

本文链接：https://blog.csdn.net/wxk1241/article/details/119759705

版权

集合专栏收录该内容

6 篇文章 0 订阅

订阅专栏

本文详细介绍了Java HashMap的数据结构、核心特性、常用方法，如put、remove、clear等，并通过实例演示了如何遍历和操作键值对。重点涵盖了键值唯一性、值的覆盖规则以及不同场景下的使用技巧。

摘要由CSDN通过智能技术生成

Map

1. 概述 & 特点

1.1 概述

将键映射到值得对象
具体的实现类：HashMap
```
Interface Map<K,V>
```
K： key 键的类型
V： value 值得类型

1.2 特点

键值对映射关系
一个键只能对应一个值
键不可以重复，值可以重复
当存储重复的键时，后存储的键对应的值覆盖前存储键对应的值
元素存储无序

2. 基本使用<代码示例>

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

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

        //添加元素
        //键是唯一的
        map.put("66666666","小笨蛋");
        map.put("77777777","超聪明");
        System.out.println(map); //{77777777=超聪明, 66666666=小笨蛋}
        
        //当键重复的时候，我们的值会把之前的值替换掉
        map.put("77777777","超笨蛋");
        System.out.println(map);//{77777777=超笨蛋, 66666666=小笨蛋}
    }
}

3. 常用方法

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

3.1 put() & remove()

import java.util.HashMap;
import java.util.Map;
// V put(K key,V value) 添加元素
// V remove(Object key) 根据键删除键值对元素
public class Demo {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

        //put 添加元素
        map.put("哈哈","呵呵");
        map.put("嘻嘻","吼吼");
        map.put("噜噜","叽叽");
        //输出集合
        System.out.println(map); //{哈哈=呵呵, 嘻嘻=吼吼, 噜噜=叽叽}
        
        //remove 根据键删除键值对元素，返回的是对应值
        System.out.println(map.remove("哈哈")); //呵呵
        //没有键对应的值 返回 null
        System.out.println(map.remove("哈呵")); // null
        System.out.println(map); //{嘻嘻=吼吼, 噜噜=叽叽}
    }
}

3.2 clear() & isEmpty()

import java.util.HashMap;
import java.util.Map;
// void clear() 移除所有的键值对元素
// boolean isEmpty() 判断集合是否为空
public class Demo {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

        //put 添加元素
        map.put("哈哈","呵呵");
        map.put("嘻嘻","吼吼");
        map.put("噜噜","叽叽");
        //输出集合
        System.out.println(map); //{哈哈=呵呵, 嘻嘻=吼吼, 噜噜=叽叽}
        
        // clear 移除所有的键值对元素
        map.clear(); // {}
        System.out.println(map);
        // isEmpty 判断集合是否为空
        System.out.println(map.isEmpty()); //ture

    }
}

3.3 containsKey() & containsValue()

import java.util.HashMap;
import java.util.Map;
// boolean containsKey(Object key) 判断集合是否包含指定的键
// boolean containsValue(Object value) 判断集合是否包含指定的值
public class Demo {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

        //put 添加元素
        map.put("哈哈","呵呵");
        map.put("嘻嘻","吼吼");
        map.put("噜噜","叽叽");
        //输出集合
        System.out.println(map); //{哈哈=呵呵, 嘻嘻=吼吼, 噜噜=叽叽}

        //containsKey 判断是否包含指定的 键
        System.out.println(map.containsKey("哈哈")); //true
        System.out.println(map.containsKey("呜呜")); //false

        //containsValue 判断是否包含指定的 值
        System.out.println(map.containsValue("呵呵")); //ture
        System.out.println(map.containsValue("哈哈")); //false

    }
}

3.4 size()

import java.util.HashMap;
import java.util.Map;
// int size() 获取集合的长度，也就是集合中键值对的个数
public class Demo {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

        //put 添加元素
        map.put("哈哈","呵呵");
        map.put("嘻嘻","吼吼");
        map.put("噜噜","叽叽");
        //输出集合
        System.out.println(map); //{哈哈=呵呵, 嘻嘻=吼吼, 噜噜=叽叽}

        //size 判断长度
        System.out.println(map.size()); //3
    }
}

3.5 get()

import java.util.HashMap;
import java.util.Map;
// V get(Object key) 根据键获取值
public class Demo {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

        //put 添加元素
        map.put("哈哈","呵呵");
        map.put("嘻嘻","吼吼");
        map.put("噜噜","叽叽");
        //输出集合
        System.out.println(map); //{哈哈=呵呵, 嘻嘻=吼吼, 噜噜=叽叽}

        //get 根据键 返回值
        System.out.println(map.get("哈哈")); //呵呵
        System.out.println(map.get("呵呵")); //null
    }
}

3.6 keySet()

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
// Set<K> keySet() 获取所有键的集合
public class Demo {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

        //put 添加元素
        map.put("哈哈","呵呵");
        map.put("嘻嘻","吼吼");
        map.put("噜噜","叽叽");
        //输出集合
        System.out.println(map); //{哈哈=呵呵, 嘻嘻=吼吼, 噜噜=叽叽}

        //keySet 获取集合中所有键
        Set<String> ks = map.keySet(); //[哈哈, 嘻嘻, 噜噜]
        //遍历
        for (String k : ks) {
            System.out.println(k);
        }
    }
}

3.7 values()

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

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

        //put 添加元素
        map.put("哈哈","呵呵");
        map.put("嘻嘻","吼吼");
        map.put("噜噜","叽叽");
        //输出集合
        System.out.println(map); //{哈哈=呵呵, 嘻嘻=吼吼, 噜噜=叽叽}

        //values 获取所有值
        Collection<String> values = map.values(); //[呵呵, 吼吼, 叽叽]
        //遍历
        for (String s : values) {
            System.out.println(s);
        }
    }
}

3.8 entrySet()

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
// Set<Map.Entry<K,V>> entrySet() 获取所有键值对对象的集合
public class Demo {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

        //put 添加元素
        map.put("哈哈","呵呵");
        map.put("嘻嘻","吼吼");
        map.put("噜噜","叽叽");
        //输出集合
        System.out.println(map); //{哈哈=呵呵, 嘻嘻=吼吼, 噜噜=叽叽}

        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        System.out.println(entrySet); //{哈哈=呵呵, 嘻嘻=吼吼, 噜噜=叽叽}
    }
}

4. 遍历Map集合

4.1 方法一

首先获取所有键的集合
遍历键的集合
再通过键获取对应值

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

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

        //put 添加元素
        map.put("哈哈","呵呵");
        map.put("嘻嘻","吼吼");
        map.put("噜噜","叽叽");
        System.out.println(map);
        //获取所有的键值
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            //通过键获取值
            String value = map.get(key);
            //输出
            System.out.println(key + "，" + value);
        }
    }
}

4.2 方法二

获取所有键值对对象的集合
遍历键值对对象的集合，得到每一个键值的对象
根据键值对对象获取键和值

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

/*
1. 获取所有键值对对象的集合
2. 遍历键值对对象的集合，得到每一个键值的对象
3. 根据键值对对象获取键和值
 */
public class Demo05 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

        //put 添加元素
        map.put("哈哈","呵呵");
        map.put("嘻嘻","吼吼");
        map.put("噜噜","叽叽");
        System.out.println(map);

        //获取所有键值对对象的集合
        Set<Map.Entry<String, String>> entrySet = map.entrySet();

        for (Map.Entry<String, String> s : entrySet) {
            //根据键值对对象获取键和值
            String key = s.getKey();
            String value = s.getValue();
            System.out.println(key + "，" + value);
        }
    }
}

5. 案例<代码示例>

5.1 V为Student类型

测试类

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

//HashMap遍历存储学生对象并遍历
/*
1. 定义学生类
2. 创建HashMap集合
3. 创建学生对象
4. 把学生添加到集合
5. 遍历集合
   方式1 ： 键找值
   方式2 ： 键值对对象找键和值
 */
public class Test01 {
    public static void main(String[] args) {
        HashMap<String,Student> hm = new HashMap<>();

        //创建学生对象
        Student s1 = new Student("王一",16);
        Student s2 = new Student("王二",17);
        Student s3 = new Student("王三",18);

        hm.put("001",s1);
        hm.put("002",s2);
        hm.put("003",s3);

        //遍历 方式1：键找值
        Set<String> keySet = hm.keySet();
        for (String s : keySet) {
            Student value = hm.get(s);
            System.out.println(s + "," + value.getName() + "," + value.getAge());
        }


        //遍历 方式2：键值对对象找键和值
        Set<Map.Entry<String, Student>> entrySet = hm.entrySet();
        for (Map.Entry<String, Student> s : entrySet) {
            String key = s.getKey();
            Student value = s.getValue();
            System.out.println(key + "," + value.getName() + "," + value.getAge());
        }
    }
}

学生类

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

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

5.2 K为Student类型

测试类

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

/*
1.定义学生类
2.创建HashMap集合对象
3.创建学生类
4.把学生添加到集合
5.遍历集合
6.在学生类中重写 equals() and hashCode()
 */
public class Test {
    public static void main(String[] args) {
        //创建HashMap集合对象
        HashMap<Student,String> hm = new HashMap<>();

        //创建学生对象
        Student s1 = new Student("王一",30);
        Student s2 = new Student("王二",31);
        Student s3 = new Student("王三",33);
        Student s4 = new Student("王三",33);

        hm.put(s1,"福建");
        hm.put(s2,"湖北");
        hm.put(s3,"湖南");
        hm.put(s4,"北京"); //键相同，值覆盖

        //遍历集合
        Set<Student> keySet = hm.keySet();
        for (Student key : keySet) {
            String value = hm.get(key);
            System.out.println(key.getName() + "," + key.getAge() + "," + value);
        }
    }
}

学生类

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;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    //这里需要重写 equals() and hashCode() 以保证键唯一性
    //利用Alt + Insert 自动生成重写
    @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);
    }
}

5.3 ArrayList集合存储HashMap元素并遍历

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

//ArrayList集合存储HashMap元素并遍历
/*
1. 创建ArrayList集合
2.创建HashMap集合，并添加键值对元素
3.把HashMap作为元素添加到ArrayList集合
4.遍历ArrayList集合
 */
public class Test {
    public static void main(String[] args) {
        //创建ArrayList集合对象 对象为HashMap类型
        ArrayList<HashMap<String,String>> arr = new ArrayList<>();
        //创建HashMap集合对象 并添加元素
        HashMap<String,String> hm1 = new HashMap<>();
        hm1.put("王一","何一");
        hm1.put("王二","何二");
        arr.add(hm1);
        HashMap<String,String> hm2 = new HashMap<>();
        hm2.put("王三","何三");
        hm2.put("王四","何四");
        arr.add(hm2);
        HashMap<String,String> hm3 = new HashMap<>();
        hm3.put("王五","何五");
        hm3.put("王六","何六");
        arr.add(hm3);
        
        //遍历ArrayList集合
        for (HashMap<String, String> hm : arr) {
            //获取HashMap所有的键
            Set<String> keySet = hm.keySet();
            for (String key : keySet) {
                //通过键得到值
                String value = hm.get(key);
                System.out.println(key + "," + value);
            }
        }
    }
}

5.4 HashMap集合存储ArrayList元素并遍历

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
/*
1.创建HashMap集合
2.创建ArrayList集合，并添加元素
3.把ArrayList添加到HashMap
4.遍历HashMap
*/
public class Test {
    public static void main(String[] args) {
        //创建HashMap集合 键为String类型 值为 ArrayList类型
        HashMap<String, ArrayList<String>> hm = new HashMap<>();
        //创建ArrayList集合 并添加元素
        ArrayList<String> arr1 = new ArrayList<>();
        arr1.add("哈哈哈");
        arr1.add("呵呵呵");
        hm.put("笑", arr1);
        ArrayList<String> arr2 = new ArrayList<>();
        arr2.add("呜呜呜");
        arr2.add("嘤嘤嘤");
        hm.put( "哭", arr2);
        //获取所有的键
        Set<String> keySet = hm.keySet();
        for (String key : keySet) {
            System.out.println(key);
            //通过键获取值
            ArrayList<String> value = hm.get(key);
            //遍历ArrayList集合
            for (String arr : value) {
                System.out.println(arr);
            }
        }

    }
}

5.5 统计字符串中每个字符出现的次数

import java.util.*;

// 统计字符串中每个字符出现的次数
/*
1.键盘录入一个字符串
2.创建HashMap集合，键是Character，值是Integer
3.遍历字符串，得到每一个字符
4.拿得到的没一个字符串作为键到HashMap集合中去找对应的值，看其返回值
     如果返回值是null：说明该字符在HashMap集合中不存在，就把该字符作为键，1作为储存值
     如果返回值不是null，说明该字符在HashMap集合中存在，把该值加1，然后重新存储该字符和对应的值
5.遍历HashMap集合，得到键和值，按照要求进行拼接
 */
public class Test01 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s = sc.nextLine();
        HashMap<Character, Integer> hm = new HashMap<>();
        //注意区别HashMap和TreeMap的区别
        //TreeMap<Character, Integer> hm = new TreeMap<>(); //TreeMap 有序输出
        for (int i = 0; i < s.length(); i++) {
            char key = s.charAt(i);
            Integer value = hm.get(key);
            if (value == null){
                hm.put(key,1);
            }else{
                value++;
                hm.put(key,value);
            }
        }
        //通过StringBuilder连接字符串
        StringBuilder sb = new StringBuilder();

        Set<Character> keySet = hm.keySet();
        for (Character key : keySet) {
            Integer value = hm.get(key);
            sb.append(key).append("(").append(value).append(")");
        }
        //将StringBuilder类型转换成String类型
        String result = sb.toString();

        System.out.println("字符串出现次数的统计结果为：\n" + result);
    }
}