【Java】Map介绍和使用

【1】Map使用场景

       Map是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关。对于静态类型的查找来说，一般直接遍历或者用二分查找【不会对区间进行插入和删除操作】

  而在现实生活中的查找比如：

根据姓名查询考试成绩

通讯录，即根据姓名查询联系方式

不重复集合，即需要先搜索关键字是否已经在集合中    

 以上等可能在查找时进行一些插入和删除的操作，即动态查找，就需要用Map进行一系列操作。

注：Map最重要的特性就是去重！

       当我们平常在做题时，遇到删除重复数据，或者找每个数据重复的此时等..都可以用Map来解决

【2】概念

Map是一个接口类，该类没有继承自Collection，该类中存储的是<K,V>结构的键值对，并且K一定是唯一的，不能重复。

<K,V>使用的是 key-value模型：

key-value 模型中 key 和 value 是一个整体，就类似于 我们一提起齐天大圣，就想起孙悟空。key-value模型就是类似于这样的一组组合。【key 和 value 互相修饰】

Map使用时一些注意点：

Map是一个接口，不能直接实例化对象，如果要实例化只能实例化其实现类TreeMap或者HashMap。

Map 中存放键值对的 Key 是唯一的， value 是可以重复的

Map 中的 Key 可以全部分离出来，存储到 Set 中 来进行访问 ( 因为 Key 不能重复 ) 。

Map 中的 value 可以全部分离出来，存储在 Collection 的任何一个子集合中 (value 可能有重复 ) 。

Map 中键值对的 Key 不能直接修改， value 可以修改，如果要修改 key ，只能先将该 key 删除掉，然后再来进行重新插入。

【3】Map 的常用方法

Map是接口类，不能实例化对象，所以只能实例化其实现类TreeMap或者HashMap

以下以TreeMap为例

