java集合之间的关系及实现细节（1）——Set与Map

　   首先，先谈一下Set和Map的一些特性及体系结构:

　　1.1 Set和Map

　　Set代表一种无序的、元素不可重复的集合。Map则代表是一种key-value对组成的集合，Map集合类似于传统的关联数组。表面上看它们之间的关系的相似性很少，实则Map和Set之间有着莫大的关联，可以这样说Map集合实则是Set集合的扩展。

　　至于为什么是Set是一种无序的、元素不可重复的集合；Map集合类似传统的关系数组。理解这个非常重要，这个我在后面会进行补充说明。

　　1.2 Set和Map之间的关系

　　先看看Set集合的继承体系，再来看Map集合的类继承体系： 

　　从上图灰色阴影部分可以看出Map和Set的集合实现类除了后面Set和Map部分不一样，前面的类或接口的名称以及其继承结构完全一样。是偶然吗？答案绝对不是。而且你若是用过Map的话，你会发现Map不允许再现相同的key，且Map在遍历的时候，key是无序的，正是对应Map中keySet()方法。这与上述Set集合的特征又是惊人的相似。下面我会用一段小程序来说明Set为何与Map这么相似了。

　　先说一下我的思路：　

　　（1）在我的印象中：map的key与value存在的关系如下图：

　　（2）既然Map中的key与value存在一一对应关系，那么，现在我们换一种思路来思考，把key-value如下图:

　　由此可见，如上述图3.4表明的一样，如果将key-value绑定在一起，那么Map说白了就是个（key-value）的Set集合

　　由上述思路，下面是程序实现由Set实现Map：

（1）包含key-value的entry实现代码：

package com.ngu4k.test.collection;

import java.io.Serializable;
import java.util.Map.Entry;

public class SimpleEntry<K,V> implements Entry<K,V>,Serializable{
    private static final long serialVersionUID = -4352059623055803486L;
    private final K key;
    private V value;
    //定义两个如下构造器
    public SimpleEntry(K key,V value)
    {
        this.key = key;
        this.value = value;
    }
    
    public SimpleEntry(Entry<? extends K,? extends V> entry)
    {
        this.key = entry.getKey();
        this.value = entry.getValue();
    }
    //获取key
    public K getKey() 
    {
        return key;
    }
    //获取value
    public V getValue() 
    {
        return value;
    }
    //改变该key-value对的value值
    public V setValue(V value) 
    {
        V oldValue = this.value;
        this.value = value;
        return oldValue;
    }
    //根据key比较两个对象是否相等
    public boolean equals(Object o)
    {
        if(o == this){
            return true;
        }
        if(o.getClass() == SimpleEntry.class){
            SimpleEntry se = (SimpleEntry)o;
            return se.getKey().equals(getKey());
        }
        return false;
    }
    //根据key获得hashCode的值
    public int hashCode(){
        return key == null ? 0 : key.hashCode();
    }
    
    public String toString(){
        return key + "=" + value;
    }
}

（2）由Set到Map的简单实现代码：

package com.ngu4k.test.collection.map;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;

import com.ngu4k.test.collection.SimpleEntry;

/**
 * Set到Map的简单实现
 * @author ikouer
 * @param <K>
 * @param <V>
 */
public class Set2Map<K,V> extends HashSet<SimpleEntry<K,V>>{

    private static final long serialVersionUID = 1596710712757978024L;
    
