24、HashSet与HashMap源代码分析

1、HashSet底层是使用HashMap实现的。当使用add方法将对象添加到set当中时，实际上是将该对象作为底层所维护的Map对象的Key，，而value则都是同一个Object对象（该对象我们用不上）；

HashSet部分源代码：

private transient HashMap<E,Object> map;

public HashSet() {
map = new HashMap<E,Object>();
}

public boolean add(E e) {
return map.put(e, PRESENT)==null;
}

HashSet的默认构造方法是生成一个HashMap对象，赋给变量map，HashSet的add（）方法是向生成的HashMap中放入一个键值对，这个键值对的键key就是我们要存入HashSet的数据，值value是一个常量PRESENT，这个PRESENT是这样定义的：

private static final Object PRESENT = new Object();

其他方法的定义：

public boolean remove(Object o) {
return map.remove(o)==PRESENT;
}

public void clear() {
map.clear();
}

public boolean isEmpty() {
return map.isEmpty();
}

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

public Iterator<E> iterator() {
return map.keySet().iterator();
}

HashSet的底层都是借助于HashMap来实现的。

2、HashMap的源代码分析（这个很复杂）。先看一下最后面的内存映像图，理解HashMap的存储形式。

首先HashMap定义了几个重要的成员变量

static final int DEFAULT_INITIAL_CAPACITY = 16;  //默认初始容量，是一个常量16

static final float DEFAULT_LOAD_FACTOR = 0.75f;  //默认负载因子，常量float 0.75，就是说数组数据达到数组容量75%时，扩展数组

transient Entry[] table;   //用来存放数据的数组，数组元素为Entry类型的。这是存放Map键值对的主体。

int threshold;

transient int size;

final float loadFactor;

HashMap底层维护一个数组（Entry[]），我们向HashMap中所放置的对象实际上是存储在该数组中。
再看一下Entry的定义： 

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

/**
* Creates new entry.
*/
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}

public final K getKey() {
return key;
}

public final V getValue() {
return value;
}

public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}

public final boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry e = (Map.Entry)o;
Object k1 = getKey();
Object k2 = e.getKey();
if (k1 == k2 || (k1 != null && k1.equals(k2))) {
Object v1 = getValue();
Object v2 = e.getValue();
if (v1 == v2 || (v1 != null && v1.equals(v2)))
return true;
}
return false;
}

public final int hashCode() {
return (key==null   ? 0 : key.hashCode()) ^
(value==null ? 0 : value.hashCode());
}

public final String toString() {
return getKey() + "=" + getValue();
}

Entry定义了四个成员变量，key和value分别用来存放键值对映射的键和值，这里注意key的定义是final的，也就是说key初始化完毕后就不能改变了，也因此HashMap只提供key的getter方法，value则提供了setter和getter方法。换句话说，如果我的HashMap中保存了“aaa”键和“value1”值这样一个键值对，而我想改成键为“bbb”而值不变依然为“value1”，只能通过先删除aaa键值对，再增加“bbb”键值对，不能直接修改“aaa”这个键。next指向另一个Entry'对象（相当于链表的指针），hash为一个final的int变量，也是只有在初始化时赋值，他是键key的hash值，Entry只有一个带参数的构造方法，所以生成新对象时就确定了key和hash。 
HashMap默认构造方法：

public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
table = new Entry[DEFAULT_INITIAL_CAPACITY];
init();
}

生成一个默认长度（16）的Entry数组。

往HashMap对象中存放键值对方法put（）：

public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}

modCount++;
addEntry(hash, key, value, i);
return null;
}

对于key==null的键值对，调用了putForNullKey（）方法：

private V putForNullKey(V value) {
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(0, null, value, 0);
return null;
}

从这个方法看，好像是key为null的键值对是固定保存在table[0]的。（这里有疑问）。e.recordAccess（）方法不明白意思。最后是调用了addEntry(0, null, value, 0);这个方法（应该就是table[0]处，说明key为null的hash值为0，保存在数组table第一位）：

void addEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
if (size++ >= threshold)
resize(2 * table.length);
}

这个方法先把bucketIndex处的对象赋值给e（bucketIndex也就是要添加的键值对在table数组的下标，从put方法看，就是i，i = indexFor(hash, table.length);），然后生成一个新的Entry对象，存放在table[bucketIndex]处，而这个新Entry对象的next指向了原来的那个Entry对象，就是e。

put（）方法中的for循环用来判断链上是否已经存有相同键（key）的元素，判断是否相等，就是要hash值相等并且((k = e.key) == key || key.equals(k))，如果有相同的键存在，就修改其值，反之就是没有相同的键，那么就执行addEntry（）方法，添加新的键值对。

HashMap在内存中的示意映像图：



HashMap底层维护一个数组（Entry[]），我们向HashMap中所放置的对象实际上是存储在该数组中。

当向HashMap中put一对键值时，他会根据key的hashCode值计算出一个位置，该位置就是此对象准备往数组中存放的位置。

如果该位置没有对象存在就将此对象直接放进数组当中；如果该位置已经有对象存在了，则顺着此存在的对象的链开始寻找（Entry类有一个Entry类型的next成员变量，指向了该对象的下一个对象），如果此链上有对象的话，再去使用equals方法进行比较，如果对此链上的某个对象的equals方法比较为false，则将该对象放到数组当中，然后将数组中该位置以前存在的那个对象连接到此对象的后面。

3、Properties类

主要用于一些属性文件，key = value形式

Properties的key和value都是String的

获取环境变量：

import java.util.Iterator;
import java.util.Properties;
import java.util.Set;

public class PropertiesTest
{
public static void main(String[] args)
{
Properties p = System.getProperties();

Set set = p.keySet();

for(Iterator iter = set.iterator();iter.hasNext();)
{
String key = (String)iter.next();
String value = p.getProperty(key);

System.out.println(key + "=" + value);
}
}
}