0
点赞
收藏
分享

微信扫一扫

java:Map接口

IT影子 2022-02-20 阅读 163
java蓝桥杯开发语言

 Map

Map接口的概述

将键映射到值的对象。 Map不能包含重复的键; 每个键可以映射到最多一个值。

举例： <K,V> 键值对 1001 王宇 1002 周家祥 1001 周家祥（不允许） Map集合中，K的值不能重复

Map接口与Collection接口有什么区别？

1、Map接口与Collection接口是平级关机，不存在继承关系，都是属于util包下面的

2、Map集合中的元素都是成对出现的，Map集合中的键是唯一的，值是可以重复的 又称之为：夫妻对

3、Collection集合中的元素都是单独出现的，Collection接口下面有个子接口Set，它的元素也是唯一的 List中的元素也是单独出现，可以重复，像这样单独出现的元素，称之为：光棍

Map接口中的方法：

1、添加功能： V put(K key, V value) 将指定的值与该映射中的指定键相关联（可选操作）。

举例：map.put(1001,"王宇");

2、删除功能： void clear() 从该Map中删除所有的映射（可选操作）。

V remove(Object key) 如果存在（从可选的操作），从该Map中删除一个键的映射。

3、判断功能：

boolean containsKey(Object key) 如果此映射包含指定键的映射，则返回 true 。

boolean containsValue(Object value) 如果此地图将一个或多个键映射到指定的值，则返回 true 。 boolean isEmpty() 如果此地图不包含键值映射，则返回 true 。

4、获取功能：

V get(Object key) 返回到指定键所映射的值，或 null如果此映射包含该键的映射。

Set<K> keySet() 返回此Map中包含的键的Set视图。

Collection<V> values() 返回此Map中包含的值的Collection视图

Set<Map.Entry<K,V>> entrySet() 获取Map中所有元素，元素的类组成是由一个键和一个值组成

5、长度功能： int size() 返回此Map中键值映射的数量。

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

        //创建Map集合对象
        //由于Map是一个接口，所以接口不能直接实例化，要使用一个具体的子类进行实例化
        //这里借助HashMap
        Map<String,String> map = new HashMap<>();

        //添加元素
        //V put(K key, V value) 将指定的值与该映射中的指定键相关联（可选操作）。
        //这里的返回值是将来再次插入同一个键的时候，被覆盖的那个值
//        System.out.println(map.put("黄晓明","杨颖"));
//        System.out.println(map.put("邓超","孙俪"));
//        System.out.println(map.put("小虎","冯提莫"));
//        System.out.println(map.put("小虎","IU"));
        map.put("黄晓明","杨颖");
        map.put("邓超","孙俪");
        map.put("小虎","冯提莫");
        map.put("小虎","IU");

        //删除功能
        //void clear() 从该Map中删除所有的映射（可选操作）。
//        map.clear();
//        V remove(Object key) 如果存在（从可选的操作），从该Map中删除一个键的映射。
        //返回对应删除的值
//        System.out.println(map.remove("小虎"));
        System.out.println("==========================================");
        //boolean containsKey(Object key) 如果此映射包含指定键的映射，则返回 true 。
        System.out.println(map.containsKey("小虎"));
        //boolean containsValue(Object value) 如果此地图将一个或多个键映射到指定的值，则返回 true 。
        System.out.println(map.containsValue("IU"));
        System.out.println(map.isEmpty());
        System.out.println("==========================================");
        
        System.out.println("==========================================");
        System.out.println(map);
    }
}

 Map集合的获取功能：

V get(Object key) 返回到指定键所映射的值，或 null如果此映射包含该键的映射。

Set<K> keySet() 返回此Map中包含的键的Set视图。

