Java-Map集合HashMap集合LinkedHashMap集合TreeMap集合

最新推荐文章于 2024-04-19 21:06:02 发布
最新推荐文章于 2024-04-19 21:06:02 发布
阅读量144 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45170723/article/details/131504633
版权

Map集合

  • 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("001","林青霞");
        map.put("002","张曼玉");
        map.put("003","王祖贤");
        map.put("003","柳岩");

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

Map集合的基本功能【应用】

方法介绍：

方法名说明
V put(K key,V value)添加元素
V remove(Object key)根据键删除键值对元素
void clear()移除所有的键值对元素
boolean containsKey(Object key)判断集合是否包含指定的键
boolean containsValue(Object value)判断集合是否包含指定的值
boolean isEmpty()判断集合是否为空
int size()集合的长度，也就是集合中键值对的个数
public class Map集合使用 {
    public static void main(String[] args) {
        Map<String,Integer> m = new HashMap<>();
        
        //put细节：put是有返回值的
        //如果键一样的时候，会覆盖掉值，并返回，如果不一样则返回Null;
        m.put("老六",18);
        m.put("蔡徐坤",19);
        m.put("肖战",18);
        m.put("王一博",18);

        //打印
        System.out.println(m);//{蔡徐坤=19, 肖战=18, 王一博=18}

        //删除，只用到键
        m.remove("老六");

        //判断是否包含键或者值的两个方法;
        Boolean r1 = m.containsKey("蔡徐坤");
        Boolean r2 = m.containsValue(18);
        System.out.println(r1);//true
        System.out.println(r2);//true

        //清除集合;
        m.clear();

        //判断集合是否为空
        Boolean r3 = m.isEmpty();
        System.out.println(r3);//true
    }
}

Map集合三种遍历方式

第一种：

  • - 遍历思路
    •   - 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
    •     - 把所有的丈夫给集中起来
    •     - 遍历丈夫的集合，获取到每一个丈夫
    •     - 根据丈夫去找对应的妻子
  • - 步骤分析
    •   - 获取所有键的集合。用keySet()方法实现
    •   - 遍历键的集合，获取到每一个键。用增强for实现  
    •   - 根据键去找值。用get(Object key)方法实现
  • - 代码实现
package Map集合;

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

public class Map集合遍历 {
    public static void main(String[] args) {
        Map<String,Integer> m = new HashMap<>();
        m.put("肖战",18);
        m.put("王一博",19);
        m.put("蔡徐坤",12);
        m.put("范丞丞",13);

        //获取所有键集合。利用keySet方法实现
        Set<String> keys= m.keySet();
        //用增强for遍历键的集合，获取每一个键
        for (String key: keys) {
            //利用键获取值.get(Object key)方法实现
            Integer value = m.get(key);
            System.out.println(key+"="+value);
        }

    }
}

第二种

  • - 遍历思路
    •   - 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
      •     - 获取所有结婚证的集合
      •     - 遍历结婚证的集合，得到每一个结婚证
      •     - 根据结婚证获取丈夫和妻子
  • - 步骤分析
    •   - 获取所有键值对对象的集合
    •     - Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合
    •   - 遍历键值对对象的集合，得到每一个键值对对象
    •     - 用增强for实现，得到每一个Map.Entry
    •   - 根据键值对对象获取键和值
    •     - 用getKey()得到键
    •     - 用getValue()得到值
  • - 代码实现
public class Map集合遍历 {
    public static void main(String[] args) {
        Map<String,Integer> m = new HashMap<>();
        m.put("肖战",18);
        m.put("王一博",19);
        m.put("蔡徐坤",12);
        m.put("范丞丞",13);

        //获取所有键值对对象的集合
        Set<Map.Entry<String,Integer>> entrySet = m.entrySet();
        //遍历键值对对象的集合，得到每一个键值对对象
        for (Map.Entry<String,Integer> me: entrySet) {
            //根据键值对对象获取键和值
            System.out.println(me.getKey()+"="+me.getValue());
        }
    }
}

第三种

Lambda表达式遍历，内部原理和第二种方式一样

