Java集合Map总结

目录一、Map集合概述二、Map集合体系Map集合体系特点：Map集合实现类特点：三、Map集合常用API四、遍历方式方式一：键找值方式二：键值对方式三：Lambda表达式五、HashMapHashMap的特点：HashMap的底层原理：六、LinkedHashMapLinkedHashMap的特点：七、TreeMapTreeMap集合的特点：自定义排序规则：一、Map集合概述Map集合是一种双列

董哩哩

509人浏览 · 2022-01-10 21:09:56

董哩哩 · 2022-01-10 21:09:56 发布

目录

一、Map集合概述

二、Map集合体系

Map集合体系特点：

Map集合实现类特点：

三、Map集合常用API

四、遍历方式

方式一：键找值

方式二：键值对

方式三：Lambda表达式

HashMap的特点：

HashMap的底层原理：

六、LinkedHashMap

LinkedHashMap的特点：

TreeMap集合的特点：

自定义排序规则：

一、Map集合概述

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

二、Map集合体系

Map集合体系特点：

Map集合的特点都是有键决定的
Map集合的键是无序的，不重复的，无索引的，值不做要求（可以重复）
Map集合后面重复的键对应的值会覆盖前面重复键的值
Map集合的键值对都可以为null

Map集合实现类特点：

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

三、Map集合常用API

package com.itheima.d6_map_ApI;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

import java.util.*;

/*
map集合常用API
        目标：Map集合的常用API(重点中的重点)
     - public V put(K key, V value):  把指定的键与指定的值添加到Map集合中。
     - public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
     - public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
     - public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
     - public Collection <v> values():获取Map集合中所有的值，存储到Collection集合中
     - public boolean containKey(Object key):判断该集合中是否有此键。
     - public boolean containValue(Object value):判断该集合中是否有此值。
*/
public class mapDemo {
    public static void main(String[] args) {
        //1、public V put(K key, V value):  把指定的键与指定的值添加到Map集合中。
        Map<String,Integer> maps = new HashMap<>();
        maps.put("鸿星尔克",10);
        maps.put("JAVA",5);
        maps.put("枸杞",16);
        maps.put("西凤酒",100);

        //2、 public V remove(Object key): 把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值。
        maps.remove("JAVA");
        System.out.println(maps);

        //3、public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
        System.out.println(maps.get("鸿星尔克"));

        //4、public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
        Set<String> set =  maps.keySet();
        System.out.println(set);

        System.out.println(maps.keySet());

        //5、public Collection <v> values():获取Map集合中所有的值，存储到Collection集合中
        Collection<Integer> value = maps.values();
        System.out.println(value);

        System.out.println(maps.values());

        //6、 public boolean containKey(Object key):判断该集合中是否有此键。
        System.out.println(maps.containsKey("鸿星尔克"));
        System.out.println(maps.containsKey("茅台"));

        //7、public boolean containValue(Object value):判断该集合中是否有此值。
        System.out.println(maps.containsValue(10));
        System.out.println(maps.containsValue(19));

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

        //9、合并其他map集合
        Map<String,Integer> map1 = new HashMap<>();
        map1.put("JAVA1",10);
        map1.put("JAVA2",20);
        map1.put("JAVA3",30);
        Map<String,Integer> map2 = new HashMap<>();
        map2.put("java",30);
        map2.put("JAVA2",40);

        map1.putAll(map2);
        System.out.println(map1);
        System.out.println(map2);

        //10、判断集合是否为空，为空返回ture
        System.out.println(map1.isEmpty());
    }
}

四、遍历方式

方式一：键找值

package com.itheima.d7_map_traversal;

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

/*遍历方法一：
    键找值
* */
public class mapDemo1 {
    public static void main(String[] args) {
        Map<String, Integer> maps = new HashMap<>();
        maps.put("鸿星尔克", 10);
        maps.put("JAVA", 5);
        maps.put("枸杞", 16);
        maps.put("西凤酒", 100);

        //1、键找值：第一步先遍历集合中全部键
        Set<String> set = maps.keySet();
        //2、通过键遍历对应的值
        for (String sets : set) {
            int value = maps.get(sets);
            System.out.println(sets+"=====>"+value);
        }
    }
}


结果：JAVA=====>5
      西凤酒=====>100
      枸杞=====>16
      鸿星尔克=====>10

方式二：键值对

package com.itheima.d7_map_traversal;

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

/*
遍历方法二：
    键值对：通过调用Map方法entrySet把Map集合转换成Set集合形式 maps.entrySet();
    {JAVA=5, 西凤酒=100, 枸杞=16, 鸿星尔克=10}转换成
    Set<Map.Entry<String, Integer>> {(JAVA=5), (西凤酒=100), (枸杞=16), (鸿星尔克=10)}

*/
public class mapDemo2 {
    public static void main(String[] args) {
        Map<String, Integer> maps = new HashMap<>();
        maps.put("鸿星尔克", 10);
        maps.put("JAVA", 5);
        maps.put("枸杞", 16);
        maps.put("西凤酒", 100);

        //1、把Map集合转换成Set集合
        Set<Map.Entry<String, Integer>> entries = maps.entrySet();
        //2、开始遍历
        for (Map.Entry<String, Integer> entry:entries){
            String key = entry.getKey();
            int value = entry.getValue();
            System.out.println(key+"======>"+value);
        }
    }
}


结果：JAVA======>5
西凤酒======>100
枸杞======>16
鸿星尔克======>10

方式三：Lambda表达式

package com.itheima.d7_map_traversal;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

