Java集合（八）Map接口

我们来查看Map接口：

里面的k-v和set集合的不同之处在于：key仍然是一个对象，但是对于set来说value是一个常量，

private static final Object PRESENT = new Object();

set里面的value放的是静态性质的PRESENT。

而map的value是自己传进去的。map接口是一个双列集合，set接口是一个单列集合。

Map接口实现类的特点：

（1）Map与Collection并列存在，用于保存具有映射关系的数据：Key-Value（双列元素）

(2)Map中的Key和value可以是任何引用类型的数据，会封装到HashMap$Node对象中

我们发现table表是HashMap$Node这样子的一个数组。

（3）Map中的key不允许重复,原因和hashSet一样。

（4）Map中的value可以重复

（5）Map的key可以为Null，value也可以为null,注意key为null,只能有一个，value为null,可以多个。

（6）常用string类作为Map的key,而只要object的子类都可以作为key。

(7)key和value之间存在单向一对一关系，即通过指定的Key总能找到对应的value.

我们的代码设计如下所示：

package com.rgf.map;

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

@SuppressWarnings({"all"})
public class Map_ {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("no1","rgf");//k-v
        map.put("no2","张无忌");
        map.put("no1","张三丰");//当有相同的key值时，会替换掉上面的value
        map.put("no3","张三丰");
        map.put(null,null);
        map.put(null,"abc");//等价替换
        map.put("no4",null);//k-v
        map.put("not5",null);//k-v
        map.put(1,"赵敏");//k-v
        map.put(new Object(),"金毛狮王");//k-v
        //通过get方法，传入key,会返回对应的value
        System.out.println(map.get(1));
        System.out.println("map="+map);



    }
}

运行界面如下所示：

（8）Map存放数据的key-value示意图，一对k-v是放在一个HashMap$Node中，又因为Node实现了Entry接口，有些书上也说一对k-v就是一个Entry。（key放在set集合里面，values放在Collection接口下面的实现子类里面的）但是，真正的Key是放在HashMap$Node这个类型里面的。而我们的set和collection集合只是指向了他而已。就是简单的引用。

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);

其中newNode返回了hashMap里面的Node类型。

Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
        return new Node<>(hash, key, value, next);
    }

Node为HashMap里面的静态内部类：

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

其中Node也实现了Entry接口

Entry这个集合中包含2类，一类是Set型的KeySet,用来存放key值，另外一类是存放value值，然后他们里面各自的值其实存放的是地址，一个指向真正Node节点中的key和value的地址。而真正存放Key和value的值是HashMap$Node。

我们来通过源码进行较深入的理解：

1.k-v最后是存放在HashMap$Node node=new Node<>(hash, key, value, next)这个类型里面的 2.k-v为了方便程序员的遍历，还会创建EntrySet集合，该集合存放的元素的类型就是Entry, // 而一个Entry对象就包含了key,value,EntrySet<Entry<K,V>>,即：transient Set<Map.Entry<K,V>> entrySet() ，有一个EntrySet集合，EntrySet集合里面放的是Entry这样子的数据类型，Entry这样子的数据类型包含key和value;

3.entrySet中，定义的类型是Map.Entry,但是实际上存放的还是HashMap$Node,Node实现了Map.Entry接口，这是因为HashMap$Node implements Map.Entrty,HashMap$Node实现了这个接口Map.Entrty。当有一个类，实现了一个接口，这个类的对象实例就可以赋给我们的接口类型。

我们进行总结就是EntrySet内部类存储了node节点的引用，返回一个集合，方便遍历。

我们进入如下源码所示：

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

（4）这样当把HashMap$Node对象存放到entrySet方便我们的遍历，因为Map.Entry提供了两个非常重要的方法

interface Entry<K,V> {
        /**
         * Returns the key corresponding to this entry.
         *
         * @return the key corresponding to this entry
         * @throws IllegalStateException implementations may, but are not
         *         required to, throw this exception if the entry has been
         *         removed from the backing map.
         */
        K getKey();

