双列集合 Map常见的API Map遍历方式 HashMap LinkedHashMap treeMap

nie2459010516

已于 2023-12-19 19:21:48 修改

阅读量437

点赞数 10

文章标签： java 开发语言

于 2023-12-05 19:10:52 首次发布

本文链接：https://blog.csdn.net/nie2459010516/article/details/134305136

版权

双列集合

在这里插入图片描述

双列集合可以记录两个元素.一个称为键一个称为值.合称为键值对,又叫键值对对象,又叫Entry

双列集合的特点

在这里插入图片描述

双列集合体系结构

在这里插入图片描述
有体系结构知Map是最顶层

Map常见的API

在这里插入图片描述

 public static void main(String[] args) {



        //创建map集合

        Map<String,String>m=new HashMap<>();


        //添加元素

        m.put("小诗时","小丹丹");
        m.put("小帆帆","小丽丽");
        m.put("张三","小未未");

       // String s = m.put("小帆帆", "李四");
        //System.out.println(s);

        //添加了相同的键
        //{张三=小未未, 小诗时=小丹丹, 小帆帆=李四}
        //这里只打印了小帆帆 李四 因为put的底层是在建制存在时 后加的会把原来的覆盖

        //并且第二个键值对象会返回第一个被覆盖的对象 这里是小丽丽
        //如果没有被覆盖的键值会返回null



        //remove根据键值删除对应元素

        //m.remove("小诗时");
        //System.out.println(m);//{张三=小未未, 小帆帆=小丽丽}




        //m.clear();//{}清除所有


        // m.containsKey判断集合是否包含指定的键
        boolean b = m.containsKey("小诗时");
        System.out.println(b);
        //true
        //{张三=小未未, 小诗时=小丹丹, 小帆帆=小丽丽}


        boolean b1 = m.containsValue("小未未");
        System.out.println(b1);//true


        //判断集合是否为空
        boolean b2 = m.isEmpty();
        System.out.println(b2);//false


        //判断有几个键值对
        int size = m.size();
        System.out.println(size);//3


        //打印集合
        System.out.println(m);
    }

Map遍历方式

Map的遍历方式一(键找值)

在这里插入图片描述

解析:把键和值分开,键放在一个单例集合里遍历然后通过get方法获取值值

public static void main(String[] args) {
        //Map集合的一种遍历
        Map<String,String>m=new HashMap<>();


        m.put("小诗时","小丹丹");
        m.put("小帆帆","小丽丽");
        m.put("张三","小未未");

        //通过键找值

        Set<String> keys = m.keySet();//这个方法可以理解为将key放到了一个Set集合里

       // System.out.println(key);//[张三, 小诗时, 小帆帆]


        //这个就是装着键的单列集合
        //遍历单列集合,得到每一个键
        for (String key : keys) {


            //通过刚刚的map集合传入键,通过键找到值
            String value = m.get(key);
            System.out.println(key+"="+value);

        }
        //小未未
        //小丹丹
        //小丽丽

        System.out.println("___________________");
        //迭代器遍历

        Iterator<String> it = keys.iterator();

        while(it.hasNext()){
            String s = it.next();
            String value2 = m.get(s);
            System.out.println(value2);
        }


        System.out.println("______________");

        //lambda遍历

        keys.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                String s3 = m.get(s);
                System.out.println(s3);
            }
        });

    }

遍历方式二键值对

原理:利用map集合调用方法entrySet()这个方法相当于获取每个键值对对象并存储在一个Set集合里

 public static void main(String[] args) {

        Map<String,String> m=new HashMap<>();


        m.put("小诗时","小丹丹");
        m.put("小帆帆","小丽丽");
        m.put("张三","小未未");


        Set<Map.Entry<String, String>> entries = m.entrySet();
        //entries相当于所有键值对对象
        for (Map.Entry<String, String> entry : entries) {
            //循环获取每个键值对对象

            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"="+value);
        }
//张三=小未未
//小诗时=小丹丹
//小帆帆=小丽丽
            System.out.println("______________________");
            //迭代器遍历
            Iterator<Map.Entry<String, String>> it = entries.iterator();
            while(it.hasNext()){
                Map.Entry<String, String> next = it.next();
                //迭代器获取了每个键值对对象

                String key1 = next.getKey();
                String value1 = next.getValue();
                System.out.println(key1+"="+value1);




            }


        System.out.println("______________");
        //lambda遍历

        entries.forEach(new Consumer<Map.Entry<String, String>>() {
            @Override
            public void accept(Map.Entry<String, String> stringStringEntry) {
                String key2 = stringStringEntry.getKey();
                String value2 = stringStringEntry.getValue();
                System.out.println(key2+"="+value2);


            }

        });

        }

