java中Set与Map的关系

Set代表一种元素不可重复、无序的集合，而Map则代表一种由多个Key-value对组成的集合。

表面上来看这两个集合并没有太多的相似之处，但如果只考虑Map集合的Key，不难发现，这些Map集合的key具有一个特征：所有Key不重复且key之间无序。也就是说，如果将Map集合的所有key集中起来，那这些key就组成一个Set集合。所以Map集合提供了一下方法来实现返回所有KEY组成的Set集合：

Set<K> keySet()

Map中的Key和value有严格的对应关系。如果将Map集合的key和value捆绑在一起，其实可以改用Set集合来保存这些key-value对，如图（图引用自疯狂java）

以下是把Set拓展成Map的实现，需要定义一个SimpleEntry和impleMapWithSet类。代码如下（参考疯狂java）

import java.util.Map;

/**
 *
 * @author Biaoming
 */
public class SimpleEntry<K,V> implements Map.Entry<K,V>,java.io.Serializable {
    private final K key;
    private V value;
    public SimpleEntry(K key,V value){
        this.key = key;
        this.value = value;
    }
    public SimpleEntry(Map.Entry<? extends K,? extends V> entry){
        this.key = entry.getKey();
        this.value = entry.getValue();
    }
    @Override
    public K getKey() {
        return key;
    }

    @Override
    public V getValue() {
        return value;
    }

    @Override
    public V setValue(V value) {
        V oldValue = this.value;
        this.value = value;
        return oldValue;
    }
    @Override
    public int hashCode(){
        return key == null?0:key.hashCode();
    }
    @Override
    public boolean equals(Object o){
        if(o == this){
            return true;
        }
        if(o.getClass() == SimpleEntry.class){
            SimpleEntry tmpEntry = (SimpleEntry)o;
            return tmpEntry.getKey().equals(this.getKey());
        }
        return false;
    }
    @Override
    public String toString(){
        return key+"="+value;
    }
    
}

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

/**
 *
 * @author Biaoming
 */
public class impleMapWithSet<K, V> extends HashSet<SimpleEntry<K, V>> {

    @Override
    public void clear() {
        super.clear();
    }

    public boolean containsKey(K key) {
        return super.contains(new SimpleEntry<K, V>(key, null));
    }

    boolean containsValue(Object value) {
        for (SimpleEntry<K, V> se : this) {
            if (se.getValue().equals(value)) {
                return true;
            }
        }
        return false;
    }

    public V get(Object key) {
        for (SimpleEntry<K, V> se : this) {
            if (se.getKey().equals(key)) {
                return se.getValue();
            }
        }
        return null;
    }

    public V put(K key, V value) {
        add(new SimpleEntry<K, V>(key, value));
        return value;
    }

    public void putAll(Map<? extends K, ? extends V> m) {
        for (K key : m.keySet()) {
            add(new SimpleEntry<K, V>(key, m.get(key)));
        }
    }

    public V removeEntry(Object key) {
        for (Iterator<SimpleEntry<K, V>> it = this.iterator(); it.hasNext();) {
            SimpleEntry se = (SimpleEntry) it.next();
            if (se.getKey().equals(key)) {
                V oldValue = (V) se.getValue();
                it.remove();
                return oldValue;
            }
        }
        return null;
    }

    public int size() {
        return super.size();
    }
}

其实 HashSet底层是通过包装HashMap来实现，HashSet在添加一个值的时候，实际上是将此值作为HashMap中的key来进行保存。

而 HashMap的底层实现是通过初始化化一个Entry数组来实现key、value的保存。

以下为转载内容：

在HashMap中添加值步骤

    第一步，对key的hashcode进行hash计算，获取应该保存到数组中的index。

   第二步，判断index所指向的数组元素是否为空，如果为空则直接插入。

   第三步，如果不为空，则依次查找entry中next所指定的元素，判读key是否相等，如果相等，则替换久的值，返回。

   第四步，如果都不相等，则将此链表头元素赋值给待插入entry的next变量，让后将待插入元素插入到entry数组中去。