/*
遍历方法三：
    Lambda表达式
*/
public class mapDemo3 {
    public static void main(String[] args) {
        Map<String, Integer> maps = new HashMap<>();
        maps.put("鸿星尔克", 10);
        maps.put("JAVA", 5);
        maps.put("枸杞", 16);
        maps.put("西凤酒", 100);

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

        maps.forEach(( k,  v)-> {
                System.out.println(k+"======>"+v);
        });
    }
}


结果：JAVA======>5
西凤酒======>100
枸杞======>16
鸿星尔克======>10

五、HashMap

HashMap的特点：

特点是由键决定的：无序、不重复、无索引
没有额外需要学习的特有方法，直接使用Map里面的方法就可
HashMap跟HashSet底层原理是一模一样的，都是哈希表结构，知识HashMap的每个元素包含两个值而已

HashMap的底层原理：

依赖HashCode方法和equals方法保证键的唯一。
如果键要存储的是自定义对象，需要重写HashCode和equal方法。
基于哈希表。增删改查都好。

六、LinkedHashMap

LinkedHashMap的特点：

特点是由键决定的：有序、不重复、无索引
这里的有序是指保证存储和取出的元素顺序一致
原理：底层数据结构依然是哈希表，只是每个键值对元素又额外的多了一个双链表的机制记录存储的顺序

package com.itheima.d9_map_impl;

import java.util.LinkedHashMap;
import java.util.Map;
/*
LinkedHashMap特点：有序，不重复，有索引
    基本原理：基于哈希表加双向链表
*/
public class LinkedHashMapDemo {
    public static void main(String[] args) {
        Map<String,Integer> maps = new LinkedHashMap<>();
        maps.put("JAVA",10);
        maps.put("HTML",20);
        maps.put("JAVA",30);//覆盖前面的数据
        maps.put("JSP",35);
        maps.put("C#",42);

        System.out.println(maps);
    }
}

结果：{JAVA=30, HTML=20, JSP=35, C#=42}

七、TreeMap

TreeMap集合的特点：

特点是由键决定的：可排序、不重复、无索引
可排序：按照数据的大小默认升序（有小到大）排序。只能对键排序
TreeMap跟TreeSet底层原理是一样的

依赖HashCode方法和equals方法保证键的唯一。
如果键要存储的是自定义对象，需要重写HashCode和equal方法。
基于哈希表。增删改查都好。

自定义排序规则：

方法一：实现Comparable接口重写里面的compareTo方法来制定比较规则。

package com.itheima.d3_collections;

public class Apple implements Comparable<Apple> {
    private String name;
    private String color;
    private double price;
    private int weight;

    public Apple() {}

    public Apple(String name, String color, double price, int weight) {
        this.name = name;
        this.color = color;
        this.price = price;
        this.weight = weight;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    @Override
    public int compareTo(Apple apple) {
        return this.weight-apple.weight;
    }

    @Override
    public String toString() {
        return "Apple{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                ", price=" + price +
                ", weight=" + weight +
                '}';
    }
}

package com.itheima.d9_map_impl;

import com.itheima.d3_collections.Apple;

import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;

/*
TreeMap特点：排序，不重复，无索引
    原理：跟TreeSet底层原理是一样的
*/
public class TreeMapDemo {
    public static void main(String[] args) {
        Map<Apple,String> maps =new TreeMap<>();
        maps.put(new Apple("红富士","红色",9.9,500),"西安");
        maps.put(new Apple("青苹果","青色",19.2,400),"宝鸡");
        maps.put(new Apple("黄苹果","黄色",11.2,300),"榆林");
        maps.put(new Apple("蓝苹果","蓝色",12.2,500),"咸阳");

        System.out.println(maps);
    }
}


结果：{Apple{name='黄苹果', color='黄色', price=11.2, weight=300}=榆林, Apple{name='青苹果', color='青色', price=19.2, weight=400}=宝鸡, Apple{name='红富士', color='红色', price=9.9, weight=500}=咸阳}

方法二：TreeSet集合有参构造器，可以设置Comparator接口对应的比较器对象，来制定比较规则。

package com.itheima.d9_map_impl;

import com.itheima.d3_collections.Apple;

import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;

/*
TreeMap特点：排序，不重复，无索引
    原理：跟TreeSet底层原理是一样的
*/
public class TreeMapDemo {
    public static void main(String[] args) {
        Map<Apple,String> maps =new TreeMap<>(( t1,  t2)-> {
                return Double.compare(t2.getPrice(),t1.getPrice());
        });
        maps.put(new Apple("红富士","红色",9.9,500),"西安");
        maps.put(new Apple("青苹果","青色",19.2,400),"宝鸡");
        maps.put(new Apple("黄苹果","黄色",11.2,300),"榆林");
        maps.put(new Apple("蓝苹果","蓝色",12.2,500),"咸阳");

        System.out.println(maps);
    }
}


结果：{Apple{name='青苹果', color='青色', price=19.2, weight=400}=宝鸡, Apple{name='蓝苹果', color='蓝色', price=12.2, weight=500}=咸阳, Apple{name='黄苹果', color='黄色', price=11.2, weight=300}=榆林, Apple{name='红富士', color='红色', price=9.9, weight=500}=西安}

CSDN学习社区

CSDN联合极客时间，共同打造面向开发者的精品内容学习社区，助力成长！

更多推荐

cover

用 OpenAI Assistants 做大模型应用开发

CSDN学习社区

cover

1 小时解读鸿蒙 10 大热点问题

CSDN学习社区

cover

1 小时解读鸿蒙 10 大热点问题

CSDN学习社区

所有评论(0)

查看更多评论

董哩哩

@weixin_51500673

已为社区贡献1条内容