Java_18_Map集合

最新推荐文章于 2024-05-21 18:39:06 发布
最新推荐文章于 2024-05-21 18:39:06 发布
阅读量126 收藏
点赞数
分类专栏： Java基础教程 文章标签： java18 java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A_shmily_/article/details/131576389
版权

Map集合

  1. Map集合是另一个集合体系。
    Collection是单值集合体系。

  2. Map集合是一种双列集合，每个元素包含两个值。
    Map集合的每个元素的格式：key=value(键值对元素)。
    Map集合也被称为“键值对集合”。

  3. Map集合的完整格式：{key1=value1 , key2=value2 , key3=value3 , …}

  4. Map集合有啥用？

    1. Map集合存储的信息更加的具体丰富。
      Collection: [“苍老师”,“日本”,“女”,“动作演员”,23,“广州”]
      Map : {name=“苍老师” , jiaxiang=小日本 , sex=“女” , age = 23 , addr=广州}

    2. Map集合很适合做购物车这样的系统。
      Map: {娃娃=30 , huawei=1 , iphonex=1}

  5. 注意：集合和泛型都只能支持引用数据类型，集合完全可以称为是对象容器，存储都是对象。

  6. Map集合的体系：
    Map<K , V>(接口,Map集合的祖宗类)
    TreeMap<K , V>
    HashMap<K , V>(实现类,经典的，用的最多)
    LinkedHashMap<K, V>(实现类)

  7. Map集合的特点：
    1.Map集合的特点都是由键决定的。
    2.Map集合的键是无序,不重复的，无索引的。
    Map集合后面重复的键对应的元素会覆盖前面的整个元素！
    3.Map集合的值无要求。
    4.Map集合的键值对都可以为null。

HashMap:元素按照键是无序，不重复，无索引，值不做要求。
LinkedHashMap:元素按照键是有序，不重复，无索引，值不做要求。

范例

public class MapDemo {
    public static void main(String[] args) {
        // 一行经典代码
        Map<String , Integer> maps = new HashMap<>();
        maps.put("娃娃",1);
        maps.put("huawei",10);
        maps.put("iphoneXS",2);
        maps.put(null , null );
        maps.put("娃娃",30);
        maps.put("特仑苏",2);
        System.out.println(maps);
    }
}

Map的几个重要API

  • public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
    • public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
    • public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
    • public Set keySet(): 获取Map集合中所有的键，存储到Set集合中。
    • public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。
    • public boolean containKey(Object key):判断该集合中是否有此键。
public class MapDemo {
    public static void main(String[] args) {
        Map<String , Integer> maps = new HashMap<>();
        // 1.添加元素: 无序，不重复，无索引。
        maps.put("iphoneX",10);
        maps.put("娃娃",30);
        maps.put("iphoneX",100);//  Map集合后面重复的键对应的元素会覆盖前面重复的整个元素！
        maps.put("huawei",1000);
        maps.put("生活用品",10);
        maps.put("手表",10);
        // {huawei=1000, 手表=10, 生活用品=10, iphoneX=100, 娃娃=30}
        System.out.println(maps);

        // 2.清空集合
        //maps.clear();
        //System.out.println(maps);

        // 3.判断集合是否为空，为空返回true ,反之！
        System.out.println(maps.isEmpty());

        // 4.根据键获取对应值。
        //Integer value = maps.get("娃娃");
        //System.out.println(value);
        System.out.println(maps.get("娃娃"));

        // 5.根据键删除整个元素。(删除键会返回键的值)
        maps.remove("iphoneX");
        System.out.println(maps);

        // 6.判断是否包含某个键 ，包含返回true ,反之
        System.out.println(maps.containsKey("手表")); // true
        System.out.println(maps.containsKey(10)); // false

        // 7.判断是否包含某个值。
        System.out.println(maps.containsValue(1000)); // true
        System.out.println(maps.containsValue(10)); // true
        System.out.println(maps.containsValue("30")); // false 包含的是整数30不是字符串。

        // 8.获取全部键的集合：public Set<K> keySet()
        // Map集合的键是无序不重复的，所以返回的是一个Set集合。
        Set<String> keys = maps.keySet();
        for (String key : keys) {
            System.out.println(key);
        }

        // 9.获取全部值的集合：Collection<V> values();
        // Map集合的值是不做要求的，可能重复，所以值要用Collection集合接收!
        Collection<Integer> values = maps.values();
        for (Integer value : values) {
            System.out.println(value);
        }

        // 10.集合的大小
        System.out.println(maps.size());

        // 11.合并其他Map集合。(拓展)
        Map<String,Integer> maps2 = new HashMap<>();
        maps2.put("xiaoMi" , 1);
        maps2.put("🔨手机" , 10);
        maps2.put("手表" , 10000);
        maps.putAll(maps2); // 把Map集合maps2的数据全部倒入到maps集合中去
        System.out.println(maps);

    }
}