Collection<V> values() 返回此Map中包含的值的Collection视图

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

        //向集合中添加元素
        map.put("黄晓明", "杨颖");
        map.put("邓超", "孙俪");
        map.put("小虎", "冯提莫");
        map.put("张杰", "谢娜");

        //V get(Object key) 返回到指定键所映射的值，或 null如果此映射包含该键的映射。
        //根据key找值
        //如果map中不包含此key，返回null
        System.out.println(map.get("小虎"));
        System.out.println(map.get("明旺"));
        System.out.println("===============================================");
        //Set<K> keySet() 返回此Map中包含的键的Set视图。
        Set<String> set = map.keySet();
        for (String s : set) {
//            System.out.println(s);
            String value = map.get(s);
            System.out.println(s + ":" + value);
        }

        //Collection<V> values() 返回此Map中包含的值的Collection视图
        Collection<String> values = map.values();
        for (String s : values) {
            System.out.println(s);
        }


    }
}

 集合遍历的方式一：根据键找值

1、通过调用keySet()方法获取Map集合中所有的key

2、结合get(key)这个方法，可以获取到每一个key对应的value

3、输出

public class MapDemo3 {
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<>();

        //向集合中添加元素
        map.put("霞", "洛");
        map.put("蛮王", "寒冰");
        map.put("卢锡安", "塞纳");
        map.put("盖伦", "卡特");

        //通过调用keySet()方法获取Map集合中所有的key
        Set<String> keySet = map.keySet();

        //遍历keySet获取到每一个key
        for (String s : keySet) {
            String value = map.get(s);
            System.out.println(s + ":" + value);
        }


    }
}

 Map集合遍历的第二种方式：

一次先把所有的键值对获取到，然后在依次获取每一个键值对的key和value

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

        //2、向集合中添加元素
        map.put("王子1", "白雪公主");
        map.put("王子2", "灰姑凉");
        map.put("王子3", "美人鱼");

        //遍历：一次先把所有的键值对获取到
        //Set<Map.Entry<K,V>> entrySet() 获取Map中所有元素，元素的类组成是由一个键和一个值组成
        Set<Map.Entry<String, String>> set = map.entrySet();

        //遍历集合获取每一个键值对
        for (Map.Entry<String, String> keyValue : set) {
            String key = keyValue.getKey();
            String value = keyValue.getValue();
            System.out.println(key + ":" + value);
        }


    }
}

HashMap<Integer,String>

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

        //2、向集合中添加元素
        map.put(1001, "明旺");
        map.put(1002, "王宇");
        map.put(1003, "周家祥");
        map.put(1003, "张保桂");

        //遍历集合
        System.out.println("===========方式1：根据键找值===================");
        //获取到所有的key
        Set<Integer> set = map.keySet();
        for (Integer i : set) {
            String s = map.get(i);
            System.out.println(i + ":" + s);
        }

        System.out.println("==========方式2：根据键值对找键和值===============");
        Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
        for (Map.Entry<Integer, String> keyValue : entrySet) {
            Integer key = keyValue.getKey();
            String value = keyValue.getValue();
            System.out.println(key + ":" + value);
        }


    }
}

HashMap<String,Student>

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

        //2、创建学生对象
        Student4 s1 = new Student4("明旺", 18);
        Student4 s2 = new Student4("王宇", 17);
        Student4 s3 = new Student4("周家祥", 19);
        Student4 s4 = new Student4("张保桂", 19);

        //3、向集合中添加键值对
        map.put("帅气男孩", s1);
        map.put("亿表人财", s2);
        map.put("油腻大叔", s3);
        map.put("忧郁男孩", s4);

        Set<Map.Entry<String, Student4>> entries = map.entrySet();
        for (Map.Entry<String, Student4> keyValue : entries) {
            String key = keyValue.getKey();
            Student4 value = keyValue.getValue();
            System.out.println(key + ":" + value);
        }

    }
}
public class Student4 {
    private String name;
    private int age;

    public Student4() {
    }

