golang 数据三 (字典)

golang基本数据结构Map也叫字典，字典的声明格式如下： map[KeyType]ValueType

字典是无序键值对集合，字典要求KeyType必须是支持相等运算符(==,!=)的数据类型，比如：数字、字符串、指针、数组、结构体以及对应的接口类型，而ValueType可以是任意类型，字典也是引用类型，使用make函数或者初始化表达式语句来创建。比如：

{     m := make(map[string]int)    //创建一个字典     m["a"] = 1      m["b"] = 2      m2 := map[int]struct{   //匿名结构体         x int      }{           1: {x:100},         2: {x:200},     }        fmt.Println(m,m2) }

字典的基本操作

比如：

{     m := make(map[string]int)     m["route"] = 66 //添加key     i := m["route"] //读取key     j := m["root"]  //the value type is int, so the zero value is 0     n := len(m) //获取长度     //n := cap(m)   // ???  引发一个思考     delete(m, "route") //删除key }

如果访问不存在的键，不会引发错误，而会默认返回ValueType的零值，那么还能否根据零值来判断key的存在呢？

在读取map操作时，可以使用双返回值来正常读取map，比如：

{     j, ok := m["root"] } 说明： ok是个bool类型变量，如果key真实存在，则ok的值为true，反之为false，如果你只是想测试key是否存在而不 获取值的话，可以使用忽略字符"_"。

在修改map值操作时，因为受内存访问安全和哈希算法等缘故，字典被设计成"not adrressable"，因此不能直接修改value成员(结构体或数组)。比如：

{     m := map[int] user {         1 : {             name:"tom",             age:19},     }     m[1].age = 1        //cannot assign to struct field m[1].age in map }

但是有两种方式可以实现直接修改map的value成员：

1. 是对整个value进行重新复制

2. 声明map时valueType为指针类型

{     m := map[int] user {         1 : {             name:"tom",             age:19},     }     u := m[1]     u.age = 1     m[1] = u } {     m := map[int] *user {         1 : {             name:"tom",             age:19},     }     m[1].age += 1 }

不能对nil字典进行写操作，但是可以读，比如：

{     var m map[string]int     //p := m["a"]       //ok     m["a"] = 1          //panic: assignment to entry in nil map }

map遍历：

{ //  var m = make(map[string]int)     var m = map[string]int{}     m["route"] = 66     m["root"] = 67     for key,value := range m{         fmt.Println("Key:", key, "Value:", value)     } }

因为map是无序的，如果想按照有序key输出的话，可以先把所有的key取出，然后对key进行排序，再遍历map，比如:

{     m := make(map[int]int)     var keys []int     for i := 0 ;i <= 5;i++{         m[i] = i     }                                                                                                                                                            for k, v := range m{         fmt.Println("Key:",k,"Value:",v)     }        for k := range m{         keys = append(keys, k)     }     sort.Ints(keys)     for _, k := range keys{         fmt.Println("Key:",k,"Value:",m[k])     } }

并发

字典不是并发安全的数据结构，如果某个任务正在对字典进行写操作，那么其他任务就不能对该字典执行并发操作(读、写、删除)，否则会导致程序崩溃，比如:

    m := make(map[string]int)     go func(){         for {             m["a"] += 1             time.Sleep(time.Microsecond)         }        }()      go func (){          for{             _ = m["b"]             time.Sleep(time.Microsecond)         }        }()      select{} } 输出： fatal error: concurrent map read and map write

GO语言编译器提供了这种问题(竞争)的检测方式，比如：

# go run -race file.go

安全

可以使用 sync.RWMutex 实现同步，避免并发环境多goroutings同时读写操作，继续完善上面的例子，比如：

{     var lock = new(sync.RWMutex)                                                                                                                           m := make(map[string]int)     go func(){         for {             lock.Lock()             m["a"]++             lock.Unlock()             time.Sleep(time.Microsecond)         }        }()      go func (){          for{             lock.RLock()             _ = m["b"]             lock.RUnlock()             time.Sleep(time.Microsecond)         }        }()      select{} }

性能

在创建字典时预先准备足够的空间有助于提升性能，减少扩张时引发内存动态分配和重复哈希操作，比如：

package main import "testing" import "fmt" func test() map[int]int {	m := make(map[int]int)	for i:=0; i < 1000; i++{	m[i] = 1	}	return m } func testCap() map[int]int{	m := make(map[int]int,1000)	for i:=0; i < 1000; i++{	m[i] = 1	}	return m } func BenchmarkTest(t *testing.B){	for i:= 0;i < t.N; i++{	test()	} } func BenchmarkTestCap(t *testing.B){	for i:= 0;i < t.N; i++{	testCap()	} } func main(){	resTest := testing.Benchmark(BenchmarkTest)	fmt.Printf("BenchmarkTest \t %d, %d ns/op,%d allocs/op, %d B/op\n", resTest.N, resTest.NsPerOp(), resTest.AllocsPerOp(), resTest.AllocedBytesPerOp())	resTest = testing.Benchmark(BenchmarkTestCap)	fmt.Printf("BenchmarkTestCap \t %d, %d ns/op,%d allocs/op, %d B/op\n", resTest.N, resTest.NsPerOp(), resTest.AllocsPerOp(), resTest.AllocedBytesPerOp()) } 输出： # go run conmap.go BenchmarkTest 	 10000, 160203 ns/op,98 allocs/op, 89556 B/op BenchmarkTestCap 20000, 65478 ns/op,12 allocs/op, 41825 B/op

借鉴：<<雨痕笔记>>