遍历方式三lambda表达式

他的底层是一个增强for就是利用第二种方式调用

  public static void main(String[] args) {



        Map<String,String> m=new HashMap<>();


        m.put("小诗时","小丹丹");
        m.put("小帆帆","小丽丽");
        m.put("张三","小未未");


        m.forEach(new BiConsumer<String, String>() {
            @Override
            public void accept(String key, String value) {
                System.out.println(key+"="+value);
            }
        });


        //lambda
        m.forEach((key, value)-> System.out.println(key+"="+value));








    }

HashMap

在这里插入图片描述

他是Map的实现类所以它可以用Map的方法
在这里插入图片描述
在底层创建按一个HashMap对象的时候他还是会创建一个默认长度为16加载因子为0.75的数组利用put方法就会创建数据了
put方法底层首先创建一个entry对象,他里面添加的就是键和值,然后利用键计算键的哈希值,只要键的哈希值即可,然后再计算出再数组中应存入的索引,如果该位置为null直接添加,如果该位置不是null并且已经存入了元素,它会调用equals方法比教键的属性值,如果键比较相同会覆盖原有的,如果比较不一样直接添加元素挂在老元素下形成一条链表.链表长度超过8并且数组长度>=64自动转成红黑树

在这里插入图片描述

练习1

需求创建一个集合对象键是学生对象值是籍贯
存储三个键值对元素并遍历
要求同姓名年龄为同一个学生

 public static void main(String[] args) {

        //创建学生对象

        Student s1=new Student("李磊",18);
        Student s2=new Student("张三",10);
        Student s3=new Student("李四",12);
        Student s4=new Student("李四",12);


        //Student{name = 李磊, age = 18}=山东
        //Student{name = 张三, age = 10}=河南
        //Student{name = 李四, age = 12}=江苏
//打印结果如上 因为重复的被覆盖了

        //创建集合
        HashMap<Student,String>hp=new HashMap<>();

        hp.put(s1,"山东");
        hp.put(s2,"河南");
        hp.put(s3,"郑州");
        hp.put(s4,"江苏");


        //匿名内部类遍历
        hp.forEach(new BiConsumer<Student, String>() {
            @Override
            public void accept(Student student, String s) {
                System.out.println(student+"="+s);
            }
        });

        System.out.println("_______________");
        //键找值遍历

        Set<Student> keySet = hp.keySet();
        //获取了键的对象
        for (Student student : keySet) {
            //一次遍历获得每个键


            //通过传入键找到值
            String value = hp.get(student);
            System.out.println(student+"="+value);


        }

        System.out.println("_______________");
        //键值对遍历

        Set<Map.Entry<Student, String>> entries = hp.entrySet();
        //获取一个键值对

        for (Map.Entry<Student, String> entry : entries) {
            //获取每个一次遍历
            Student key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"="+value);
        }
    }

核心:HashMap的键位置如果是存储自定义学生对象需要重写hashCode和equals方法

练习二

在这里插入图片描述

像这种要统计的集合比较多不确定有多少种的时候可以用map集合,这里的景点数量就是个不确定的数

思路用键存储景点名称值存储景点位置

public static void main(String[] args) {


        //定义四个景点存储在一个数组内
        String arr[]={"A","B","C","D"};

        ArrayList<String>list=new ArrayList<>();

        //写一个集合模拟80人投票结果
        Random r=new Random();
        for (int i = 0; i < 80; i++) {

            int index = r.nextInt(arr.length);
            //获取随机索引
            //System.out.println(arr[index]);

            //吧随即索引添加列表中存储
            list.add(arr[index]);

        }


        //创建一个hashMap集合 键存储景点 值存储次数

        HashMap<String,Integer>hp=new HashMap<>();
        for (String name : list) {//遍历得到每次投票信息 景点名


            //判断当前景点再map集合是否存在
            if(hp.containsKey(name)){
                //存在
                //先获取当前经典的已有次数
                Integer value = hp.get(name);
                value++;
                //把信息信息传递给map
                hp.put(name,value);


            }else{
                //不存在


                hp.put(name,1);

            }


        }
        System.out.println(hp);



        //判断哪个景点想去的人最多

        int max=0;
        //解析景点投票可能出现有些经典很多人有些很少但也
        //会出现有些很多有些是0人

        //遍历得到每个键值对

        Set<Map.Entry<String, Integer>> entries = hp.entrySet();

        for (Map.Entry<String, Integer> entry : entries) {

            Integer value = entry.getValue();
            if(value>max){
                max=value;
            }

        }
        System.out.println(max);


        for (Map.Entry<String, Integer> entry : entries) {

            Integer value = entry.getValue();
            if(value==max){

                System.out.println(entry.getKey());
            }


        }

    }