    public Student4(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 String toString() {
        return "Student4{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

HashMap<Student,String>

如果key是自己自定义的一个对象，该类需要重写hashCode()方法和equals()方法
因为put方法的底层，添加元素的标准就是根据hashCode()方法和equals()的值来判断元素是否重复

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

        //2、创建学生对象
        Student5 s1 = new Student5("王昭君", 17);
        Student5 s2 = new Student5("貂蝉", 16);
        Student5 s3 = new Student5("杨玉环", 18);
        Student5 s4 = new Student5("西施", 19);
        Student5 s5 = new Student5("王昭君", 17);

        //将元素添加到集合中
        map.put(s1, "1111");
        map.put(s2, "2222");
        map.put(s3, "3333");
        map.put(s4, "4444");
        map.put(s5, "5555");

        //遍历
        Set<Map.Entry<Student5, String>> entries = map.entrySet();
        for (Map.Entry<Student5, String> keyValue : entries) {
            Student5 key = keyValue.getKey();
            String value = keyValue.getValue();
            System.out.println(key + ":" + value);
        }


    }
}
import java.util.Objects;

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

    public Student5() {
    }

    public Student5(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;
        Student5 student5 = (Student5) o;
        return age == student5.age && Objects.equals(name, student5.name);
    }

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

    @Override
    public String toString() {
        return "Student4{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

ArrayList嵌套HashMap

public class ArrayListAndHashMap {
    public static void main(String[] args) {
        //定义一个ArrayList对象
        ArrayList<HashMap<String, String>> list = new ArrayList<>();

        //创建2个HashMap对象
        HashMap<String, String> map1 = new HashMap<>();
        map1.put("霞", "洛");
        map1.put("卢锡安", "塞纳");
        map1.put("蛮王", "寒冰");
        map1.put("盖伦", "卡特");

        HashMap<String, String> map2 = new HashMap<>();
        map2.put("邓超", "孙俪");
        map2.put("张杰", "谢娜");
        map2.put("小虎", "冯提莫");

        list.add(map1);
        list.add(map2);

        //遍历
        for (HashMap<String, String> maps : list) {
            Set<Map.Entry<String, String>> entries = maps.entrySet();
            for (Map.Entry<String, String> keyValue : entries) {
                String key = keyValue.getKey();
                String value = keyValue.getValue();
                System.out.println(key + ":" + value);
            }
        }

    }
}

TreeMap:

键是基于红黑树结构存储的
键：String
值：String

public class TreeMapDemo1 {
    public static void main(String[] args) {
        //1、创建集合对象
        TreeMap<String, String> map = new TreeMap<>();

        //创建元素并添加到集合中
        map.put("hello", "你好");
        map.put("world", "世界");
        map.put("java", "面向对象的编程语言");
        map.put("mysql", "结构化数据库");

        //遍历：
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> keyValue : entries) {
            String key = keyValue.getKey();
            String value = keyValue.getValue();
            System.out.println(key + ":" + value);
        }
    }
}

TreeMap<Student,String>

 键：Student 键的存储是红黑树结构存储，可以保证键的排序和唯一

 值：String

public class TreeMapDemo2 {
    public static void main(String[] args) {
        //1、创建TreeMap对象
//        TreeMap<Student6, String> map = new TreeMap<>();
        //推荐使用比较器排序，并且用匿名内部类实现
        TreeMap<Student6, String> map = new TreeMap<>(new Comparator<Student6>() {
            @Override
            public int compare(Student6 o1, Student6 o2) {
                //        return 0;
                //判断年龄是否一样
                int i = o1.getAge() - o2.getAge();
                //年龄一样。姓名不一定一样
                int i2 = i == 0 ? o1.getName().compareTo(o2.getName()) : i;

                return i2;
            }
        });

        //2、创建学生对象
        Student6 s1 = new Student6("明旺", 18);
        Student6 s2 = new Student6("王宇", 19);
        Student6 s3 = new Student6("周家祥", 20);
        Student6 s4 = new Student6("张保桂", 17);
        Student6 s5 = new Student6("明旺", 18);

        //3、向集合中添加元素
        map.put(s1, "男枪");
        map.put(s2, "女警");
        map.put(s3, "卡特");
        map.put(s4, "霞");
        map.put(s5, "男枪");

        //4、遍历
        Set<Map.Entry<Student6, String>> entries = map.entrySet();
        for (Map.Entry<Student6, String> keyValue : entries) {
            Student6 key = keyValue.getKey();
            String value = keyValue.getValue();
            System.out.println(key + ":" + value);
        }

    }
}

import java.util.Objects;

public class Student6 implements Comparable<Student6> {
    private String name;
    private int age;