    //清空Set2Map中key-value对
    public void clear()
    {
        super.clear();
    }
    //查看是否包含指定的key
    public boolean containsKey(K key)
    {
        return super.contains(new SimpleEntry<K, V>(key,null));
    }
    //查看是否包含指定的value
    public boolean containsValue(V value)
    {
        for(SimpleEntry<K,V> se : this)
        {
            if(se.getValue().equals(value))
            {
                return true;
            }
        }
        return false;
    }
    //根据指定的key获取对应的value
    public V get(K key)
    {
        for(SimpleEntry<K,V> se : this)
        {
            if(se.getKey().equals(key)){
                return se.getValue();
            }
        }
        return null;
    }
    //把指定的key-value添加到集合中
    public V put(K key,V value)
    {
        this.add(new SimpleEntry<K,V>(key,value));
        return value;
    }
    //把一个Map集合添加到Set2Map集合中
    public void putAll(Map<? extends K,? extends V> om)
    {
        for(K key : om.keySet())
        {
            this.add(new SimpleEntry<K,V>(key,om.get(key)));
        }
    }
    //根据指定的key移除对应的key-value
    public V remove(K key)
    {
        for(Iterator<SimpleEntry<K,V>> it = this.iterator(); it.hasNext();){
            SimpleEntry<K,V> se = it.next();
            if(se.getKey().equals(key))
            {
                V rv = se.getValue();
                it.remove();
                return rv;
            }
        }
        return null;
    }
    //获取集合大小
    public int size(){
        return super.size();
    }
    
    public static void main(String[] args) {
        Set2Map<String,Integer> smap = new Set2Map<String,Integer>();
        //将key-value放入集合
        smap.put("语文", 88);
        smap.put("数学", 99);
        smap.put("英语", 102);
        System.out.println(smap);
        System.out.println(smap.size());
        //执行移除对称key的entry
        smap.remove("数学");
        System.out.println("删除key为\"数学\"的Entry之后:"+smap);
        //获取key为语文的value值
        System.out.println("key为\"语文\"的value值："+smap.get("语文"));
        //判断是否包含key
        System.out.println("是否包含key为\"英语\"的entry:"+smap.containsKey("英语"));
        //判断是否包含value
        System.out.println("是否包含value为102:"+smap.containsValue(102));
        //执行clear方法
        smap.clear();
        System.out.println("执行完clear()方法之后的集合："+smap);
        
    }
}

 

此处的提供的Set2Map集合的功能甚至可以媲美Map集合的功能

而TreeSet底层也是采用TreeMap实现的。至于Tree(二叉树)是怎么实现，读者可参考疯狂java系列书籍或到网上自行搜索。

至此，我想大家应该知道Set中的元素为什么是无序且不可重复的了吧。（因为Set集合的底层全部采用Map集合来实现的）

下面再和大家分析一下java中的Map的实现--HashMap的原理：

1.3 HashMap的实现原理

　　要搞清hashmap是什么，首先要清楚它的数据结构，在java编程语言中，最基本的结构就是数组和模拟指针了，几乎所有的数据都可以用这两具基本的结构来构造的，hashmap也不例外。java中的hashmap实际上是一个数组和链表的结合体（在数据结构中，一般称之为“链表散列”）

　　java中的hashmap是以key-value的模式存取的，实际上它也是存放在数组当中的。过程是这样的：首先会得到key的hashcode，然后通过hashcode(key)%size，来得到数组的索引，把entry放入数组中。请看下图（横排表示数组，纵排表示链表）：

　　

由上图可知，hashMap其实是就是一个数组。看一下hashMap的源代码：

上面table中的定义为：  transient Entry[] table;

由此可见hashmap在初始化时会创建一个Entry类型的数组。再看一下Entry的源代码:

　　可以看到entry中持有一个指向下一个元素的引用，这样就构成了链表。

　　当我们往hashmap中put元素中，首先根据key的hash值得到这个元素在数组中的位置（即下标），然后可这个元素放入到对应的位置就行了。如果这个位置已经有了其它元素，那么在同一个位置的元素将以链表的形式存储，新加入的元素放在链头，最先加入的元素放在链尾。从hashmap中get元素的时候，首先根据传入的key值的hash得到元素在数组中的存放位置，然后再通过key的equals方法来得到需要的元素。

　　java中的Set与Map并不是我们想像中的那么神秘，其实很简单。

　　本文参考：《疯狂java》、《java中的哈希表》

　　上述是Map与Set的关系及一些实现细节。若有不到之处，敬请各位指导并谅解，谢谢！

　　下篇文章我会把List与Map的关系及ArrayList，LinkList的实现细节做一些详细的记录。

      欢迎大家阅读与转载。转载请注入本文原址，谢谢！