        /**
         * Returns the value corresponding to this entry.  If the mapping
         * has been removed from the backing map (by the iterator's
         * <tt>remove</tt> operation), the results of this call are undefined.
         *
         * @return the value corresponding to this entry
         * @throws IllegalStateException implementations may, but are not
         *         required to, throw this exception if the entry has been
         *         removed from the backing map.
         */
        V getValue();

我们设计的代码如下所示：

package com.rgf.map;

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

@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=new Node<>(hash, key, value, next)这个类型里面的
        //2.k-v为了方便程序员的遍历，还会创建EntrySet集合，该集合存放的元素的类型就是Entry,
        // 而一个Entry对象就包含了key,value,EntrySet<Entry<K,V>>,即：transient Set<Map.Entry<K,V>> entrySet()
        //有一个EntrySet集合，EntrySet集合里面放的是Entry这样子的数据类型，Entry这样子的数据类型包含key和value;
        //3.entrySet中，定义的类型是Map.Entry,但是实际上存放的还是HashMap$Node,Node实现了Map.Entry接口
        //这是因为HashMap$Node  implements Map.Entrty,HashMap$Node实现了这个接口Map.Entrty。
        //当有一个类，实现了一个接口，这个类的对象实例就可以赋给我们的接口类型。
        //4.这样当把HashMap$Node对象存放到entrySet方便我们的遍历，因为Map.Entry提供了两个非常重要的方法
        //getKey()和getValue()方法
        Set set = map.entrySet();
        System.out.println(set.getClass());//输出EntrySet类型
        for (Object obj :set) {
            //System.out.println(obj.getClass()); //输出HashMap$Node类型
            //为了从HashMap$Node取出k-v,先做一个向下转型
           // System.out.println("==============");
            Map.Entry entry=(Map.Entry)  obj;
            System.out.println(entry.getKey()+"-"+entry.getValue());
        }


    }
}

运行界面如下所示：

我们进行Debug来进行更好的理解：

我们entrySet里面的no2和no1其实是指向table表里面的那两个结点。

我们发现这两个表的位置是相同的。

我们这里有一个table表，是以数组+链表+红黑树的来组织我们这个Node,但是为了方便管理，我们在底层做了一个控制，我们把每一个Node封装成一个entry,然后把多个entry放到entrySet这个集合里面去，便于管理，除此之外，还提供了一个叫keyset,如果我们想指向得到这个keyset的话，可以直接把key里面的对象封装到set这样子一个集合。通过这样可以单独的取出key里面的对象。

我们继续进行设计代码：

package com.rgf.map;

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

@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=new Node<>(hash, key, value, next)这个类型里面的
        //2.k-v为了方便程序员的遍历，还会创建EntrySet集合，该集合存放的元素的类型就是Entry,
        // 而一个Entry对象就包含了key,value,EntrySet<Entry<K,V>>,即：transient Set<Map.Entry<K,V>> entrySet()
        //有一个EntrySet集合，EntrySet集合里面放的是Entry这样子的数据类型，Entry这样子的数据类型包含key和value;
        //3.entrySet中，定义的类型是Map.Entry,但是实际上存放的还是HashMap$Node,Node实现了Map.Entry接口
        //这是因为HashMap$Node  implements Map.Entrty,HashMap$Node实现了这个接口Map.Entrty。
        //当有一个类，实现了一个接口，这个类的对象实例就可以赋给我们的接口类型。
        //4.这样当把HashMap$Node对象存放到entrySet方便我们的遍历，因为Map.Entry提供了两个非常重要的方法
        //getKey()和getValue()方法
        Set set = map.entrySet();
        System.out.println(set.getClass());//输出EntrySet类型
        for (Object obj :set) {
            //System.out.println(obj.getClass()); //输出HashMap$Node类型
            //为了从HashMap$Node取出k-v,先做一个向下转型
           // System.out.println("==============");
            Map.Entry entry=(Map.Entry)  obj;
            System.out.println(entry.getKey()+"-"+entry.getValue());
        }
        Set set1 = map.keySet();
        System.out.println(set1.getClass());
        for (Object o :set1) {
            System.out.println("key="+o);

        }
        Collection values = map.values();
        for (Object o1 :values) {
            System.out.println("values="+o1);

        }

        System.out.println(values.getClass());
    }
}

运行界面如下所示：

我们可以查看values的源码：