1、put方法 设置 key 对应的 value【放置元素】

  public static void main(String[] args) {
        Map<String,Integer> map = new TreeMap<>();
        map.put("abc",10);
        map.put("hello",20);
        map.put("hhf",23);
        System.out.println(map);//Map类重写了toString方法
        map.put("abc",20);//修改"abc"对应的value值
        System.out.println(map);

2、get方法 返回 key 对应的值，key不存在则返回null

  public static void main(String[] args) {
        Map<String,Integer> map = new TreeMap<>();
        map.put("abc",10);
        System.out.println(map.get("abc"));//10
        System.out.println(map.get("key"));//null

3、getOrDefault 方法 返回 key 对应的 value，key 不存在，返回默认值

 public static void main(String[] args) {
        Map<String,Integer> map = new TreeMap<>();
        map.put("abc",10);
        System.out.println(map.getOrDefault("abc", 19));//找到key值，则返回对应的value,输出10
        System.out.println(map.getOrDefault("hello",20));//未找到key值，则返回默认值，输出20

4、remove 删除 key 对应的映射关系

public static void main(String[] args) {
        Map<String,Integer> map = new TreeMap<>();
        map.put("abc",10);
        map.put("hello",20);
        map.put("hhf",23);
        System.out.println(map);
        map.remove("abc");
        System.out.println(map);

5、Set<K> keySet()  返回所有 key 的不重复集合，不包含value

public static void main(String[] args) {
        Map<String,Integer> map = new TreeMap<>();
        map.put("abc",10);
        map.put("hello",20);
        map.put("hhf",23);
        map.put("world",20);
        Set<String> set = map.keySet();
        System.out.println(set);

'<V>'中V为 key的包装类型

set 中使用的模型是 key模型。

6、Collection<V> values() 返回所有 value 的可重复集合

 public static void main(String[] args) {
        Map<String,Integer> map = new TreeMap<>();
        map.put("abc",10);
        map.put("hello",20);
        map.put("hhf",23);
        map.put("world",20);
        Collection<Integer> list = map.values();
        System.out.println(list);

'<V>'中V为 value 的包装类型

7、Set<Map.Entry<K, V>> entrySet() 返回所有的 key-value 映射关系【重要】

entrySet方法能把TreeMap中的键值对打包，放入Set集合中。

  public static void main(String[] args) {
        Map<String,Integer> map = new TreeMap<>();
        map.put("abc",10);
        map.put("hello",20);
        map.put("hhf",23);
       Set<Map.Entry<String,Integer>> entrySet = map.entrySet();

上述代码中，map调用entrySet方法，把其内部的值全部打包为  Map.Entry<String,Integer> 类型，然后存储在 entrySet 变量中。

8、boolean containsKey(Object key) 判断是否包含 key

   public static void main(String[] args) {

public static void main(String[] args) {
        Map<String,Integer> map = new TreeMap<>();
        map.put("abc",10);
        map.put("hello",20);
        map.put("hhf",23);
        System.out.println(map.containsKey("hello"));// true
        System.out.println(map.containsKey("world"));// fasle
    }

9、boolean containsValue(Object value) 判断是否包含 value

public static void main(String[] args) {
        Map<String,Integer> map = new TreeMap<>();
        map.put("abc",10);
        map.put("hello",20);
        map.put("hhf",23);
        System.out.println(map.containsValue(20));// true
        System.out.println(map.containsValue(50));// false
    }

【4】关于Map.Entry<K, V>的说明

        Map.Entry<K, V> 是Map内部实现的用来存放<key, value>键值对映射关系的内部类

Entry是Map接口里面的接口

所以 TreeMap类实现Map接口时，也会具体实现Entry接口，HashMap内部也是如此

1、Map.Entry的作用

       Map.Entry是为了更方便的输出Map键值对。一般情况下，要输出Map中的key 和 value  是先得到key的集合keySet()，然后再迭代（循环）由每个key得到每个value。values()方法是获取集合中的所有值，不包含键，没有对应关系。而Entry可以一次性获得这两个值。

2、Map.Entry中的常用方法

这些方法都会结合着for循环进行操作，具体使用往下看

3、使用Map.Entry遍历Map集合

public static void main(String[] args) {
        Map<String,Integer> map = new TreeMap<>();
        map.put("abc",10);
        map.put("hello",20);
        map.put("hhf",23);
        Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
        for(Map.Entry<String,Integer> entry : entrySet){
            System.out.println("key: "+entry.getKey()+" value: "+entry.getValue());
        }
    }

【5】简单介绍 TreeMap和HashMap

1、TreeMap

TreeMap底层是一颗搜索树。而搜索树的插入是需要比较大小的，而TreeMap通过key来比较大小！所以key一定是编译器可以自动比较大小的。

public static void main(String[] args) {
        Map<Integer,Integer> map1 = new TreeMap<>();
        Map<String,Integer> map2 = new TreeMap<>();
        map1.put(2,5);
        map1.put(1,9);
        map1.put(10,4);
        map2.put("hello",2);
        map2.put("world",20);
        map2.put("weiwei",35);
        System.out.println(map1);
        System.out.println(map2);
    }

当我们实现TreeMap类后，往里面传入自定义类就会报错！

所以，要想放入自定义类型，就要满足一下两个条件之一

       1.自定义类型要实现Comparable ，重写compareTo

class People implements Comparable{
    public int age;
    public int money;
    @Override
    public int compareTo(Object o) {
        return 0;
    }
}
public class Test3 {
    public static void main(String[] args) {
       Map<People,Integer> map = new TreeMap<>();
        map.put(new People(),10);
        System.out.println(map);
    }
}

       2.实例化对象时传入一个比较器

class People implements{
    public int age;
    public int money;
}
public class Test3 {
    public static void main(String[] args) {
       Map<People,Integer> map = new TreeMap<>(new Comparator<People>() {
           @Override
           public int compare(People o1, People o2) {
               return 0;
           }
       });
        map.put(new People(),10);
        System.out.println(map);
    }
}

以上两种方法，其实都是在告诉集合，自定义类型如何比较大小

同时不能放null，否则就会报错

如果两次put的key值一样，那么val值就会被替换掉

2、HashMap

        HashMap底层是一颗红黑树，存储的无序的，所以自定义类型和null都能直接存储，不会报错。

3、TreeMap和HashMap的区别

TreeMap 和 HashMap 底层实现逻辑不同，所以插入时间、删除时间、插入方法等都不相同

具体如下：

插入/删除/查找时间 复杂度		O(1)
是否有序	关于Key有序	无序