Map接口概述

1 Map接口

Map和Collection没有继承关系

Map集合以key和value的方式存储数据：键值对

​ key和value都是引用数据类型。

​ key和value都是存储对象的内存地址。

​ key起主导作用，value是key的附属品。

Map接口中的常用方法：

V put(K key,V value);向Map集合中添加键值对

V get(Object key);通过Key获取value

void clear();清空Map集合

boolean containsKey(Object key);判断Map中是否包含某个key

boolean containsValue(Object value);判断Map中是否包含某个value

boolean isEmpty();判断Map集合中元素个数是否为0

Set keySet();获取Map集合所有的key（所有的键是一个set集合）

V remove(Object key);通过key删除键值对

int size();获取Map集合中键值对的个数

Collection values();获取Map集合中所有的value，返回一个Collection

Set<Map.Entry<K,V>> entrySet();将Map集合转换成Set集合

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

public class MapTest01 {
    public static void main(String[] args) {
        //创建Map集合对象
        Map<Integer, String> map = new HashMap<>();
        //向Map集合中添加键值对
        map.put(1, "jack");
        map.put(2, "rose");
        map.put(3, "Tom");
        map.put(4, "Lee");
        //通过key获取value
        System.out.println(map.get(2));//rose
        //获取键值对的数量
        System.out.println(map.size());//4

        //通过key删除key-value
        map.remove(2);
        System.out.println(map.size());//3

        //判断是否包含某个key
        //contains方法底层调用的都是equals方法
        System.out.println(map.containsKey(3));//true
        //判断是否包含某个value
        System.out.println(map.containsValue("Lee"));//true

        //清空Map集合
//        map.clear();
//        System.out.println(map.size());//0
//        //判断集合是否为空
//        System.out.println(map.isEmpty());//true

        //获取map集合所有的value
        Collection<String> c = map.values();
        for (String s : c) {
            System.out.println(s);
        }
    }
}

Map集合的遍历：

第一种：获取所有的key，通过遍历key，来遍历value。

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

public class MapTest02 {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        //向Map集合中添加键值对
        map.put(1, "jack");
        map.put(2, "rose");
        map.put(3, "Tom");
        map.put(4, "Lee");
        //获取所有的key，所有的key是一个Set集合
        Set<Integer> keys = map.keySet();
        Iterator<Integer> it = keys.iterator();
        while (it.hasNext()) {
            //取出其中一个key
            Integer key = it.next();
            //通过key来获取value
            String value = map.get(key);
            System.out.println(key + "=" + value);
        }
        System.out.println("----------------");
        //foreach来遍历集合
        for (Integer key : keys) {
            System.out.println(key + "=" + map.get(key));
        }
    }
}

第二种方式：Set<Map,Entry<K,V>> entrySet()

这种方法是把Map集合直接全部转换成Set集合，Set集合中元素的类型是：Map.Entry

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

public class MapTest03 {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        //向Map集合中添加键值对
        map.put(1, "jack");
        map.put(2, "rose");
        map.put(3, "Tom");
        map.put(4, "Lee");

        Set<Map.Entry<Integer, String>> set = map.entrySet();
        //遍历set集合，每次取出一个Node
        //迭代器
        Iterator<Map.Entry<Integer, String>> it = set.iterator();
        while (it.hasNext()) {
            Map.Entry<Integer, String> node = it.next();
            Integer key = node.getKey();
            String value = (String) node.getValue();
            System.out.println(key + "=" + value);
        }
        System.out.println("------------------");
        //foreach遍历
        for (Map.Entry<Integer, String> node : set) {
            System.out.println(node.getKey() + "=" + node.getValue());
        }
    }
}

1.1 HashMap集合

HashMap集合底层是哈希表/散列表的数据结构。

HashMap集合初始化容量16，加载因子0.75（容量达到75%的时候开始扩容）。

HashMap初始化容易必须是2的倍数，官方推荐。

哈希表是一个怎样的数据结构？

​ 哈希表是一个数组和单向链表的结合体。

​ 数组：在查询方面效率很高，随机增删效率较低。