final class Values extends AbstractCollection<V> {
        public final int size()                 { return size; }
        public final void clear()               { HashMap.this.clear(); }
        public final Iterator<V> iterator()     { return new ValueIterator(); }
        public final boolean contains(Object o) { return containsValue(o); }
        public final Spliterator<V> spliterator() {
            return new ValueSpliterator<>(HashMap.this, 0, -1, 0, 0);
        }
        public final void forEach(Consumer<? super V> action) {

也可以查看values的源码：

final class KeySet extends AbstractSet<K> {
        public final int size()                 { return size; }
        public final void clear()               { HashMap.this.clear(); }
        public final Iterator<K> iterator()     { return new KeyIterator(); }
        public final boolean contains(Object o) { return containsKey(o); }
        public final boolean remove(Object key) {
            return removeNode(hash(key), key, null, false, true) != null;
        }
        public final Spliterator<K> spliterator() {
            return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0);
        }
        public final void forEach(Consumer<? super K> action) {

Map接口和常用方法：

Map体系的继承图：

Map接口常用方法：

我们所设计的代码如下所示：

package com.rgf.map;

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

@SuppressWarnings({"all"})
public class MapMethod {
    public static void main(String[] args) {
        //演示map接口常用方法
        Map 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);
        //remove：根据键删除映射关系
        map.remove(null);
        System.out.println("map="+map);
        //get:根据键获取值
        Object val = map.get("鹿晗");
        System.out.println("val="+val);
        //size:获取元素个数
        System.out.println("k-v="+map.size());
        //isEmpty:判断个数是否为0
        System.out.println(map.isEmpty());//F
        //clear:清除k-v
        map.clear();
        System.out.println("map="+map);
        map.put("rgf","ypl");
        //containsKey:查找键是否存在
        System.out.println("结果="+map.containsKey("rgf"));//F


    }
}
class Book{
    private String name;
    private  int num;

    public Book(String name, int num) {
        this.name = name;
        this.num = num;
    }
}

运行界面如下所示：

Map接口遍历方法：

（1）containsKey:查找键是否存在

（2）KeySet:获取所有的键

（3）entrySet:获取所有关系k-v

(4）values:获取所有的值

我们设计代码如下所示：

package com.rgf.map;

import java.util.*;

@SuppressWarnings({"all"})
public class MapFor {
    public static void main(String[] args) {
        Map map = new HashMap();
        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("--------keyset第一种方式:增强for循环-------");
        for (Object key :keyset) {
            System.out.println(key+"-"+map.get(key));
        }
        //(2)iterator迭代器
        System.out.println("-------keyset第二种方式:迭代器-------");
        Iterator iterator = keyset.iterator();
        while (iterator.hasNext()) {
            Object key =  iterator.next();
            System.out.println(key+"-"+map.get(key));
        }
        //第二组：把所有的values取出
        Collection values = map.values();
        //这里可以使用collection使用的遍历方法
        //(1)增强for循环
        System.out.println("-------values第一种方式：增强for循环-----");
        for (Object value :values) {
            System.out.println("values="+value);
        }
        //（2）iterator迭代器遍历
        System.out.println("-----values第二种方式：iterator迭代器遍历");
        Iterator iterator1 = values.iterator();
        while (iterator1.hasNext()) {
            Object value = iterator1.next();
            System.out.println("values=" + value);
        }
       //第三组：通过EntrySet来获取k-v
        Set entrySet = map.entrySet(); //EntrySet<Entry<K,V>>
//(1)增强for
        System.out.println("-------entrySet增强for循环----");
        for (Object entry :entrySet) {
            //将entry转成Map.Entry
            Map.Entry m =(Map.Entry) entry;
            System.out.println(m.getKey()+"-"+m.getValue());
        }
        //(2)迭代器
        System.out.println("-------entrySet迭代器------");
        Iterator iterator2 = entrySet.iterator();
        while (iterator2.hasNext()) {
            Object entry= iterator2.next();
            System.out.println(entry.getClass());//HashMap$Node--->实现了Map.Entry(getKey,getValue)
            //向下转型，应该转成HashMap$Node，但是因为他没有提供相应的方法，就直接转成Map.Entry
            Map.Entry  m=(Map.Entry) entry;
            System.out.println(m.getKey()+"-"+m.getValue());
        }


    }


    }

运行界面如下所示：

实例练习：

使用HashMap添加三个员工对象，要求：

键：员工id

值：员工对象

并遍历显示工资>18000的员工（遍历方式至少两种）

员工类：姓名、工资、员工id

我们设计的代码如下所示：

package com.rgf.map;

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

@SuppressWarnings({"all"})
public class MapExercise {
    public static void main(String[] args) {
        Map map = new HashMap();
        Object rgf = map.put(1, new staff("rgf", 50000, 1));
        Object ypl = map.put(2, new staff("ypl", 60000, 2));
        Object love = map.put(3, new staff("love", 9999, 3));
        Set keySet = map.keySet();

        //第一种遍历:Keyset方式:增强for循环
        System.out.println("=====第一种遍历方式：keyset增强for循环=====");
        for (Object key : keySet) {
            //先获取value
            staff emp = (staff) map.get(key);
            if (emp.getWages() > 18000) {
                System.out.println(emp);
            }
        }
        System.out.println("=====第二种遍历方式:entryset迭代器方式");
            //第二种遍历：entryset:迭代器方式
            Set set = map.entrySet();
            Iterator iterator = set.iterator();
            while (iterator.hasNext()) {
                Object entry = iterator.next();
                Map.Entry entry1 = (Map.Entry) entry;
                staff value = (staff) entry1.getValue();
                if (value.getWages() > 18000) {
                    System.out.println(value);
                }
            }
        

    }
        static class staff {

        private String name;
        private int wages;
        private int id;

        public staff(String name, int wages,int id) {
            this.name = name;
            this.wages = wages;
            this.id = id;
        }

        public String getName() {
            return name;
        }

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

        public int getWages() {
            return wages;
        }

        public void setWages(int wages) {
            this.wages = wages;
        }

        public int getId() {
            return id;
        }

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

            @Override
            public String toString() {
                return "staff{" +
                        "name='" + name + '\'' +
                        ", wages=" + wages +
                        ", id=" + id +
                        '}';
            }
        }
}

运行界面如下所示：