Map接口和常用方法

Posted 2022-04-08 程序员超时空

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Map接口和常用方法相关的知识，希望对你有一定的参考价值。

Map接口和常用方法

Map接口实现类的特点[很实用]

注意:
这里讲的是JDK8的Map接口特点

Map 与 Collection 并列存在。用于保存具有映射关系的数据: Key-Value
Map 中的 key 和 value 可以是任何引用类型的数据，会封装到 HashMap$Node 对象中
Map 中的 key 不允许重复，原因和 HashSet 一样，前面博文中分析过源码.
Map 中的 value 可以重复
Map 的 key 可以为 null , value 也可以为 null ,注意 key 为 null ,只能有一个，
value为null ,可以多个.
常用 String 类作为 Map 的 key
key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到对应的 value

package www.xz.map_;

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

/**
- @author 许正
- @version 1.0
  */
  @SuppressWarnings(“all”)
  public class Map_
  public static void main(String[] args)
  //1) Map 与 Collection 并列存在。用于保存具有映射关系的数据: Key-Value
  //2) Map 中的 key 和 value 可以是任何引用类型的数据，会封装到 HashMap$Node 对象中
  //3) Map 中的 key 不允许重复，原因和 HashSet 一样，前面博文中分析过源码.
  //4) Map 中的 value 可以重复
  //5) Map 的 key 可以为 null , value 也可以为 null ,注意 key 为 null ,只能有一个，
  // value为null ,可以多个.
  //6) 常用 String 类作为 Map 的 key
  //7) key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到对应的 value
  Map map = new HashMap();
  map.put(“no1”, “许正”);//k-v
  map.put(“no2”, “张三丰”);//k-v
  map.put(“no1”, “张无忌”);//当有相同的k，就等价于替换。
  map.put(“no3”, “张无忌”);//k-v
  map.put(null, null);//等价于替换
  map.put(null, “abc”);//k-v
  map.put(“no4”, null);
  map.put(“no5”, null);
  map.put(1, “豪豪”);
  map.put(new Object(), “秋山帅豪”);
```
 //通过get() 方法，传入 key ，会返回相对应的 value
 System.out.println(map.get("no3"));
 System.out.println("map=" + map);
```

**8. Map存放数据的key-value示意图，一对k-v是放在一个HashMap$Node中的，
因为Node实现了Entry 接口，有些书上也说一对k-v就是一个Entry(如图) **

package www.xz.map_;

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

/**
 * @author 许正
 * @version 1.0
 */
@SuppressWarnings("all")
public class MapSource_ 
    public static void main(String[] args) 

        Map map = new HashMap();
        map.put("no1", "许正");//k-v
        map.put("no2", "张三丰");//k-v

        //1. k-v最后是HashMap$Node node = newNode (hash, key, vaLue, nuLl)
        //2. k-v为了方便程序员的遍历，还会创建EntrySet 集合，该集合存放的元素的类型Entry, 而一个Entry
        //   对象就有k,v EntrySet<Entry<K,V>> 即: transient Set<Map。Entry<K,V>> entrySet ;
        //3. entrySet 中，定 义的类型是Map.Entry ，但是实际上存放的还是HashMap$Node
        //   这是因为 static class Node<K, V> impLements Map。Entry<K, V>
        //4. 当把 HashMap$Node 对象存放到entrySet 就方便我们的遍历
        Set set = map.entrySet();//HashMap$EntrySet
        System.out.println(set.getClass());
        for (Object obj : set) 
            //System.out.println(obj. getClass()); //HashMap$Node
            //为了从HashMap$Node 取出k-v
            //1. 先做一个向下转型
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "-" + entry.getValue());
        

        Set keySet = map.keySet();
        System.out.println(keySet.getClass());
        Collection values = map.values();
        System.out.println(values.getClass());

Map接口常用方法

put:添加
remove:根据键删除映射关系
get:根据键获取值
size:获取元素个数
isEmpty:判断个数是否为0
clear:清除
containsKey:查找键是否存在

package www.xz.map_;

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

/**
- @author 许正
- @version 1.0
  */
  @SuppressWarnings(“all”)
  public class MapMethod
  public static void main(String[] args)
  //演示Map接口的常用方法
