Map接口

一、概述

java.util接口Map<K,V>
类型参数：K—此映射所维护的键的类型 V—映射值得类型
也叫哈希表，散列表。常用于存键值对结构的数据。
其中的键不能重复，值可以重复。

二、特点

可以根据键提取对应的值
键不允许重复，如果重复，值会被覆盖
存放的都是无序数据
初始容量是16，默认的加载因子是0.75

三、常用方法

void clear()
          从此映射中移除所有映射关系（可选操作）。
 boolean containsKey(Object key)
          如果此映射包含指定键的映射关系，则返回 true。
 boolean containsValue(Object value)
          如果此映射将一个或多个键映射到指定值，则返回 true。
 V get(Object key)
          返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
 boolean isEmpty()
          如果此映射未包含键-值映射关系，则返回 true。
 V put(K key, V value)
          将指定的值与此映射中的指定键关联（可选操作）。
 void putAll(Map<? extends K,? extends V> m)
          从指定映射中将所有映射关系复制到此映射中（可选操作）。
 V remove(Object key)
          如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
 int size()
         返回此映射中的键-值映射关系数。
Set<Map.Entry<K,V>> entrySet()
          返回此映射所包含的映射关系的 Set 视图。

代码测试

public class HashMapDemo {
    public static void main(String[] args) {
        // 1.创建对象
        Map<String,Integer> map = new HashMap<>();
        // 2.调用方法
        //V put(K key, V value)
        //   将指定的值与此映射中的指定键关联（可选操作）。
        map.put("lc",22);
        map.put("ly",23);
        map.put("yw",23);
        map.put("xq",23);
        map.put("lbl",21);
        System.out.println(map); // {lc=22, lbl=21, xq=23, ly=23, yw=23}
        // void clear()
        //          从此映射中移除所有映射关系（可选操作）。
        //map.clear();
        System.out.println(map); //{}
        // boolean containsKey(Object key)
        //          如果此映射包含指定键的映射关系，则返回 true。
        System.out.println(map.containsKey("ly"));//true
        // boolean containsValue(Object value)
        //          如果此映射将一个或多个键映射到指定值，则返回 true。
        System.out.println(map.containsValue(23));//true
        // V get(Object key)
        //          返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
        System.out.println(map.get("lbl"));//21
        System.out.println(map.get("zjx"));//null
        // boolean isEmpty()
        //          如果此映射未包含键-值映射关系，则返回 true。
        System.out.println(map.isEmpty());//false
        // void putAll(Map<? extends K,? extends V> m)
        //          从指定映射中将所有映射关系复制到此映射中（可选操作）。
        HashMap<String, Integer> map1 = new HashMap<>();
        map1.put("zjx",21);
        map1.put("lhz",22);
        map1.put("wgq",22);
        map.putAll(map1);
        System.out.println(map);
        //{wgq=22, lc=22, lbl=21, xq=23, zjx=21, ly=23, yw=23, lhz=22}

        // V remove(Object key)
        //          如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
        Integer wgq = map.remove("wgq");
        System.out.println(wgq);//22
        // int size()
        //          返回此映射中的键-值映射关系数。
        System.out.println(map.size());//7
        //Set<Map.Entry<K,V>> entrySet()
        //          返回此映射所包含的映射关系的 Set 视图。
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        System.out.println(entries);//[lc=22, lbl=21, xq=23, zjx=21, ly=23, yw=23, lhz=22]


    }
}

四、迭代

总的来说，Map的迭代就三种方式

1. keySet()方法
   返回此映射中所包含的键的 Set 视图。
2. entrySet()方法
   返回此映射所包含的映射关系的 Set 视图。
3. values()方法
   返回此映射所包含的值的 Collection 视图。

//Map的迭代
        //1.映射关系的Set集合foreach
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            System.out.print(entry+" ");
        }

        //2.映射关系的set集合的iterator()
        Iterator<Map.Entry<String, Integer>> iterator1 = entries.iterator();
        while(iterator1.hasNext()){
            System.out.print(iterator1.next()+" ");
        }

        //3.映射关系的键的Set集合的iterator()
        Set<String> strings = map.keySet();
        Iterator<String> iterator = strings.iterator();
        while(iterator.hasNext()){
            System.out.print(map.get(iterator.next())+" ");
        }

        //4.映射关系的键的Set集合的foreach
        for (String s : map.keySet()) {
            System.out.print(map.get(s)+" ");
        }
		// 5.此映射所包含的值的 Collection 视图。
        Collection<Integer> values = map.values();
        for (Integer value : values) {
            System.out.print(value+" ");
        }