public class Map集合遍历 {
    public static void main(String[] args) {
        Map<String,Integer> m = new HashMap<>();
        m.put("肖战",18);
        m.put("王一博",19);
        m.put("蔡徐坤",12);
        m.put("范丞丞",13);

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

    }
}

代码原理实现：

default void forEach(BiConsumer<? super K, ? super V> action) {
        Objects.requireNonNull(action);
        for (Map.Entry<K, V> entry : entrySet()) {
            K k;
            V v;
            try {
                k = entry.getKey();
                v = entry.getValue();
            } catch (IllegalStateException ise) {
                // this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }
            action.accept(k, v);
        }
    }

HashMap集合

 

  

 HashMap练习：

public class HashMap练习 {
    public static void main(String[] args) {
        HashMap<Student,String> hashMap = new HashMap<>();

        hashMap.put(new Student("蔡徐坤",18),"广东");
        hashMap.put(new Student("王一博",19),"江西");
        hashMap.put(new Student("肖战",17),"北京");
        hashMap.put(new Student("范丞丞",16),"浙江");
        //重写了HashCode和equals就会去重
        hashMap.put(new Student("范丞丞",16),"山东");

        hashMap.forEach(new BiConsumer<Student, String>() {
            @Override
            public void accept(Student student, String s) {
                System.out.println("学生名字:"+student.getName()+" 学生年龄:"+student.getAge()+" 学生籍贯："+s);
            }
        });
    }
}
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;
    }

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

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

 

public class HashMap练习二 {
    public static void main(String[] args) {
        String[] arr = new String[]{"双月湾","白云山","欢乐谷","世界之窗"};

        ArrayList<String> list = new ArrayList<>();
        Random r = new Random();
        for (int i = 0; i < 88; i++) {
            int dex = r.nextInt(arr.length);
            list.add(arr[dex]);
        }

        HashMap<String,Integer> hashMap = new HashMap<>();

        for (String name : list) {
            //hashMap.getOrDefault(name, 0) 的执行过程如下：
            //如果 name 在 HashMap 中存在，则返回该键对应的值。
            //如果 name 在 HashMap 中不存在，则返回默认值 0。
            hashMap.put(name, hashMap.getOrDefault(name, 0) + 1);
        }

        System.out.println(hashMap);

        int max = 0;
        String maxkey = null;
        Set<Map.Entry<String,Integer>> keys = hashMap.entrySet();
        for (Map.Entry<String, Integer> key : keys) {
            if (key.getValue()>max){
                max = key.getValue();
                maxkey = key.getKey();
            }
        }

        System.out.println(max);
        System.out.println(maxkey);
    }
}

LinkedHashMap集合

public class LinkedHashMap集合 {
    public static void main(String[] args) {
        LinkedHashMap<String,Integer> l = new LinkedHashMap<>();

        l.put("王一博",99);
        l.put("蔡徐坤",15);
        l.put("肖战",93);
        l.put("范丞丞",18);

        System.out.println(l);
    }
}

TreeMap集合

  • TreeMap集合概述和特点【理解】
    • TreeMap底层是红黑树结构
    • 依赖自然排序或者比较器排序,对键进行排序
    •  如果键存储的是自定义对象,需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则

public class TreeMap集合 {
    public static void main(String[] args) {
        TreeMap<Integer,String> tm = new TreeMap<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //o1是需要添加的数，o2已经在红黑树存在的数
                return o2-o1;
            }
        });

        tm.put(1,"a");
        tm.put(2,"b");
        tm.put(3,"c");
        tm.put(4,"d");
        tm.put(5,"e");

        System.out.println(tm);
    }
}

 

public class TreeMap集合练习 {
    public static void main(String[] args) {
        TreeMap<studen1,String> tm = new TreeMap<>();

        tm.put(new studen1("abc",18),"江西");
        tm.put(new studen1("cdas",23),"广东");
        tm.put(new studen1("dsa",16),"浙江");
        tm.put(new studen1("asad",79),"北京");

        System.out.println(tm);
    }
}
class studen1 implements Comparable<studen1>{
    private String name;
    private int age;

