Java基础学习之Map（18-4）

lyy_sss

于 2022-03-30 19:48:23 发布

阅读量320

点赞数

分类专栏： Java学习文章标签： java

本文链接：https://blog.csdn.net/lyy_sss/article/details/123804117

版权

Java学习专栏收录该内容

45 篇文章 0 订阅

订阅专栏

1.Map

Map集合

Interface Map<K,V> 是一个接口，K：键的类型；V：值的类型
将键映射到值的对象；不能包含重复的键；每个键可以映射到最多一个值

创建Map集合的对象

由于Map是一个接口，不能直接实例化，因此采用多态的方式
具体实现类HashMap

package Java18.Map.map1;

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

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

        //V put(K key,V value)将指定的值与该映射中的指定键相关联（可选操作）。
        map.put("001","lyy");
        map.put("002","lyq");
        map.put("003","jus");
        map.put("004","lyy");
        //当键重复时，值会吧键以前的值替代调，即键第一次出现时，put是添加元素；后面继续出现时，put则是修改元素
        map.put("004","fqy");
        
        //  HashMap重写了toString方法，把键和值用等于号拼接起来
        System.out.println(map);
    }
}

1.1 Map集合的基本功能

在这里插入图片描述

package Java18.Map.map1;

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

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

        //添加键值对
        map.put("001","lyy");
        map.put("002","lyq");
        map.put("003","dy");
        map.put("004","fqy");

        System.out.println(map);
        System.out.println("---------------");

        //根据键删除键值对元素
        map.remove("004");
        System.out.println(map);
        System.out.println("------------------");

        //判断集合是否包含指定键
        System.out.println(map.containsKey("002"));
        //判断集合是否包含指定值
        System.out.println(map.containsValue("lyy"));

        //集合长度
        System.out.println(map.size());

        //移除所有键值对元素
        map.clear();
        System.out.println(map);

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

    }
}

1.2 Map集合的获取功能

在这里插入图片描述

package Java18.Map.map1;

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

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

        //添加键值对
        map.put("001","lyy");
        map.put("002","lyq");
        map.put("003","dy");
        map.put("004","fqy");

        //根据键获取值
        System.out.println(map.get("003"));

        //获取所有键的集合,Set集合中不含重复元素
        Set<String> keySet = map.keySet();
        for(String k : keySet){
            System.out.println(k);
        }

        System.out.println("_____________");
        //获取所有值的方法
        Collection<String> values = map.values();
        for (String v:values){
            System.out.println(v);
        }
    }
}

1.3 Map集合的遍历方式

方式1：

把所有键集中起来（获取所有键的集合，用keySet()方法实现）
遍历键的集合，获取到每一个键（增强for）
根据键去找值（用get（key）方法实现）

package Java18.Map.map1;

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

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

        //添加键值对
        map.put("001","lyy");
        map.put("002","lyq");
        map.put("003","dy");
        map.put("004","fqy");

        //遍历操作,获取所有的键
        Set<String> key = map.keySet();
        //增强for遍历所有键
        for (String k:key){
            //根据键去找值
            String value = map.get(k);
            System.out.println(k+","+value);
        }

    }
}

方式2：

获取所有键值对对象的集合（Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合）
遍历键值对对象的集合，得到每一个键值对对象（用增强for实现，得到每一个Map.Entry）
根据键值对对象获取键和值（用getKey()得到键，用getValue()得到值）

package Java18.Map.map1;
//        - 获取所有键值对对象的集合（Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合）
//        - 遍历键值对对象的集合，得到每一个键值对对象（用增强for实现，得到每一个Map.Entry）
//        - 根据键值对对象获取键和值（用getKey()得到键，用getValue()得到值）

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

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

        //添加键值对
        map.put("001","lyy");
        map.put("002","lyq");
        map.put("003","dy");
        map.put("004","fqy");

        //获取所有键值对对象集合
        Set<Map.Entry<String,String>> KV = map.entrySet();
        //增强for遍历键值对
        for(Map.Entry<String,String> kv:KV){
            String key = kv.getKey();
            String value = kv.getValue();
            System.out.println(key+","+value);
        }
        
    }
}

案例：使用HashMap存储学生学号及学生信息，其中键对应学号，值对应学生信息，并遍历

学生类存储学生信息

package Java18.Map.map1;

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

测试类

