4. Dictionary HashTable

struct KeyValuePair<TKey,TValue>

public TKey Key{get;}
public TValue Value{get;}
public string ToString(){return [Key,Value]}

IDictionary<TKey,TValue>:ICollection<KeyValuePair<TKey,TValue>>

TValue this[TKey key]{get;set}
ICollection<TKey> keys{get;}
ICollection<TValue> values{get;}
bool ContainsKey(TKey key);
void Add(TKey key,TValue value);
bool Remove(TKey key);
bool TryGetValue(TKey key,out TValue value);

IDictionary:ICollection

Object this[Object key]{get;set;}
ICollection Keys{get;}
ICollection Values{get;}
bool Contains(Object key);
void Add(Object key,Object value);
void Clear();
bool IsReadonly{get;}
bool IsFixedSize{get;}
new IDictionaryEnumerator GetEnumerator();
void Remove(Object key);

IReadOnlyDictionary<TKey,TValue>:IReadOnlyCollection<KeyValuePair<TKey,TValue>>

对比IDictionary<TKey,TValue>的没有Add,Remove两个方法

IEqualityComparer

bool Equals(T x,T y);
int GetHashCode(T obj);

KeyCollection:ICollection

new Enumerator(Dictionary)

因为key其实是保存在entries[]中的entry.key

ValueCollection:ICollection

new Enumerator(Dictionary)

因为value其实是保存在entries[]中的entry.value

Dictionary<TKey,TValue> 1170行,中等水平

private struct Entry{
    public int hashCode;
    public int next;
    public TKey key;
    public TValue value;
}
private int[] buckets; //key数组
private Entry[] entries; //value数组
private int count;     //
private int version;   
private int freeList;
private int freeCount; //每次删除就++
private IEqualityComparer<TKey> comparer; //组合模式
private KeyCollection keys;
private ValueCollection values;
private object _syncRoot;

两个集合

int[] buckets; //居然是int[],int应该是综合来看最好的选择
Entry[] entries;

内部两个数组的大小变化

是[3, 7, 11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521,...] 按素数去增长,是为了取余的时候能够不重复,保证key在buckets中是不冲突的,但是为什么没有5呢

insert方法解析

1. 计算key的hashcode
2. 计算targetbucket= hashcode % buckets.Length //计算在第一个数组桶中的索引
3. 在entries中设置数据
next=buckets[targetBucket]  //用来连接相同的hashcode的对象的
hashcode=hashcode    //记录key的hashcode,是为了在Resize时反向操作,获取key在buckets中的index
key=key,     //dict中插入的key
value=value  //dict中插入的数据

buckets的值是entries的索引

private void Insert(TKey key,TValue value,bool add){
    if(key==null){
        throw new ArgumentMentNullException("key");
    }

    if(buckets==null) Initialize(0); //初始化为3个长度
    int hashCode = comparer.GetHashCode(key) & ox7fffffff; //获取正的hashcode
    int targetBucket = hashCode % buckets.Length;   //求出在buckets中的索引

    for(int i=buckets[targetBucket];i>=0;i=entries[i].next){ //
        if(entries[i].hashCode == hashCode && comparer.Equals(entries[i].key,key)){ //判断key是否存在
            if(add){
                throw new ArgumentException();
            }
            entries[i].value=value;
            version++;
            return;
        }
    }

    int index;
    if(freeCount>0){
        index=freeList;
        freeList=entries[index].next;
        freeCount--;
    }
    else{
        if(count==entries.Length){
            Resize();
            targetBucket = hashCode % buckets.Length;
        }
        index = count;  //在entries中顺序插入数据的
        count ++;
    }
    entries[index].hashCode = hashCode;
    entreis[index].next = buckets[targetBucket];
    entries[index].key = key;
    entries[index].value = value;
    buckets[targetBucket]=index;
}

Insert 实例

这是一种特殊的情况,所有的数据的hashcode都相同但是key本身不同,然后在entries中通过next构成了一个链表,所以本身dictionary中就利用这种方式来解决冲突

count	targetBucket	i=buckets[targetBucket]	freeCount	index=count	entries[index].next	buckets[targetBucket]=index
1	2	-1	0	0	-1	0
2	2	0	0	1	0	1
3	2	1	0	2	1	2
4	2	2	0	3	2	3

private FindEntry(Tkey key) 方法解析:返回entries中数据索引

containskey(key),this["key"]这些方法都要通过FindEntry()获取

1. 获取key的hashcode
2. hashcode%buckets.length 得到具体的在buckets中的位置,然后其值就是entries中value的索引
3. 根据索引获取value,判断两个数据是否相等
    1. hashcode
    2. key
4. 如果entries中的Entry的hashcode和key都相等,就表示这个key存在,entries中的的索引了

private Resize():扩展buckets的容量的

这个方法是在需要扩展容量时调用,比如当前容器是3,需要扩展到7时

