从底层到应用，想深入Map这篇文章千万不要错过！

type hmap struct {
  // Note: the format of the hmap is also encoded in cmd/compile/internal/gc/reflect.go.
  // Make sure this stays in sync with the compiler's definition.
  count     int // 哈希表中元素个数，即len(map)的返回值
  flags     uint8
  B         uint8  // 线性表中桶个数的的对数log_2(哈希表元素数量最大可达到装载因子*2^B)
  noverflow uint16 // 溢出桶的大概数字;详情见incrnoverflow
  hash0     uint32 // 哈希种子

  buckets    unsafe.Pointer // 指向线性表的指针，数组大小为2^B，如果元素个数为0，它为nil.
  oldbuckets unsafe.Pointer // 指向扩容后的老线性表地址
  nevacuate  uintptr        // 表示扩容进度

  extra *mapextra // 垃圾回收用
}

// A bucket for a Go map.
type bmap struct {
  // tophash包含此桶中每个键的哈希值最高字节（高8位）信息（也就是前面所述的high-order bits）。
  // 如果tophash[0] < minTopHash，tophash[0]则代表桶的搬迁（evacuation）状态。
    tophash [bucketCnt]uint8
}

func mapiterinit(t *maptype, h *hmap, it *hiter) {
  if raceenabled && h != nil {
    callerpc := getcallerpc()
    racereadpc(unsafe.Pointer(h), callerpc, funcPC(mapiterinit))
  }

  if h == nil || h.count == 0 {
    return
  }

  if unsafe.Sizeof(hiter{})/sys.PtrSize != 12 {
    throw("hash_iter size incorrect") // see cmd/compile/internal/gc/reflect.go
  }
  it.t = t
  it.h = h

  // grab snapshot of bucket state
  it.B = h.B
  it.buckets = h.buckets
  if t.bucket.ptrdata == 0 {
    // Allocate the current slice and remember pointers to both current and old.
    // This preserves all relevant overflow buckets alive even if
    // the table grows and/or overflow buckets are added to the table
    // while we are iterating.
    h.createOverflow()
    it.overflow = h.extra.overflow
    it.oldoverflow = h.extra.oldoverflow
  }

  // 产生随机数
  r := uintptr(fastrand())
  if h.B > 31-bucketCntBits {
    r += uintptr(fastrand()) << 31
  }
  //决定桶的开始位置
  it.startBucket = r & bucketMask(h.B)
  //决定桶中bmap的开始位置
  it.offset = uint8(r >> h.B & (bucketCnt - 1))

  // iterator state
  it.bucket = it.startBucket

  // Remember we have an iterator.
  // Can run concurrently with another mapiterinit().
  if old := h.flags; old&(iterator|oldIterator) != iterator|oldIterator {
    atomic.Or8(&h.flags, iterator|oldIterator)
  }

  mapiternext(it)
}

package main

import (
  "fmt"
  "sort"
)

func main() {

  //创建class包括超超和婷婷俩个对象
  class := map[int]string{1: "chaochao", 2: "tingting"}

  //辅助有序遍历的ids切片
  ids := make([]int, 0, 10)
  for k, _ := range class {
    ids = append(ids, k)
  }
  
  //对id进行排序
  sort.Ints(ids)
  for _, v := range ids {
    //根据有序切片取出
    fmt.Println(class[v])
  }
}

package main

import (
  "container/list"
  "fmt"
)

//Map结构体
type Map struct {
  ids   *list.List
  class map[interface{}]interface{}
}

//创建一个Map
func NewMap() *Map {
  m := &Map{
    ids:   list.New(),
    class: make(map[interface{}]interface{}),
  }
  return m
}

//向Map中添加元素
func (p *Map) push(id int, name string) bool {
  if p.class[id] != nil {
    return false
  }
  p.ids.PushBack(id)
  p.class[id] = name
  return true
}

//对ids排序，通过ids的顺序遍历获取names
func (p *Map) getNames() []interface{} {
  names := make([]interface{}, 0, p.ids.Len())
  //sort(p.ids)对list排序，篇幅有限读者可自行实现
  for i := p.ids.Front(); i != nil; i = i.Next() {
    names = append(names, p.class[i.Value])
  }
  return names
}

func main() {
  m := NewMap()
  m.push(1, "chaochao")
  m.push(2, "tingting")
  names := m.getNames()
  for k, v := range names {
    fmt.Println(k, v)
  }
}

package main

import (
  "fmt"
)

//定义Set结构体
type Set struct {
  class map[interface{}]bool
}

//创建一个Set
func NewSet() *Set {
  s := &Set{
    class: make(map[interface{}]bool),
  }
  return s
}

//向Set中添加元素
func (p *Set) push(id int, name string) bool {
  if p.class[id] {
    return false
  }
  p.class[name] = true
  return true
}

//对class中的key排序
func (p *Set) getNames() []interface{} {
  names := make([]interface{}, 0, len(p.class))
  for k, _ := range p.class {
    names = append(names, k)
  }
  //sort(names)
  return names
}

func main() {
  m := NewSet()
  m.push(1, "chaochao")
  m.push(2, "tingting")
  names := m.getNames()
  for k, v := range names {
    fmt.Println(k, v)
  }
}