浅析go中的map数据结构字典_Golang_

 package main import ( "fmt" ) // bool 的零值是false var m map[int]bool a, ok := m[1] fmt.Println(a, ok) // false false // int 的零值是0 var m map[int]int a, ok := m[1] fmt.Println(a, ok) // 0 false func main() { var agemap[string]int if age== nil { fmt.Println("map is nil.") age= make(map[string]int) } }

 func main() { exp := map[string]int{ "steve": 20, "jamie": 80, } fmt.Println("Ori exp", age) newexp:= exp newexp["steve"] = 18 fmt.Println("exp changed", exp) } //Ori age map[steve:20 jamie:80] //age changed map[steve:18 jamie:80]

 //正常遍历： for k, v := range exp { fmt.Println(k, v) } //有序遍历 import "sort" var keys []string // 把key单独抽取出来，放在数组中 for k, _ := range exp { keys = append(keys, k) } // 进行数组的排序 sort.Strings(keys) // 遍历数组就是有序的了 for _, k := range keys { fmt.Println(k, m[k]) }

 type hmap struct { count int //元素个数 flags uint8 B uint8 //扩容常量 noverflow uint16 //溢出 bucket 个数 hash0 uint32 //hash 种子 buckets unsafe.Pointer //bucket 数组指针 oldbuckets unsafe.Pointer //扩容时旧的buckets 数组指针 nevacuate uintptr //扩容搬迁进度 extra *mapextra //记录溢出相关 } type bmap struct { tophash [bucketCnt]uint8 // Followed by bucketCnt keys //and then bucketan Cnt values // Followed by overflow pointer. }

 // mapextra holds fields that are not present on all maps. type mapextra struct { // If both key and value do not contain pointers and are inline, then we mark bucket // type as containing no pointers. This avoids scanning such maps. // However, bmap.overflow is a pointer. In order to keep overflow buckets // alive, we store pointers to all overflow buckets in hmap.extra.overflow and hmap.extra.oldoverflow. // overflow and oldoverflow are only used if key and value do not contain pointers. // overflow contains overflow buckets for hmap.buckets. // oldoverflow contains overflow buckets for hmap.oldbuckets. // The indirection allows to store a pointer to the slice in hiter. overflow *[]*bmap oldoverflow *[]*bmap // nextOverflow holds a pointer to a free overflow bucket. nextOverflow *bmap }

 type typeAlg struct { // function for hashing objects of this type // (ptr to object, seed) -> hash hash func(unsafe.Pointer, uintptr) uintptr // function for comparing objects of this type // (ptr to object A, ptr to object B) -> ==? equal func(unsafe.Pointer, unsafe.Pointer) bool // tophash calculates the tophash value for hash. func tophash(hash uintptr) uint8 { top := uint8(hash >> (sys.PtrSize*8 - 8)) if top < minTopHash { top += minTopHash } return top }

 //makemap为make（map [k] v，hint）实现Go map创建。 //如果编译器已确定映射或第一个存储桶,可以在堆栈上创建，hmap或bucket可以为非nil。 //如果h！= nil，则可以直接在h中创建map。 //如果h.buckets！= nil，则指向的存储桶可以用作第一个存储桶。 func makemap(t *maptype, hint int, h *hmap) *hmap { if hint < 0 || hint > int(maxSliceCap(t.bucket.size)) { hint = 0 } // 初始化Hmap if h == nil { h = new(hmap) } h.hash0 = fastrand() // 查找将保存请求的元素数的size参数 B := uint8(0) for overLoadFactor(hint, B) { B++ } h.B = B // 分配初始哈希表 // if B == 0, 稍后会延迟分配buckets字段（在mapassign中） //如果提示很大，则将内存清零可能需要一段时间。 if h.B != 0 { var nextOverflow *bmap h.buckets, nextOverflow = makeBucketArray(t, h.B, nil) if nextOverflow != nil { h.extra = new(mapextra) h.extra.nextOverflow = nextOverflow } } return h }

 // makeBucketArray初始化地图存储区的后备数组。 // 1 << b是要分配的最小存储桶数。 // dirtyalloc之前应该为nil或bucket数组 //由makeBucketArray使用相同的t和b参数分配。 //如果dirtyalloc为零，则将分配一个新的支持数组，dirtyalloc将被清除并作为后备数组重用。 func makeBucketArray(t *maptype, b uint8, dirtyalloc unsafe.Pointer) (buckets unsafe.Pointer, nextOverflow *bmap) { base := bucketShift(b) nbuckets := base // 对于小b，溢出桶不太可能出现。 // 避免计算的开销。 if b >= 4 { //加上估计的溢出桶数 //插入元素的中位数 //与此值b一起使用。 nbuckets += bucketShift(b - 4) sz := t.bucket.size * nbuckets up := roundupsize(sz) if up != sz { nbuckets = up / t.bucket.size } } if dirtyalloc == nil { buckets = newarray(t.bucket, int(nbuckets)) } else { // dirtyalloc先前是由上面的newarray（t.bucket，int（nbuckets）），但不能为空。 buckets = dirtyalloc size := t.bucket.size * nbuckets if t.bucket.kind&kindNoPointers == 0 { memclrHasPointers(buckets, size) } else { memclrNoHeapPointers(buckets, size) } } if base != nbuckets { //我们预先分配了一些溢出桶。 //为了将跟踪这些溢出桶的开销降至最低，我们使用的约定是，如果预分配的溢出存储桶发生了溢出指针为零，则通过碰撞指针还有更多可用空间。 //对于最后一个溢出存储区，我们需要一个安全的非nil指针；只是用bucket。 nextOverflow = (*bmap)(add(buckets, base*uintptr(t.bucketsize))) last := (*bmap)(add(buckets, (nbuckets-1)*uintptr(t.bucketsize))) last.setoverflow(t, (*bmap)(buckets)) } return buckets, nextOverflow }

 // mapaccess1返回指向h [key]的指针。从不返回nil，而是 如果值类型为零，它将返回对零对象的引用,该键不在map中。 //注意：返回的指针可能会使整个map保持活动状态，因此请不要坚持很长时间。 func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer { if raceenabled && h != nil { //raceenabled是否启用数据竞争检测。 callerpc := getcallerpc() pc := funcPC(mapaccess1) racereadpc(unsafe.Pointer(h), callerpc, pc) raceReadObjectPC(t.key, key, callerpc, pc) } if msanenabled && h != nil { msanread(key, t.key.size) } if h == nil || h.count == 0 { return unsafe.Pointer(&zeroVal[0]) } // 并发访问检查 if h.flags&hashWriting != 0 { throw("concurrent map read and map write") } // 计算key的hash值 alg := t.key.alg hash := alg.hash(key, uintptr(h.hash0)) // alg.hash // hash值对m取余数得到对应的bucket m := uintptr(1)<>= 1 } oldb := (*bmap)(add(c, (hash&m)*uintptr(t.bucketsize))) if !evacuated(oldb) { b = oldb } } // 计算tophash，取高8位 top := uint8(hash >> (sys.PtrSize*8 - 8)) for { for i := uintptr(0); i < bucketCnt; i++ { // 检查top值，如高8位不一样就找下一个 if b.tophash[i] != top { continue } // 取key的地址 k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize)) if alg.equal(key, k) { // alg.equal // 取value得地址 v := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize)) } } // 如果当前bucket没有找到，则找bucket链的下一个bucket b = b.overflow(t) if b == nil { // 返回零值 return unsafe.Pointer(&zeroVal[0]) } } }

 // 与mapaccess类似，但是如果map中不存在密钥，则为该密钥分配一个插槽 func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsa
                
提示：
                    本文由神整理自网络，如有侵权请联系本站删除！
                    

                    本站声明： 

                    1、本站所有资源均来源于互联网，不保证100%完整、不提供任何技术支持； 

                    2、本站所发布的文章以及附件仅限用于学习和研究目的;不得将用于商业或者非法用途；否则由此产生的法律后果，本站概不负责！
                
                

                

                                            
上一篇：golang环形队列实现代码示例_Golang_
                                                                
下一篇：如何在Go中使用切片容量和长度_Golang_