​ 单项链表：在随机增删方面效率较高，在查询方面效率很低。

​ 哈希表将以上两种数据结构融合在一起，充分发挥它们各自的优点。

哈希表/散列表：一维数组，这个数组中的每一个元素是一个单向链表。（数组和链表的结合体）

HashMap的kye部分特点：无序，不可重复。

无序：因为不一定会挂到哪个单向链表上。

不可重复：equals方法来保证HashMap集合的key不可重复。如果key重复，value会覆盖。

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

public class HashMapTest01 {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "jack");
        map.put(2, "rose");
        map.put(2, "Tom");
        map.put(3, "Lee");
        map.put(4, "hello");
        System.out.println(map.size());//4

        Set<Map.Entry<Integer, String>> set = map.entrySet();
        Iterator<Map.Entry<Integer, String>> it = set.iterator();
        while (it.hasNext()) {
            Map.Entry<Integer, String> node = it.next();
            Integer key = node.getKey();
            String value = node.getValue();
            System.out.println(key + "=" + value);
        }

    }
}

运行结果：

HashMap集合key和value都可以为空：

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

public class HashMapTest03 {
    public static void main(String[] args) {
        Map map = new HashMap();
        //HashMap集合允许key为空
        map.put(null, null);
        System.out.println(map.size());//1
        //key重复value覆盖
        map.put(null, 100);
        System.out.println(map.size());//1
        //通过jey获取value
        System.out.println(map.get(null));//100
    }
}

1.1.1 HashMap集合操作

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

public class HashMapTest {
    public static void main(String[] args) {
        //创建HashMap集合对象
        Map<Integer, String> map = new HashMap<>();
        //添加元素
        map.put(11, "hello");
        map.put(10, "world");
        map.put(18, "java");
        map.put(0, "okok");
        //key相同value覆盖
        map.put(10, "rose");
        //取元素
        System.out.println(map.get(0));//okok
        //遍历集合
        //先获取key，再通过key得到valu
        Set<Integer> keys = map.keySet();
        for (Integer i : keys) {
            System.out.println(i + "=" + map.get(i));
        }
        //把map集合全部转换为Set集合，Set集合中每一个元素都是一个节点Node
        Set<Map.Entry<Integer, String>> set = map.entrySet();
        for (Map.Entry<Integer, String> ss : set) {
            System.out.println(ss.getKey() + "=" + ss.getValue());
        }

    }
}

1.2 Properties集合

目前只需掌握Properties属性类对象的相关方法即可。

Peoperties是一个Map集合，继承Hashtable，Properties的key和value都是String类型。

Properties被称为属性类对象。

Properties是线程安全的。

import java.util.Properties;

public class PropertiesTest01 {
    public static void main(String[] args) {
        //创建一个Properties对象
        Properties pro = new Properties();
        //Properties的两个方法，一个存，一个取
        pro.setProperty("a", "jack");
        pro.setProperty("b", "rose");
        pro.setProperty("hello", "world");

        //通过key获取value
        System.out.println(pro.getProperty("a"));//jack
        System.out.println(pro.getProperty("b"));//rose
        System.out.println(pro.getProperty("hello"));//world
    }
}

1.3 TreeMap集合

treeMap 可以对 Map 中的 key 进行排序，如果 map 中的 key 采用的是自定类那么需要实现Comaprable 或Comparator 接口完成排序。

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

/**
 * 重写比较器，降序
 */
public class TreeMapTest {
    public static void main(String[] args) {
        Map<Integer, String> map = new TreeMap<Integer, String>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        map.put(1001, "jack");
        map.put(1003, "zhansan");
        map.put(1002, "aangwu");
        map.put(100, "abcd");
        map.put(1007, "hello");

        //获取键，遍历键来获取值
        Set<Integer> keys = map.keySet();
        for (Integer i : keys) {
            System.out.println(i + "=" + map.get(i));
        }
        //把map集合全部转换成Set集合
        Set<Map.Entry<Integer, String>> set = map.entrySet();
        for (Map.Entry<Integer, String> ss : set) {
            System.out.println(ss.getKey() + "=" + ss.getValue());
        }
    }
}