    public studen1(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 "student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        studen1 student1 = (studen1) o;
        return age == student1.age && Objects.equals(name, student1.name);
    }

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

    @Override
    public int compareTo(studen1 o) {
        //返回值是负数则是小的,存左边，返回值是正数则是大的，存右边，返回值0不存
        int i = this.getAge() - o.getAge();
        if (this.getAge() == o.getAge()){
            if (Objects.equals(this.getName(), o.getName())){
                return 0;
            }else
                return this.getName().compareTo(o.getName());
        }

        return i;
    }
}

 

 

weixin_45170723
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
java中map集合的用法.doc
10-24
创建Map的常见方式是使用实现Map接口的具体类，如HashMap、TreeMap或LinkedHashMap。例如，`Map, String> map = new HashMap();`。 2. **存储键值对**： 使用`put()`方法将键值对放入Map中，如`map.put("key", ...
Java HashMap详解及实现原理
兴趣是最好的老师，勤能补拙
05-15 2088
Java HashMap是Java集合框架中最常用的实现Map接口的数据结构，它使用哈希表实现，允许null作为键和值，可以存储不同类型的键值对。HashMap提供了高效的存取方法，并且是非线程安全的。在Java中，HashMap被广泛应用于各种场景，如缓存、数据库连接池、路由器等。
深入剖析Java Map：掌握HashMap、TreeMap、LinkedHashMap和ConcurrentHashMap
小虎哥的技术博客
07-28 221
在Java中，Map接口是一个通用的键值对集合，它允许我们使用一对键值来存储和访问数据。可以通过put(key, value)方法将键值对存储到Map中，然后通过get(key)方法获取相应的值。
Java集合详解——HashMap类（包括 底层机制源代码分析）
最新发布
m0_75013084的博客
04-19 952
（1）Map接口的常用实现子类：HashMap、Hashtable和Properties。（2）HashMap是Map接口 使用频率最高的实现类。（3）HashMap是以key-value对的方式 来存储数据。（4）key不能重复，但是是值可以重复，允许使用null键和null值。（5）如果添加相同的key，则会覆盖原来的key-value，相当于修改（key不会替换，value会替换）。（6）与HashSet一样，不保证映射的顺序，因为底层是以hash表的方式来存储的。
Java的TreeMap和HashMap的介绍和使用
热门推荐
yo_bc的博客
02-12 1万+
1. TreeMap的介绍和使用 第1部分 TreeMap介绍 TreeMap 简介 TreeMap 是一个有序的key-value集合，它是通过红黑树实现的。 TreeMap 继承于AbstractMap，所以它是一个Map，即一个key-value集合。 TreeMap 实现了NavigableMap接口，意味着它支持一系列的导航方法。比如返回有序的key集合
Java-数据结构（二）-Map：HashMap、TreeMap、LinkedHashMap
向诸位大佬虚心学习
07-02 7723
Map是Java中的一个接口，它代表了一种键值对的映射关系。它允许我们通过Key来访问Value。在Map中，每个Key都是唯一的，而且与该Key对应的Value是一一对应的关系。维度HashMapTreeMap底层实现哈希表红黑树哈希表+链表插入顺序无序无序（基于键的自然排序或自定义排序）保持插入顺序查找效率O(1)O(log n)O(1)迭代顺序无序有序（基于键的自然排序或自定义排序）保持插入顺序或访问顺序键的唯一性允许null键和null值。
Java中的集合类——HashMap
qq_45838559的博客
08-29 954
（1）在hash表中进行添加、删除、查找等操作性能很高，不考虑hash冲突的情况下仅需一次定位即可完成，时间复杂度为O(1)。（2）hash表的主干就是数组。（3）当我们要新增或查找某个元素，我们通过把当前元素的关键字通过某个函数映射到数组中的某个位置，通过数组下标一次定位就可完成操作。即：存储位置 = f(关键字)（4）哈希冲突：当我们对某个元素进行哈希运算，得到一个存储地址，然后要进行插入的时候，发现已经被其他元素占用了，其实这就是所谓的哈希冲突，也叫哈希碰撞。...
Java map集合顺序如何同步添加顺序
08-19
Java 提供了多种 Map 实现类，包括 HashMap、TreeMap、LinkedHashMap 等。其中，HashMap 是最常用的，但是它的元素顺序是不可预测的。TreeMap 和 LinkedHashMap 则可以保证元素的顺序，但是它们的实现机制不同。...
java HashMap,TreeMap与LinkedHashMap的详解
09-01
在Java编程语言中，`HashMap`、`TreeMap`和`LinkedHashMap`都是`java.util.Map`接口的实现，它们提供了不同的数据存储和访问策略。本文将深入探讨这三种数据结构的特点、工作原理以及适用场景。 1. **HashMap** `...
JAVA集合框架Map特性及实例解析
08-19
在JAVA集合框架中，HashMap是Map的一个重要实现类，也是最常用的，基于哈希表实现。HashMap的特性包括： 1. HashMap基于哈希表实现。 2. HashMap中的Entry对象是无序排列的。 3. Key值和Value值都可以为null，但是...
Java-collection-frame.rar_Java集合框架
09-20
在Java集合框架中，主要分为两大类：List（列表）、Set（集合）和Map（映射）。 1. List接口：List是一种有序的集合，允许包含重复元素。它定义了元素的插入、删除和访问方法，如add()、remove()和get()。ArrayList...
Java中Map相关讲解（HashMap、TreeMap、LinkedHashMap）
weixin_44171249的博客
12-07 986
Map
java面试整理（四）—— HashMap、LinkedHashMap、TreeMap、Hashtable、HashSet和ConcurrentHashMap区别
落尘
05-17 7927
HashMap HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键(HashMap最多只允许一条记录的键为null，允许多条记录的值为null。)。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。 HashMap中不允许出现重复的键（Key） Hashmap是非线程安全的，如果多个线程同时访问一个HashMap，可能会导致数...
Java之HashMap和TreeMap
weixin_47543906的博客
11-08 728
Map Map是一种键值对集合，每一个元素都包含了一个键对象和一个值对象。 Map集合中，键不允许重复，值可以重复。（比如身份证和姓名） 键和值是一一对应的，通过键可以找到与之对应的唯一的值。
java HashMap与TreeMap总结
liaorongxiao的博客
04-06 3025
1、HashMap简介 HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。 HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。 HashMap 是无序的，即不会记录插入的顺序。 HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。 HashMap 类位于 java.util 包中，使用前需要引入它.
Java集合 —— HashMap原理解析
m0_56602092的博客
04-28 3973
一、HashMap是什么 HashMap是一个存储key-value键值对的哈希表，表中每个元素的key都是唯一的（通过equals方法判断），查询时通过key的hashcode值即可定位到元素的存储地址，因此HashMap在理想情况下查询时间复杂度为O(1)。 1. 存储下标计算方法 HashMap底层通过Entry数组来存储元素，插入元素和查询元素时首先需要计算元素在数组中的存储下标，方法如下： 1. 通过key的hashCode()方法获取其hashcode值 2. 将这个hashcode值再通过h
JavaSE进阶 | Map集合、HashMap集合、TreeMap集合
m0_61933976的博客
07-24 1637
JavaSE进阶 | Map集合、HashMap集合、TreeMap集合
Java Map集合详解 ：HashMap类
weixin_62458944的博客
08-07 782
Map 是一种键-值对（key-value）集合，Map 集合中的每一个元素都包含一个键（key）对象和一个值（value）对象。用于保存具有映射关系的数据。Map 集合里保存着两组值，一组值用于保存 Map 里的 key，另外一组值用于保存 Map 里的 value，key 和 value 都可以是任何引用类型的数据。Map 的 key 不允许重复，value 可以重复，即同一个 Map 对象的任何两个 key 通过 equals 方法比较总是返回 false。
【Java集合框架】19 ——HashMap 类
weixin_44735928的博客
08-09 662
HashMap类

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值