package Java18.Map.map1;


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

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

        //创建集合对象
        Student s1 = new Student("lyy",23);
        Student s2 = new Student("dy",22);
        Student s3 = new Student("lyq",23);

        //把学生添加到集合
        hm.put("001",s1);
        hm.put("002",s2);
        hm.put("003",s3);

        //遍历集合方式1键找值
        //获取键集合
        Set<String> key = hm.keySet();
        //遍历键集合
        for(String k:key){
            //获取键所对应的值
            Student s = hm.get(k);
            System.out.println("学号："+k+"姓名："+s.getName()+"年龄："+s.getAge());
        }
        System.out.println("-----------------");

        //方式2
        //获取键值对
        Set<Map.Entry<String,Student>> sm = hm.entrySet();
        //遍历键值对
        for(Map.Entry<String,Student> ss:sm){
            //获取键值对中的键
            String number = ss.getKey();
            //获取键值对中的值
            Student s = ss.getValue();

            System.out.println("学号："+number+"姓名："+s.getName()+"年龄："+s.getAge());
        }

    }
}

案例2：创建一个HashMap集合，键是学生对象（Student），值是居住地（String）。存储多个键值对元素，并遍历。要求保证键的唯一性：如果学生对象的成员变量值相同，我们就认为是同一个对象

学生类中重写HashCode和equals方法

package Java18.Map.map2;

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

案例3：ArrayList集合存储HashMap元素并遍历

package Java18.Map.map2;

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

public class demo {
    public static void main(String[] args) {
        //创建ArrayList集合
        ArrayList<HashMap<String,String>> array = new ArrayList<HashMap<String,String>>();

        //创建HashMap集合
        HashMap<String,String> hm1 = new HashMap<String,String>();
        //添加键值对元素
        hm1.put("孙策","大乔");
        hm1.put("周瑜","小乔");
        //把HashMap作为元素添加到ArrayList集合中
        array.add(hm1);

        HashMap<String,String> hm2 = new HashMap<String,String>();
        //添加键值对元素
        hm2.put("郭靖","黄蓉");
        hm2.put("杨过","小龙女");
        //把HashMap作为元素添加到ArrayList集合中
        array.add(hm2);

        HashMap<String,String> hm3 = new HashMap<String,String>();
        //添加键值对元素
        hm3.put("令狐冲","任盈盈");
        hm3.put("林平之","岳灵珊");
        //把HashMap作为元素添加到ArrayList集合中
        array.add(hm3);

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

HashMap集合中嵌套ArrayList集合

package Java18.Map.map2;

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

public class demo2 {
    public static void main(String[] args) {
        HashMap<String, ArrayList<String>> hm = new HashMap<String, ArrayList<String>>();

        //创建ArrayList集合，并添加元素
        ArrayList<String> sgyy = new ArrayList<String>();
        sgyy.add("zhugeliang");
        sgyy.add("zhaoyun");
        //吧ArrayList作为元素添加到HashMap
        hm.put("三国演义", sgyy);

        ArrayList<String> xyj = new ArrayList<String>();
        xyj.add("sunwukong");
        xyj.add("tangsanzang");
        //吧ArrayList作为元素添加到HashMap
        hm.put("西游记", xyj);

        ArrayList<String> shz = new ArrayList<String>();
        shz.add("luzhishen");
        shz.add("wusong");
        //吧ArrayList作为元素添加到HashMap
        hm.put("水浒传", shz);

        //遍历
        //获取键
        Set<String> key = hm.keySet();
        for (String k : key) {
            System.out.println(k);
            //遍历ArrayList
            Iterator<String> it = hm.get(k).iterator();
            while (it.hasNext()) {
                String s = it.next();
                System.out.println(s);
            }
            //或者
/*        for (String k:key){
            System.out.println(k);
            ArrayList<String> array = hm.get(k);
            for(String a:array){
                System.out.println(a);
            }
        }*/

        }
    }
}

遍历字符串

package Java18.Map.map3;

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

public class demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串");
        String s =sc.nextLine();

        //创建HashMap
        HashMap<Character,Integer> hm = new HashMap<Character,Integer>();

        //遍历字符串
        for(int i=0;i<s.length();i++){
            char key = s.charAt(i);

            //得到的每一个字符作为键到HashMap集合中去找对应的值，看起返回值
            Integer value = hm.get(key);
            if(value == null){
                //返回值null，说明该字符HashMap集合中不存在，就把该字符作为键，1作为存储值
                hm.put(key,1);
            }else{
                //返回值不是null，说明该字符HashMap集合中存在，该值加1，然后重新存储字符和对应值
                value++;
                hm.put(key,value);
            }
        }
        //遍历集合，按照要求进行拼接
        StringBuilder sb = new StringBuilder();

        Set<Character> keySet = hm.keySet();
        for (Character k:keySet){
            Integer value = hm.get(k);
            sb.append(k).append("(").append(value).append(")");
        }
        String result = sb.toString();

        System.out.println(result);
    }
}