遍历

  1. Map集合的遍历方式有：3种。
    （1）“键找值”的方式遍历：先获取Map集合全部的键，再根据遍历键找值。
    （2）“键值对”的方式遍历：难度较大。
    （3）JDK 1.8开始之后的新技术：Lambda表达式。（暂时了解）

  2. “键找值”的方式遍历Map集合。
    1.先获取Map集合的全部键的Set集合。
    2.遍历键的Set集合，然后通过键找值。
    小结：
    代码简单，需要记住!

 // 获取当前Map集合的全部键的集合 。
        Set<String> keys = maps.keySet();
        System.out.println(keys);
        // [huawei, 手表, 生活用品, iphoneX, 娃娃]
        //          key
        // b.通过遍历键然后通过键取对应的值
        for (String key : keys) {
            // 过键取对应的值
            Integer value = maps.get(key);
            System.out.println(key + "=" + value);
        }

  1. “键值对”的方式遍历：
    1. 把Map集合转换成一个Set集合:Set<Map.Entry<K, V>> entrySet();
    2. 此时键值对元素的类型就确定了，类型是键值对实体类型：Map.Entry<K, V>
    3. 接下来就可以用foreach遍历这个Set集合，类型用Map.Entry<K, V>

  2. “键值对”的方式遍历：更加面向对象的方式，代码复杂。

  3. “键值对”想把键值对当成一个整体遍历，也就是直接使用foreach遍历：
    for(被遍历集合的元素类型 变量：集合名称){}
    但是发现Map集合的键值对数据直接是没有元素类型的，foreach无法直接遍历Map集合。
    👇
    把Map集合通过代码Set<Map.Entry<K, V>> entrySet()转换成Set集合。
    👇
    Set<Map.Entry<String,Integer>> entries = maps.entrySet();
    👇
    entries = [(huawei=1000), (手表=10), (生活用品=10), (iphoneX=100), (娃娃=30) ]
    // entry
    此时键值对元素才能作为一个整体就有了类型。类型是 Map.Entry<String,Integer>实体类型

public class MapDemo02 {
    public static void main(String[] args) {
        Map<String , Integer> maps = new HashMap<>();
        // 1.添加元素: 无序，不重复，无索引。
        maps.put("娃娃",30);
        maps.put("iphoneX",100);//  Map集合后面重复的键对应的元素会覆盖前面重复的整个元素！
        maps.put("huawei",1000);
        maps.put("生活用品",10);
        maps.put("手表",10);
        System.out.println(maps);
        // maps = {huawei=1000, 手表=10, 生活用品=10, iphoneX=100, 娃娃=30}
        //
        Set<Map.Entry<String,Integer>> entries = maps.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
             String key = entry.getKey();
             Integer value = entry.getValue();
             System.out.println(key + "=>" + value);
        }
    }
}

存储自定义类型

Map集合的键和值都可以存储自定义类型。

  1. 小结：
    Map集合的键和值都可以存储自定义类型。
    如果希望Map集合认为自定义类型的键对象重复了，必须重写对象的hashCode()和equals()方法

Orange类作存储类型

public class Orange {
    private String name;
    private double weight;
    private String price;
    public Orange() {
    }

    public Orange(String name, double weight, String price) {
        this.name = name;
        this.weight = weight;
        this.price = price;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Orange orange = (Orange) o;
        return Double.compare(orange.weight, weight) == 0 &&
                Objects.equals(name, orange.name) &&
                Objects.equals(price, orange.price);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, weight, price);
   }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getWeight() {
        return weight;
    }
    public void setWeight(double weight) {
        this.weight = weight;
    }
    public String getPrice() {
        return price;
    }
    public void setPrice(String price) {
        this.price = price;
    }

    public String toString() {
        return "Orange{name = " + name + ", weight = " + weight + ", price = " + price + "}";
    }
}