```
 HashMap map = new HashMap();
 map.put("邓超", new Book("", 100));
 map.put("邓超", "孙丽");
 map.put("王宝强", "马蓉");
 map.put("宋喆", "马蓉");
 map.put("秋山帅豪", null);
 map.put(null, " 刘亦菲");
 map.put("鹿晗", " 关晓彤");

 System.out.println("map=" + map);
```
// 1) remove:根据键删除映射关系
map.remove(null);
System.out.println(“map” + map);
// 2) get:根据键获取值
Object o = map.get(“秋山帅豪”);
System.out.println(“帅豪对应的对象：” + o);
// 3) size:获取元素个数
System.out.println(map.size());
// 4) isEmpty:判断个数是否为0
System.out.println(map.isEmpty());
// 5) clear:清除
map.clear();
System.out.println(“map=” + map);
// 6) containsKey:查找键是否存在
System.out.println(map.containsKey(“秋山帅豪”));

class Book
private String name;
private int num;
```
public Book(String name, int num) 
    this.name = name;
    this.num = num;
```

Map接口遍历方法

Map遍历的示意图(比List ,和Set复杂点，但是基本原理一样)

Map遍历方式案例演示

containsKey:查找键是否存在
keySet:获取所有的键
entrySet:获取所有关系k-v

values:获取所有的值

package www.xz.map_;

import java.util.*;

/**

@author 许正

@version 1.0
*/
@SuppressWarnings(“all”)
public class MapFor
public static void main(String[] args)
HashMap map = new HashMap();
map.put(“邓超”, new Book(“”, 100));
map.put(“邓超”, “孙丽”);
map.put(“王宝强”, “马蓉”);
map.put(“宋喆”, “马蓉”);
map.put(“秋山帅豪”, null);
map.put(null, “刘亦菲”);
map.put(“鹿晗”, “关晓彤”);

 //第一组：先取出所有的 Key ，通过Key 取出对应的Value
 Set keySet = map.keySet();
 //(1) 增强for
 System.out.println("===第一种方式===");
 for (Object key : keySet) 
     System.out.println(key + "-" + map.get(key));
 
 //(2) 迭代器
 System.out.println("===第二种方式===");
 Iterator iterator = keySet.iterator();
 while (iterator.hasNext()) 
     Object next = iterator.next();
     System.out.println(next + "-" + map.get(next));
 

 //第二组：把所有的Value 取出
 Collection values = map.values();
 //这里可以使用所有的ColLections使用的遍历方法
 System.out.println("---取出所有的Value 增强for---");
 for (Object value : values) 
     System.out.println(value);
 
 System.out.println("---取出所有的Value 迭代器---");
 Iterator iterator2 = values.iterator();
 while (iterator2.hasNext()) 
     Object next = iterator2.next();
     System.out.println(next);
 

 //第三组:通过EntrySet 来获取k-v
 Set entrySet = map.entrySet();
 System.out.println("---使用EntrySet的 增强for(第三种)---");
 for (Object o : entrySet) 
     Map.Entry entry = (Map.Entry) o;
     System.out.println(entry.getKey() + "-" + entry.getValue());
 
 System.out.println("---使用EntrySet的 迭代器(第四种)---");
 Iterator iterator3 = entrySet.iterator();
 while (iterator3.hasNext()) 
     Object next = iterator3.next();
     Map.Entry next1 = (Map.Entry) next;
     System.out.println(next1.getKey() + "-" + next1.getValue());

MapExercise

package www.xz.map_;

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

/**
 * @author 许正
 * @version 1.0
 */
@SuppressWarnings("all")
public class MapExercise 
    public static void main(String[] args) 
        Map map = new HashMap();
        Employee jack = new Employee("jack", 19000, 1);
        Employee tom = new Employee("tom", 20000, 2);
        Employee marry = new Employee("marry", 15000, 3);
        map.put(jack.getId(), jack);
        map.put(tom.getId(), tom);
        map.put(marry.getId(), marry);

        Set set = map.keySet();
        System.out.println("遍历显示工资大于18000的员工：");
        for (Object o : set) 
            Object o1 = map.get(o);
            Employee o11 = (Employee) o1;
            if (o11.getSal() > 18000) 
                System.out.println(o11);
            
        

        //2. 使用EntrySet ->迭代器
        System.out.println("使用EntrySet ->迭代器:");
        Set set1 = map.entrySet();
        Iterator iterator = set1.iterator();
        while (iterator.hasNext()) 
            Object next =  iterator.next();
            Map.Entry entry = (Map.Entry) next;
            Employee employee = (Employee) entry.getValue();
            if (employee.getSal()>18000)
