Java Map集合知多少？

Map集合可以存储键值对，在开发中使用相当方便，所以整理一下。

1.基本概念

Map(K,V):将键映射到值的对象接口，一个映射不能包含重复的键；每个键最多只能映射到一个值。

2.常用方法

(1).添加功能

// 将指定的值与此映射中的指定键关联
V put(K key, V value)
// 从指定映射中将所有映射关系复制到此映射中
void putAll(Map

         //子类对象实现接口         Map<Integer, String> map = new HashMap<Integer, String>();         Map<Integer, String> map2 = new HashMap<Integer, String>();         //添加键值对         map.put(0, "A");         map.put(1, "B");         map.put(2, "C");         System.out.println(map);//{0=A, 1=B, 2=C}         map2.put(7, "A");         map2.put(8, "B");         map2.put(9, "C");         //添加map集合         map.putAll(map2);         System.out.println(map);//{0=A, 1=B, 2=C, 7=A, 8=B, 9=C}

(2).删除功能

// 如果存在一个键的映射关系，则将其从此映射中移除
V remove(Object key)
// 如果存在键值对的映射关系，则将其从此映射中移除
boolen remove(key, value)
// 从此映射中移除所有映射关系
void clear()

        Map<Integer, String> map = new HashMap<Integer, String>();        // 添加键值对        map.put(0, "A");        map.put(1, "B");        map.put(2, "C");        // 通过key删除 键值对元素        map.remove(0);        // 通过key value 删除键值对元素        map.remove(2, "C");        System.out.println(map);// {1=B}

(3).判断功能

// 如果此映射未包含键-值映射关系，则返回 true
boolean isEmpty()
// 如果此映射包含指定键的映射关系，则返回 true
boolean containsKey(Object key)
// 如果此映射将一个或多个键映射到指定值，则返回 true
boolean containsValue(Object value)

         Map<Integer, String> map = new HashMap<Integer, String>();         // 添加键值对         map.put(0, "A");         map.put(1, "B");         map.put(2, "C");         // 判断是否为空         boolean b = map.isEmpty();         System.out.println(b);// false         //判断是否包含key为3的元素         boolean bb = map.containsKey(3);         System.out.println(bb);// false         //判断是否包含valuae为"A"的元素         boolean bbb = map.containsValue("A");         System.out.println(bbb);// true

(4).获取功能

// 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null
V get(Object key)
// 返回此映射中包含的键的 Set
Set(K) keySet()
// 返回此映射中包含的值的 Collection
Collection(V) values()
// 返回此映射中包含的映射关系的 Set
Set(Map.Entry(K,V)) entrySet()
// 返回此映射中的键-值映射关系数
int size()

         Map<Integer, String> map = new HashMap<Integer, String>();         // 添加键值对         map.put(0, "A");         map.put(1, "B");         map.put(2, "C");         //获取长度         int size=map.size();         System.out.println(size);//3         //通过键获取值         String values=map.get(1);         System.out.println(values);//B         //获取所有键         Set<Integer> set=map.keySet();         System.out.println(set);//[0, 1, 2]         //获取所有values         Collection<String> collection=map.values();         System.out.println(collection);//[A, B, C]         //获取所有映射关系         Set<Map.Entry<Integer,String>> maps=map.entrySet();         System.out.println(maps);//[0=A, 1=B, 2=C]

3.集合遍历

(1).键找值

         User key1=new User("一一", 11);         User key2=new User("二二", 22);         User key3=new User("三三", 33);         //自定义对象为Key         Map<User,Integer> map=new HashMap<User, Integer>();         //添加键值对         map.put(key1,1);         map.put(key2,2);         map.put(key3,3);        // 增强for循环        for (User user : map.keySet()) {            // 获取值            Integer integer = map.get(user);            System.out.println("key:" + user + " value:" + integer);            // 注意：            // key:User [name=二二, age=22] value:2            // key:User [name=三三, age=33] value:3            // key:User [name=一一, age=11] value:1        }

(2).键值对对象

Map.Entry(K,V)键值对对象方法：
// 比较指定对象与此项的相等性
boolean equals(Object o)
// 返回与此项对应的键
K getKey()
// 返回与此项对应的值
V getValue()
// 返回此映射项的哈希码值
int hashCode()
// 用指定的值替换与此项对应的值
V setValue(V value)

         User key1=new User("一一", 11);         User key2=new User("二二", 22);         User key3=new User("三三", 33);         //自定义对象为Key         Map<User,Integer> map=new HashMap<User, Integer>();         //添加键值对         map.put(key1,1);         map.put(key2,2);         map.put(key3,3);         Set<Map.Entry<User, Integer>> set = map.entrySet();         for (Entry<User, Integer> entry : set) {            User key = entry.getKey();            Integer value = entry.getValue();            System.out.println("key:" + key + "  value:" + value);            // key:User [name=二二, age=22] value:2            // key:User [name=三三, age=33] value:3            // key:User [name=一一, age=11] value:1        }

4.主要实现类

(1).HashMap

HashMap：基于哈希表的Map接口的实现。此类不保证映射的顺序,特别是它不保证该顺序恒久不变，无序，实现不是同步的。

(2).TreeMap

TreeMap：根据其键的自然顺序进行排序，或者根据创建映射时提供的Comparator进行排序，具体取决于使用的构造方法， 有序，实现不是同步的。

自然排序：

        Map<String, Integer> map = new TreeMap<String, Integer>();        // 添加键值对        map.put("yiyi", 1);        map.put("erer", 2);        map.put("sansan", 3);        System.out.println(map);//{erer=2, sansan=3, yiyi=1}

比较器排序：

        Users key1 = new Users("一一", 11);        Users key2 = new Users("二二", 22);        Users key3 = new Users("三三", 33);        Users key4 = new Users("三三", 33);        // 比较器排序        Map<Users, Integer> map = new TreeMap<Users, Integer>(                new Comparator<Users>() {                    public int compare(Users o1, Users o2) {                        // 指定排序规则                        return o1.name.compareTo(o2.name);                    }                });        // 添加键值对        map.put(key1, 1);        map.put(key2, 2);        map.put(key3, 3);        map.put(key4, 3);        System.out.println(map);// {Users [name=一一, ager=11]=1, Users [name=三三, ager=33]=3, Users [name=二二, ager=22]=2}

注：更多方法查看API