Main

public class MapDemo02 {
    public static void main(String[] args){
        Map<Oranges,String> maps = new HashMap<>();
        Oranges o1 = new Oranges("黄橘子",20.3 , "贼便宜!");
        Oranges o2 = new Oranges("黑橘子",30.3 , "坏了");
        Oranges o3 = new Oranges("青橘子",34.3 , "9.9包邮");
        Oranges o4 = new Oranges("黄橘子",20.3 , "贼便宜！");

        maps.put(o1,"江西");
        maps.put(o2,"江苏");
        maps.put(o3,"山东");
        maps.put(o4,"浙江");

        System.out.println(maps);
    }
}

LinkedHashMap

  1. LinkedHashMap是HashMap的子类。
    1. 添加的元素按照键有序，不重复的。
    HashSet集合相当于是HashMap集合的键都不带值。
    LinkedHashSet集合相当于是LinkedHashMap集合的键都不带值。

  2. 底层原理完全一样，都是基于哈希表按照键存储数据的，
    只是HashMap或者LinkedHashMap的键都多一个附属值。

  3. 小结：
    HashMap集合是无序不重复的键值对集合。
    LinkedHashMap集合是有序不重复的键值对集合。
    他们都是基于哈希表存储数据,增删改查都很好。

public class LinkedHashMapDemo {
    public static void main(String[] args) {
        Map<String , Integer> maps = new LinkedHashMap<>();
        maps.put("iphoneX",10);
        maps.put("娃娃",30);
        maps.put("iphoneX",100); // 依然是保留前面的位置，只是替换其值！
        maps.put("huawei",1000);
        maps.put("生活用品",10);
        maps.put("手表",10);
        System.out.println(maps);
    }
}

TreeMap

  1. TreeMap集合按照键是可排序不重复的键值对集合。(默认升序)
  2. TreeMap集合按照键排序的特点与TreeSet是完全一样的。
  3. 小结：
    TreeMap集合和TreeSet集合都是排序不重复集合
    TreeSet集合的底层是基于TreeMap，只是键没有附属值而已。
    所以TreeMap集合指定大小规则有2种方式：
    a.直接为对象的类实现比较器规则接口Comparable，重写比较方法（拓展方式）
    b.直接为集合设置比较器Comparator对象,重写比较方法
  // 比较者： this
    // 被比较者： o
    // 需求：按照价格排序！
    @Override
    public int compareTo(Object o) {
        // 浮点型的大小比较建议使用Java自己的API:
        // public static int compare(double d1, double d2)
        return  Double.compare(this.price , ((Pig)o).price);
    }

浮点型有专门的比较API 默认升序，降序加个负号就行。

public class TreeMapDemo {
    public static void main(String[] args) {
        Map<Integer,String> maps = new TreeMap<>();
        maps.put(1000000,"张三");
        maps.put(1000000,"张三1");
        maps.put(10000,"李四");
        maps.put(10,"王五");
        maps.put(24244,"张麻子");
        System.out.println(maps);

        Map<Pig,String> pigs = new TreeMap<>();
        pigs.put(new Pig("🐖佩奇",99.5 , 500.0), "荷兰");
        pigs.put(new Pig("🐖乔治",99.4 , 605.0), "澳大利亚");
        pigs.put(new Pig("🐗野猪",199.4 , 305.0), "山上");
        pigs.put(new Pig("🐗野猪",199.4 , 305.0), "山上2");
        System.out.println(pigs);


        //  public TreeMap(Comparator<? super K> comparator)
        Map<Pig,String> pigs1 = new TreeMap<>(new Comparator<Pig>() {
            @Override
            public int compare(Pig p1, Pig p2) {
                return Double.compare(p1.getWeight() , p2.getWeight());
            }
        });
        pigs1.put(new Pig("🐖佩奇",99.5 , 500.0), "荷兰");
        pigs1.put(new Pig("🐖乔治",99.4 , 605.0), "澳大利亚");
        pigs1.put(new Pig("🐗野猪",199.4 , 305.0), "山上");
        pigs1.put(new Pig("🐗野猪",199.4 , 305.0), "山上2");
        System.out.println(pigs1);
    }
}

