Map接口

方法：

  • public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
  • public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
  • public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
  • boolean containsKey(Object key) 判断集合中是否包含指定的键。
  • public Set keySet(): 获取Map集合中所有的键，存储到Set集合中。
  • public Set> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)

其他方法

  1. put(K key, V value)    有添加和替换功能
  2. putAll(Map m)    添加一个Map的元素
  3. clear()    清空集合
  4. remove(Object key)    根据键删除一个元素
  5. containsKey()    判断集合是否包含指定的键
  6. containsValue()    判断集合是否包含指定的值
  7. isEmpty()    判断集合是否为空
  8. get(Object key)    根据键获取值
  9. keySet()    获取所有的键
  10. values()    获取所有的值
  12. size()    获取集合元素的个数

遍历

三种遍历方式

  1. public class HashMapIterator {
  2.     public static void main(String[] args) {
  3.         Map<String, Integer> map = new HashMap<>();
  4.         map.put("a", 1);
  5.         map.put("b", 2);
  6.         map.put("c", 3);
  8.         //迭代器
  9.         Set<String> set = map.keySet();
  10.         Iterator<String> it = set.iterator();
  11.         while (it.hasNext()) {
  12.             String key = it.next();
  13.             Integer value = map.get(key);
  14.             System.out.println(key + "--->" + value);
  15.         }
  17.         //for set
  18.         for (String key : map.keySet()) {
  19.             Integer value = map.get(key);
  20.             System.out.println(key + "--->" + value);
  21.         }
  23.         // for entry
  24.         for (Map.Entry<String, Integer> e : map.entrySet()) {
  25.             System.out.println(e.getKey() + "--->" + e.getValue());
  26.         }
  28.     }
  29. }

Entry/键值对对象

Map中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在在Map中是一一对应关系，这一对对象又称做Map中的一个Entry(项)。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。
既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值得方法：

  1. public K getKey()：获取Entry对象中的键。
  2. public V getValue()：获取Entry对象中的值。

在Map集合中也提供了获取所有Entry对象的方法：

  1. public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

eg

  1. public static void main(String[] arge){
  2.        HashMap<String,String> map = new HashMap<String,String>();
  3.        map.put("北京","北京");
  4.        map.put("广东","广州");
  5.        map.put("山东","济南");
  6.        map.put("浙江","杭州");
  7.        map.put("江苏","杭州");
  8.        Set<Entry<String,String>> set = map.entrySet();
  9.        for (Entry<String,String> entry: set){
  10.            System.out.println(entry.getKey()+"："+entry.getValue());
  11.        }
  12.    }

存储自定义对象

  1. @Override
  2.    public boolean equals(Object o) {
  3.        if (this == o)
  4.            return true;
  5.        if (o == null || getClass() != o.getClass())
  6.            return false;
  7.        Student student = (Student) o;
  8.        return age == student.age && Objects.equals(name, student.name);
  9.    }
  11.    @Override
  12.    public int hashCode() {
  13.        return Objects.hash(name, age);
  14.    }

LinkedHashMap

我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？在HashMap下面有一个子类LinkedHashMap，它是链表和哈希表组合的一个数据存储结构。

  1. public static void main(String[] arg) {
  2.         LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
  3.         map.put("中国", "CHN");
  4.         map.put("美国", "USA");
  5.         map.put("俄罗斯", "RUS");
  6.         map.put("法国", "FRA");
  7.         map.put("英国", "UK");
  8.         Set<Entry<String, String>> entrySet = map.entrySet();
  9.         for (Entry<String, String> entry : entrySet) {
  10.             System.out.println(entry.getKey() + "  " + entry.getValue());
  11.         }
  12.     }

参考

https://www.cnblogs.com/liyihua/p/12199448.html