LinkedHashMap

在这里插入图片描述

  public static void main(String[] args) {

        LinkedHashMap<String,Integer>lhm=new LinkedHashMap<>();

        lhm.put("a",123);
        lhm.put("a",234);
        lhm.put("b",154);
        lhm.put("c",123);
        
        //{a=234, b=154, c=123} 键不能重复 还会覆盖

        System.out.println(lhm);
    }

TreeMap

在这里插入图片描述

TreeMap练习1

在这里插入图片描述

TreeMap<Integer,String>tm=new TreeMap<>();
        //默认按照键的排序方式
        //而Integer排序方式是按照第一种排序方式默认升序


        tm.put(5,"可乐");
        tm.put(4,"雪碧");
        tm.put(3,"冰红茶");
        tm.put(2,"奶茶");
        tm.put(1,"香蕉");


        System.out.println(tm);

如果确实想实现按逆序排列只能采用比较器

   TreeMap<Integer,String>tm=new TreeMap<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        //默认按照键的排序方式
        //而Integer排序方式是默认升序


        tm.put(5,"可乐");
        tm.put(4,"雪碧");
        tm.put(3,"冰红茶");
        tm.put(2,"奶茶");
        tm.put(1,"香蕉");


        System.out.println(tm);
        //{5=可乐, 4=雪碧, 3=冰红茶, 2=奶茶, 1=香蕉}

二

在这里插入图片描述
运行报错:是因为自定义对象排序需要指定排序规则

三

遇到这样的题应该如何选择集合
如果题目中没有要求对结果进行排序默认使用HashMap
如题目中要求对结果进行排序请使用TreeMap

 public static void main(String[] args) {


        //要求利用map集合统计aababcabcdabcde
        //键表示要统计的内容
        //值表示次数



        //:思路先拆分字符串
        //拿到字符串然后与集合联动 看看再集合中存在否 不存在的话put一个新的存在的话count++


        TreeMap<Character,Integer>tm=new TreeMap<>();
        String s="aababcabcdabcde";
        for (int i = 0; i < s.length(); i++) {
            char c=s.charAt(i);//取除每一个字符串

            //把字符串存入集合 如果在集合中已经存在count++次数
            //如果不存在直接put
            if(tm.containsKey(c)){
                //拿出value已有次数
                int count=tm.get(c);
                count++;

                //把自增后的结果添加集合
                tm.put(c,count);


            }else{
                tm.put(c,1);


            }



        }
        System.out.println(tm);
        //{a=5, b=4, c=3, d=2, e=1}

        //我们想要的格式为a(5)b(4)....

        //可以使用StringBuilder拼接

        StringBuilder sb=new StringBuilder();

        //打印集合
        tm.forEach(new BiConsumer<Character, Integer>() {
            @Override
            public void accept(Character key, Integer value) {
                sb.append(key).append("(").append(value).append(")");
                
            }
        });
        System.out.println(sb);
        //a(5)b(4)c(3)d(2)e(1)
        
    }

nie2459010516

关注

10
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
双列集合 Map常见的API Map遍历方式 HashMap LinkedHashMap treeMap

原理:利用map集合调用方法entrySet()这个方法相当于获取每个键值对对象并存储在一个Set集合里。像这种要统计的集合比较多不确定有多少种的时候可以用map集合,这里的景点数量就是个不确定的数。如果题目中没有要求对结果进行排序默认使用HashMap。如题目中要求对结果进行排序请使用TreeMap。需求创建一个集合对象键是学生对象值是籍贯。如果确实想实现按逆序排列只能采用比较器。思路用键存储景点名称值存储景点位置。存储三个键值对元素并遍历。要求同姓名年龄为同一个学生。
复制链接

扫一扫