案例

  1. 目标：输出一个字符串中每个字符出现的次数。（经典面试题）

  2. 分析：
    （1）键盘录入一个字符串。aabbccddaa123。
    （2）定义一个Map集合，键是每个字符，值是其出现的次数。 {a=4 , b=2 ,…}
    （3）遍历字符串中的每一个字符。
    （4）拿着这个字符去Map集合中看是否有这个字符键，有说明之前统计过，其值+1
    没有这个字符键，说明该字符是第一次统计，直接存入“该字符=1”

public class MapDemo03 {
    public static void main(String[] args){
        // （1）键盘录入一个字符串。aabbccddaa123。
        Scanner scanner = new Scanner(System.in);
        System.out.print("请您输入一个字符串：");
        String tmp = scanner.nextLine();
        // （2）定义一个Map集合，键是每个字符，值是其出现的次数。
        Map<Character,Integer> iCount = new HashMap<>();
        // （3）遍历字符串中的每一个字符。
        for(int i = 0;i < tmp.length();i ++){
            char nowLocal = tmp.charAt(i);  //定义变量存当前位置的字符
            // （4）拿着这个字符去Map集合中看是否有这个字符键，有说明之前统计过，其值+1
            //   没有这个字符键，说明该字符是第一次统计，直接存入“该字符=1”
            if(iCount.containsKey(nowLocal)) iCount.put(nowLocal,iCount.get(nowLocal) + 1);
            else iCount.put(nowLocal,1);
        }
        System.out.println(iCount);
    }
}
沐鑫本鑫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java__Map集合.mp4
07-09
Java__Map集合.mp4
java 定义map集合_java基础-Map集合
weixin_36331312的博客
02-24 2484
java基础-Map集合作者：尹正杰版权声明：原创作品，谢绝转载！否则将追究法律责任。一.Map集合概述我们通过查看Map接口描述，发现Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同，如下：1>.Collection中的集合，元素是孤立存在的，向集合中存储元素采用一个个元素的方式存储；2>.Map中的集合，元素是成对存在的，每个元素是成对存在的，每个元素由...
java 定义map集合_Java中的Map集合
weixin_39974223的博客
02-13 2658
Map集合：个人感觉Map接口以后会经常用到，可以很清晰地查找某个对象，要熟悉其四种遍历方法。特别注意其键值对的键不能是重复的，有想定义有序存取的话，可以使用LinkedHashMap集合。不过定义自定义对象时，要复写其对象的hashCode和equals方法。静态导入的话，不用编辑器的话可以使用下。再定义方法时有多个参数的话，可以使用可变参数，不过只能一个且在最后面。Collections的工具...
java的Map集合 详解Map集合
热门推荐
weixin_46140377的博客
04-10 7万+
java 集合 Map， HashMap，LinkedHashMap，Hashtable， 详解Map集合
java中redis存储map集合_使用redis存放 map数据
weixin_36431145的博客
02-27 3014
效果实现public class JedisPoolUtil {/*** 获取一个redis实例* @param jedisConnectionFactory* @return*/public static Jedis getJedis(JedisConnectionFactory jedisConnectionFactory){JedisPoolConfig config = jedisConn...
java map存储list集合_Java集合类(List、map、list集合)
weixin_30706851的博客
02-13 4884
1.1集合类的概述Java.util包中提供了一些集合类，这些集合类右被称为容器。提到容器不难想到数组，集合类与数组不同之处是：数组的长度是固定长度，集合的长度是可变的；数组是用来存放基本数据类型，集合是用来存放对象的引用。常用的集合有List集合、Set集合和Map集合，其中List和Set继承了Collection接口，各接口还提供了不同的实现类。上述集合类的继承关系如图14.1所示：1.1C...
JavaMap.rar_arraylist map_collection_java map_javamap_地图 java
09-23
Java Map 集合类简介,Collection,Map,ArrayList
Java_Collection_List-Set-Map.zip_list set map
09-24
Java集合排序及java集合类详解 (Collection, List, Set, Map)
Collection-and-Map.zip_java list map
09-20
关于Map，List，collection集合遍历，泛型等
Java集合Map常见问题_动力节点Java学院整理
08-30
主要为大家详细整理了Java集合Map常见问题，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java 18新特性深度解析
小透明的博客
05-17 485
Java 18继续遵循着六个月一次的更新周期，它聚焦于提升性能、增强新的功能以及改善开发者的体验。在这次更新中，虽然大部分变化集中在性能和稳定性上，但仍然有一些值得注意的新特性。Java 18的新特性虽然不多，但在性能和稳定性方面的努力是显而易见的。这些改进为Java开发者提供了更高效、更安全的编程环境，同时也为Java在未来的发展奠定了坚实的基础。随着Java语言的不断进化，开发者应当持续关注新版本的特性，以便更好地利用这些新工具来构建和维护自己的应用。
Java18的新特性介绍
runqu的博客
05-17 932
基于事件的系统采用异步事件驱动的方式，通过事件的发布和订阅机制来进行组件之间的通信和协作。在上面的示例中，我们只处理了长度为4的向量。如果需要处理更长的向量，可以将向量长度补齐为向量大小的倍数，或者使用SIMD支持的其他方法。请注意，这只是一个简单的示例，实际的SIMD操作可能更复杂，具体的实现方式取决于你的需求和所选择的库。你可以根据自己的要求选择适合的库，并参考相应的文档和示例代码来学习和使用SIMD技术。需要注意的是，在实际的基于事件的系统中，通常还会有更多的功能和复杂性，例如异步处理、事件过滤等。
Java18新特性
weixin_47936134的博客
05-21 241
Java 18 引入了一系列新特性和改进，旨在增强开发者体验、提升性能和促进现代化编程实践。
Java 18：开启Java平台的新纪元
关注收藏，可以私信解决问题！
05-20 280
随着Java 18的发布，Java平台再次证明了其不断创新和适应现代软件开发需求的能力。作为长期支持（LTS）版本，Java 18不仅带来了性能上的提升，还引入了一系列令人兴奋的新特性和改进，为开发者提供了更多的工具来构建高效、安全且可维护的应用程序。
Java 18 新特性详解
最新发布
weixin_43977307的博客
05-21 415
Java 18通过一系列新特性的引入，继续推动Java平台向前发展，强化了其在跨平台开发、性能优化、语言简洁性及互操作性方面的优势。无论是对于初学者还是资深开发者，掌握这些新特性都将有助于提升开发效率和应用程序的性能。值得注意的是，部分特性作为孵化器项目或预览特性出现，意味着它们仍在进化中，开发者在实际项目中应用时应考虑其成熟度和长期兼容性。随着Java生态系统的不断演进，Java 18的新特性无疑为未来的Java版本奠定了坚实的基础。
jar包增量更新分析
junlaiyan的专栏
05-16 269
借助jdeps分析出jar包的增量文件
Spring-Cloud 微服务
weixin_65127444的博客
05-15 900
先来思考一个问题*通过上一章的操作，我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址（ip，端口）等硬编码到了代码中，这种做法存在许多问题：1.一旦服务提供者地址变化，就需要手工修改代码2. 一旦是多个服务提供者，无法实现负载均衡功能3.一旦服务变得越来越多，人工维护调用关系困难那么应该怎么解决呢，这时候就需要通过注册中心动态的实现。
java Map集合
09-14
Java的Map集合是一种键值对的数据结构，用于存储不重复的键和对应的值。根据引用，HashMap是Map的一个实现类，而LinkedHashMap是HashMap的子类，它们都可以用来存储键值对。HashMap和LinkedHashMap的主要区别在于迭代顺序的不同，HashMap不保证迭代顺序，而LinkedHashMap则按照插入顺序或者访问顺序进行迭代。 根据引用，如果你想获取Map集合的所有键，你可以使用setKey方法将Map集合中的键存储到Set集合中。然后，你可以使用迭代器或者foreach循环遍历Set集合来获取Map集合的每一个键。接着，你可以使用get(key)方法来获取对应的值。 根据引用，如果你想同时获取Map集合中的键和值，你可以使用Entry对象。可以使用Map的entrySet方法将Map集合中的多个Entry对象存入一个Set集合中。然后，你可以遍历Set集合来获取每一个Entry对象，使用Entry中的getKey方法来获取键，使用getValue方法来获取值。 总结起来，你可以使用HashMap或者LinkedHashMap来存储键值对。如果只关心键，可以使用setKey方法将键存储到Set集合中，然后遍历Set集合获取每一个键。如果同时需要键和值，可以使用Entry对象，通过entrySet方法将Entry对象存储到Set集合中，然后遍历Set集合获取每一个Entry对象，使用getKey方法获取键，使用getValue方法获取值。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

沐鑫本鑫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值