    public Student6() {
    }

    public Student6(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 String toString() {
        return "Student4{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student6 o) {
//        return 0;
        //判断年龄是否一样
        int i = this.age - o.age;
        //年龄一样。姓名不一定一样
        int i2 = i == 0 ? this.name.compareTo(o.name) : i;

        return i2;

    }
}

"aababcabcdabcde",获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)
分析：
    1、定义一个字符串（后期可用键盘录入改进）
    2、定义一个TreeMap对象存储数据
        键：Character
        值：Integer
    3、将字符串转成字符数组
    4、遍历字符数组，得到每一个字符
    5、拿着这个字符作为键去map集合中去找，看返回值
        如果返回值是null,表示集合中没有该字符作为键，就把当前这个字符设置为键，value设置为1
        如果返回值不是null,说明集合中已经存在这个字符作为键，value值+1，然后重新放入到集合中
    6、定义一个StringBuffer作为拼接
    7、遍历集合得到键和值，按照对应的输出格式进行拼接
    8、把StringBuffer输出

输入：aababcabcdabcde
输出：a(5)b(4)c(3)d(2)e(1)

import java.util.Scanner;
public class TreeMapDemo3 {
    public static void main(String[] args) {
        //定义一个字符串（后期可用键盘录入改进）
//        String s = "aababcabcdabcde";
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要统计的字符串：");
        String s = sc.next();


        //定义一个TreeMap对象存储数据
        TreeMap<Character, Integer> map = new TreeMap<>();

        //将字符串转成字符数组
        char[] chars = s.toCharArray();

        //遍历字符数组，得到每一个字符 增强for循环遍历
        for (Character ch : chars) {
            //拿着这个字符作为键去map集合中去找，看返回值 get(key)
            Integer num = map.get(ch);

            //如果返回值是null,表示集合中没有该字符作为键，就把当前这个字符设置为键，value设置为1
            if (num == null) {
                map.put(ch, 1);
            } else {
                // 如果返回值不是null,说明集合中已经存在这个字符作为键，value值+1，然后重新放入到集合中
                num++;
                map.put(ch, num);
            }
        }

        //定义一个StringBuffer作为拼接
        StringBuffer sb = new StringBuffer();

        //遍历集合得到键和值，按照对应的输出格式进行拼接
        Set<Map.Entry<Character, Integer>> entries = map.entrySet();
        for (Map.Entry<Character, Integer> keyValue : entries) {
            Character ch = keyValue.getKey();
            Integer number = keyValue.getValue();
            sb.append(ch).append("(").append(number).append(")");
        }

        //将StringBuffer转成字符串
        String result = sb.toString();
        System.out.println("统计结果为：" + result);

    }

}
举报

相关推荐

Java基础——Map接口

java开发语言后端

java的Map接口

javaSystem键值对音视频

Java Map接口详解

javaJava编程语言

Java集合框架Map接口

SystemjavaJava后端开发

java 接口获取map的value

Javajava键值对后端开发

Java中Map接口的解析

java后端

Java集合——Map接口学习总结

算法周赛python

Map接口

p2plinqgnu

Java精选笔记_集合【Map(映射)接口】

集合Map映射接口HashMap集合LinkedHashMap类TreeMap集合Spark大数据

【Java笔记】集合Map接口的使用

java开发语言蓝桥杯面向对象
0 条评论