//                System.out.println(entry.getValue());
                System.out.println(employee);
            
        

    


class Employee 
    public String name;
    private double sal;
    private int id;

    public Employee(String name, double sal, int id) 
        this.name = name;
        this.sal = sal;
        this.id = id;
    

    public String getName() 
        return name;
    

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

    public double getSal() 
        return sal;
    

    public void setSal(double sal) 
        this.sal = sal;
    

    public double getId() 
        return id;
    

    public void setId(int id) 
        this.id = id;
    

    @Override
    public String toString() 
        return "Employee" +
                "name='" + name + ''' +
                ", sal=" + sal +
                ", id=" + id +
                '';

HashMap小结

Map接口的常用实现类: HashMap、Hashtable和Properties.
HashMap是Map接口使用频率最高的实现类。
HashMap是以key-val对的方式来存储数据[案例Entry]
key不能重复，但是值可以重复,允许使用null键和null值。
如果添加相同的key ,则会覆盖原来的key-val等同于修改.(key不会替换，val会替换)
与HashSet一样，不保证映射的顺序，因为底层是以hash表的方式来存储的.
HashMap没有实现同步，因此是线程不安全的

HashMap底层机制及源码剖析

示意图

(k,v)是一个Node实现了Map.Entry<K,V>，查看HashMap的源码可以看到.
jdk7.0的hashmap底层实现[数组+链表]，jdk8.0底层[数组+链表+红黑树]

扩容机制和[HashSet相同]

HashMap底层维护了Node类型的数组table,默认为null
当创建对象时，将加载因子(loadfactor)初始化为0.75.
当添加key-val时，通过key的哈希值得到在table的索引。然后判断该索引处是否有元素，
如果没有元素直接添加。如果该索引处有元素，继续判断该元素的key是否和准备加入的
key相等，如果相等，则直接替换val;如果不相等需要判断是树结构还是链表结构，做出
相应处理。如果添加时发现容量不够则需要扩容。
第1次添加，则需要扩容table容量为16,临界值(threshold)为12.
以后再扩容，则需要扩容table容量为原来的2倍，临界值为原来的2倍,即24,依次类推.
在Java8中，如果一条链表的元素个数超过TREEIFY THRESHOLD(默认是8),并且
table的大小>= MIN_TREEIFY_CAPACITY(默认64),就会进行树化(红黑树)

追一下源码！！！

package www.xz.map_;

import java.util.HashMap;

/**
 * @author 许正
 * @version 1.0
 */
@SuppressWarnings("all")
public class HashMapSource01 
    public static void main(String[] args) 
        HashMap map = new HashMap();
        map.put("java", 10);//ok
        map.put("php", 10);//ok
        map.put("java", 20);//替换value

        System.out.println("map=" + map);

HashMap扩容数化触发

package www.xz.map_;

import java.util.HashMap;
import java.util.Objects;

/**
 * @author 许正
 * @version 1.0
 */
@SuppressWarnings("all")
public class HashMapSource02 
    public static void main(String[] args) 
        HashMap map = new HashMap();
        for (int i = 1; i <=12 ; i++) 
            map.put(new A(i),"hello");
        

        System.out.println(map);
    


class A
    private int num;

    public A(int num) 
        this.num = num;
    

    @Override
    public int hashCode() 
        return 100;
    

    @Override
    public String toString() 
        return "
A" +
                "num=" + num +
                '';

Map接口实现类Hashtable

HashTable的基本介绍

存放的元素是键值对:即K-V
hashtable的键和值都不能为null,否则会抛出NullPointerException
hashTable使用方法基本上和HashMap一样
hashTable是线程安全的，hashMap是线程不安全的
简单看下底层结构

//简单说明一下Hashtable的底层
//1.底层有数组Hashtable$Entry[] 初始化大小为11
//2.临界值threshold 8 = 11 * 0.75
//3.扩容:按照自己的扩容机制来进行即可。
//4.执行方法addEntry(hash, key, value, index); 添加K-V封装到Entry
//5.当if (count >=threshold)满足时，就进行扩容
//5.按照int newCapacity = (oldCapacity << 1) + 1;的大小扩容。

HashTable的应用案例

debug看一下table表是如何扩容的

package www.xz.map_;

import java.util.Hashtable;

/**
 * @author 许正
 * @version 1.0
 */
@SuppressWarnings("all")
public class HashTableExercise 
    public static void main(String[] args) 
        Hashtable hashtable = new Hashtable();
        hashtable.put("john",100);
//        hashtable.put(null,100);
//        hashtable.put("john",null);
        hashtable.put("lucy",100);
        hashtable.put("lic",100);
        hashtable.put("lic",80);

        hashtable.put("hello1",1);
        hashtable.put("hello2",1);
        hashtable.put("hello3",1);
        hashtable.put("hello4",1);
        hashtable.put("hello5",1);
        hashtable.put("hello6",1);

        System.out.println(hashtable);

Hashtable 和HashMap对比

Map接口实现类Properties

基本介绍

Properties类继承自Hashtable类并且实现了 Map接口，也是使用一种键值对的形
式来保存数据。
他的使用特点和Hashtable类似
Properties 还可以用于从xxx.properties文件中，加载数据到Properties类对象，
并进行读取和修改
说明:工作后xxx.properties 文件通常作为配置文件，这个知识点在IO流举例，有兴
趣可先看文章[点击跳转](https:/ /www.cnblogs.com/ xudong bupt/ p/3758136.html)

package www.xz.map_;

import java.util.Properties;

/**
- @author 许正
- @version 1.0
  */
  @SuppressWarnings(“all”)
  public class Properties_
  public static void main(String[] args)
  Properties properties = new Properties();
  //1. Properties 继承Hashtable
  //2. 可以通过k-v存放数据，当然key和value不能为null
  properties.put(“john”, 100);
  properties.put(“lucy”, 100);
  properties.put(“lic”, 100);
  properties.put(“lic”, 88);//替换
```
 //通过key 获取对应值
 System.out.println(properties.get("lic"));

 //删除
 properties.remove("lic");
 System.out.println(properties);

 //修改(直接覆盖)
 properties.put("john","jack");
 System.out.println(properties);

 //查找
 System.out.println(properties.getProperty("john"));
```

总结-开发中如何选择集合实现类

在开发中，选择什么集合实现类，主要取决于业务操作特点，然后根据集合实现类特性进行
选择，分析如下:

先判断存储的类型(一组对象或一组键值对)
一组对象: Collection接口
允许重复: List
增删多: LinkedList [底层维护了一个双向链表]
改查多: ArrayList [底层维护Object类型的可变数组]
不允许重复: Set
无序: HashSet [底层是HashMap ,维护了一个哈希表即(数组+链表+红黑树)]
排序: TreeSet
插入和取出顺序一致: LinkedHashSet , 维护数组+双向链表
一组键值对: Map
键无序: HashMap [底层是:哈希表jdk7: 数组+链表，jdk8: 数组+链表+红黑树]
键排序: TreeMap
键插入和取出顺序一致: LinkedHashMap
读取文件Properties

Map接口实现类TreeMap

package www.xz.map_;

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

/**
 * @author 许正
 * @version 1.0
 */
@SuppressWarnings("all")
public class TreeMap_ 
    public static void main(String[] args) 
//        TreeMap treeMap = new TreeMap();
        TreeMap treeMap = new TreeMap(new Comparator() 
            @Override
            public int compare(Object o1, Object o2) 
                //按照首字母倒序
//                return ((String)o2).compareTo((String)o1);
                //按照字符串长度
                return ((String)o1).length()-((String)o2).length();
            
        );
        treeMap.put("jack", "杰克");
        treeMap.put("tom", "汤姆");
        treeMap.put("kristina", "克雷丝缇娜");
        treeMap.put("smith", "史密斯");

        System.out.println(treeMap);

以上是关于Map接口和常用方法的主要内容，如果未能解决你的问题，请参考以下文章

Map接口和常用方法

Map的学习

面试半年！三面阿里，四面蚂蚁金服，居然倒在了一个Java集合之Map上？

java Map接口

Map接口的一些常用方法