1. 先得到能否扩展,以及扩展后的容量
2. copy entries到新的newentries中
3. 循环newentries,根据hashcode 计算key的index,然后重建buckets
    1. 根据hashcode % 当前容量 得到一个index
    2. buckets[index]=i ; //i 就是entries中当前数据的index,这样就完成了 buckets和entris的关联,是逆向重建

4. 将new对象覆盖旧对象

最大的疑问是Entry中next是起什么作用

暂时不知道

Prop

public int Count{get{return count - freeCount;}}
public KeyCollection Keys {get {return new KeyCollection(this);}}
public ICollection<TKey> Keys {get {return new KeyCollection(this);}}
public ValueCollection Values {get {return new ValueCollection(this);}}
public ICollection<TValue> Values {get {return new ValueCollection(this);}}
public TValue this[Tkey key]{
    get {
        int i = FindEntry(key);
        if(i>=0) return entries[i].value;
        throw new KeyNotFoundException();
    }
    set {Insert(key,value,false)}
}

private method

//初始化
private void Initialize(int capacity){
    int size = HashHelper.GetPrime(capacity); //return size;
    buckets = new int[size];
    for(int i=0;i<buckets.Length;i++)buckets[i]=-1;
    entries=new Entry[size];
    freeList=-1;
}
private void ICollection<KeyValuePair<TKey,TValue>>.Add(KeyValuePair<TKey,TValue> keyValuePair){
    Add(KeyValuePair.Key,KeyValuePair.Value);
}
private bool ICollection<KeyValuePair<TKey,TValue>>.Contains(KeyValuePair<TKey,TValue> keyValuePair){
    int i = FindEntry(keyValuePair.Key);
    if(i>=0 && EqualityComparer<TValue>.Deafult.Equals(entries[i].value,keyValuePair.Value)){
        return true;
    }
    return false;
}
private bool ICollection<KeyValuePair<TKey,TValue>>.Remove(KeyValuePair<TKey,TValue> keyValuePair){
    int i = FindEntry(keyValuePair.Key);
    if( i >= 0 && EqualityComparer<TValue>.Default.Equals(entries[i].value, keyValuePair.Value)) {
        Remove(keyValuePair.Key);  //移除key
        return true;
    }
    return false;
}
//复制所有的key,value到数组KeyValuePair<TKey,TValue>[]中
private void CopyTo(KeyValuePair<TKey,TValue>[] array,int index){
    Entry[] entries = this.entries;
    for(int i=0;i<count;i++){
        if(entries[i].hashCode>=0){
            array[index++]=new KeyValuePair<TKey,TValue>(entries[i].key,entries[i].value);
        }
    }
}
private int FindEntry(TKey key){
    if(buckets != null){
        int hashCode = comparer.GetHashCode(key) & 0x7fffffff;
        for(int i=buckets[hashCode%buckets.Length];i>=0;i=entries[i].next){
            if(entries[i].hashCode==hashCode && comparer.Equals.(entries[i].key,key))
                return i;
        }
    }
    return -1;
}
//bool 控制新增和修改
private void Insert(TKey,key,TValue,value,bool add){
    if(buckets == null)Initialize(0);
    int hashCode = comparer.GetHashCode(key) & 0x7fffffff; //计算key的hash值
    int targetBucket = hashCode % buckets.Length;

    for(int i=buckets[targetBucket];i>=0;i=entries[i].next){
        if(entries[i].hashCode == hashCode && comparer.Equals(entries[i].key,key)){
            if(add){
                throw new ArgumentException();
            }
            //修改数据
            entries[i].value = value;
            version++;
            return;
        }
    }
    int index;
    if(freeCount>0){
        index = freeList;
        freeList = entries[index].next;
        freeCount--;
    }else{
        if(count==entries.Length){
            Resize();
            targetBucket = hashCode % buckets.Length;
        }
        inex = count;
        count++;
    }

    entries[index].hashCode = hashCode;
    entries[index].next = buckets[targetBucket];
    entries[index].key = key;
    entries[index].value = value;
    entries[targetBucket] = index;        
}

public method

public void Add(TKey key,TValue value){
    Insert(key,value,true);
}
public void Clear(){
    if(count>0){
        for(int i=0;i<buckets.Length;i++)buckets[i]=-1;
        Array.Clear(entries,0,count);
        freeList = -1;
        count = 0;
        freeCount = 0;
        version ++;
    }
}
public bool ContainsKey(TKey key){
    return FindEntry(key)>=0;
}
public bool ContainsValue(TValue value){
    if (value == null){
        for(int i=0;i<count;i++){
            if(entries[i].hashCode>=0&&entries[i].value==null)return true;
        }
    }else{
        EqualityComparer<TValue> c = EqualityComparer<TValue>.Default;
        for(int i=0;i<count;i++){
            if(entries[i].hashCode>=0&&c.Equals(entries[i].value,value))return true;
        }
    }
    return false;
}
public Enumerator GetEnumerator(){
    return new Enumerator(this,Enumerator.KeyValuePair);
}