gmap

    该模块包含多个数据结构的map容器：HashMap、TreeMap和ListMap。

    使用场景：

    任何map/哈希表/关联数组使用场景，尤其是并发安全场景中。

    使用方式：

    接口文档：

    1. package main
    3. import (
    4.     "fmt"
    5.     "github.com/gogf/gf/container/gmap"
    6. )
    8. func main() {
    9.     // 创建一个默认的gmap对象，
    10.     // 默认情况下该gmap对象不支持并发安全特性，
    11.     // 初始化时可以给定true参数开启并发安全特性。
    12.     m := gmap.New()
    14.     // 设置键值对
    15.     for i := 0; i < 10; i++ {
    16.         m.Set(i, i)
    17.     }
    18.     // 查询大小
    19.     fmt.Println(m.Size())
    20.     // 批量设置键值对(不同的数据类型对象参数不同)
    21.     m.Sets(map[interface{}]interface{}{
    22.         10 : 10,
    23.         11 : 11,
    24.     })
    25.     fmt.Println(m.Size())
    27.     // 查询是否存在
    28.     fmt.Println(m.Contains(1))
    30.     // 查询键值
    31.     fmt.Println(m.Get(1))
    33.     // 删除数据项
    34.     m.Remove(9)
    35.     fmt.Println(m.Size())
    37.     // 批量删除
    38.     m.Removes([]interface{}{10, 11})
    39.     fmt.Println(m.Size())
    41.     // 当前键名列表(随机排序)
    42.     fmt.Println(m.Keys())
    43.     // 当前键值列表(随机排序)
    44.     fmt.Println(m.Values())
    46.     // 查询键名，当键值不存在时，写入给定的默认值
    47.     fmt.Println(m.GetOrSet(100, 100))
    49.     // 删除键值对，并返回对应的键值
    50.     fmt.Println(m.Remove(100))
    52.     // 遍历map
    53.     m.Iterator(func(k interface{}, v interface{}) bool {
    54.         fmt.Printf("%v:%v ", k, v)
    55.         return true
    56.     })
    58.     m.LockFunc(func(m map[interface{}]interface{}) {
    59.         m[99] = 99
    60.     })
    62.     // 自定义读锁操作
    63.     m.RLockFunc(func(m map[interface{}]interface{}) {
    64.         fmt.Println(m[99])
    65.     })
    67.     // 清空map
    68.     m.Clear()
    70.     // 判断map是否为空
    71.     fmt.Println(m.IsEmpty())
    72. }

    执行后，输出结果为：

    1. 10
    2. 12
    3. true
    4. 1
    5. 11
    6. 9
    7. [0 1 2 4 6 7 3 5 8]
    8. [3 5 8 0 1 2 4 6 7]
    9. 100
    10. 100
    11. 3:3 5:5 8:8 7:7 0:0 1:1 2:2 4:4 6:6 99
    12. true

    示例2，有序遍历

    我们来看一下三种不同类型map的有序性遍历示例。

    1. package main
    3. import (
    4.     "fmt"
    5.     "github.com/gogf/gf/frame/g"
    6.     "github.com/gogf/gf/container/gmap"
    7.     "github.com/gogf/gf/util/gutil"
    8. )
    10. func main() {
    11.     array   := g.Slice{2, 3, 1, 5, 4, 6, 8, 7, 9}
    12.     hashMap := gmap.New(true)
    13.     listMap := gmap.NewListMap(true)
    14.     treeMap := gmap.NewTreeMap(gutil.ComparatorInt, true)
    15.     for _, v := range array {
    16.         hashMap.Set(v, v)
    17.     }
    18.     for _, v := range array {
    19.         listMap.Set(v, v)
    20.     }
    21.     for _, v := range array {
    22.         treeMap.Set(v, v)
    23.     }
    24.     fmt.Println("HashMap   Keys:", hashMap.Keys())
    25.     fmt.Println("HashMap Values:", hashMap.Values())
    26.     fmt.Println("ListMap   Keys:", listMap.Keys())
    27.     fmt.Println("ListMap Values:", listMap.Values())
    28.     fmt.Println("TreeMap   Keys:", treeMap.Keys())
    29.     fmt.Println("TreeMap Values:", treeMap.Values())
    30. }

    执行后，输出结果为：

    gmap模块下的所有容器类型均实现了标准库json数据格式的序列化/反序列化接口。

    1. Marshal

      1.  package main
      3.  import (
      4.      "encoding/json"
      5.      "fmt"
      6.      "github.com/gogf/gf/frame/g"
      8.  )
      10.  func main() {
      11.      m := gmap.New()
      13.          "name":  "john",
      14.          "score": 100,
      15.      })
      16.      b, _ := json.Marshal(m)
      17.      fmt.Println(string(b))
      18.  }

      执行后，输出结果：

      1.  {"name":"john","score":100}
      1.  package main
      3.  import (
      4.      "encoding/json"
      5.      "fmt"
      6.      "github.com/gogf/gf/container/gmap"
      7.  )
      9.  func main() {
      10.      m := gmap.Map{}
      11.      s := []byte(`{"name":"john","score":100}`)
      12.      json.Unmarshal(s, &m)
      13.      fmt.Println(m.Map())
      14.  }

      执行后，输出结果：

    gmap支持并发安全选项开关，在默认情况下是非并发安全的，开发者可以选择开启gmap的并发安全特性(传递初始化开关参数safe参数值为true, 必须在初始化时设定，不能运行时动态设定)。如：

    1. m := gmap.New(true)

    不仅仅是gmap模块，gf框架的其他并发安全数据结构也支持并发安全特性开关。

    并发安全

    https://github.com/gogf/gf/blob/master/container/gmap/gmap_z_bench_safe_test.go

    1. goos: darwin
    2. goarch: amd64
    3. Benchmark_IntIntMap_Set-4               10000000               202 ns/op              15 B/op          0 allocs/op
    4. Benchmark_IntAnyMap_Set-4               10000000               262 ns/op              29 B/op          1 allocs/op
    5. Benchmark_IntStrMap_Set-4               10000000               241 ns/op              22 B/op          0 allocs/op
    6. Benchmark_AnyAnyMap_Set-4                5000000               359 ns/op              40 B/op          2 allocs/op
    7. Benchmark_StrIntMap_Set-4                5000000               305 ns/op              26 B/op          1 allocs/op
    8. Benchmark_StrAnyMap_Set-4                5000000               354 ns/op              40 B/op          2 allocs/op
    9. Benchmark_StrStrMap_Set-4                5000000               338 ns/op              32 B/op          1 allocs/op
    10. Benchmark_IntIntMap_Get-4               20000000              86.6 ns/op               0 B/op          0 allocs/op
    11. Benchmark_IntAnyMap_Get-4               30000000              69.7 ns/op               0 B/op          0 allocs/op
    12. Benchmark_IntStrMap_Get-4               30000000              69.6 ns/op               0 B/op          0 allocs/op
    13. Benchmark_AnyAnyMap_Get-4               20000000              74.4 ns/op               0 B/op          0 allocs/op
    14. Benchmark_StrIntMap_Get-4               20000000               116 ns/op               7 B/op          0 allocs/op
    15. Benchmark_StrAnyMap_Get-4               20000000              92.3 ns/op               7 B/op          0 allocs/op
    16. Benchmark_StrStrMap_Get-4               20000000              91.9 ns/op               7 B/op          0 allocs/op

    1. goos: darwin
    2. goarch: amd64
    3. Benchmark_Unsafe_IntIntMap_Set-4        10000000               318 ns/op              62 B/op          0 allocs/op
    4. Benchmark_Unsafe_IntAnyMap_Set-4         5000000               282 ns/op              57 B/op          1 allocs/op
    5. Benchmark_Unsafe_IntStrMap_Set-4         5000000               332 ns/op              82 B/op          1 allocs/op
    6. Benchmark_Unsafe_AnyAnyMap_Set-4         3000000               471 ns/op              73 B/op          2 allocs/op
    7. Benchmark_Unsafe_StrIntMap_Set-4         5000000               429 ns/op              82 B/op          1 allocs/op
    8. Benchmark_Unsafe_StrAnyMap_Set-4         3000000               424 ns/op              73 B/op          2 allocs/op
    9. Benchmark_Unsafe_StrStrMap_Set-4         2000000               515 ns/op              96 B/op          2 allocs/op
    10. Benchmark_Unsafe_IntIntMap_Get-4        10000000               133 ns/op               0 B/op          0 allocs/op
    11. Benchmark_Unsafe_IntAnyMap_Get-4        20000000               134 ns/op               0 B/op          0 allocs/op
    12. Benchmark_Unsafe_IntStrMap_Get-4        10000000               126 ns/op               0 B/op          0 allocs/op
    13. Benchmark_Unsafe_AnyAnyMap_Get-4        10000000               166 ns/op               0 B/op          0 allocs/op
    14. Benchmark_Unsafe_StrIntMap_Get-4         5000000               246 ns/op               7 B/op          0 allocs/op
    15. Benchmark_Unsafe_StrAnyMap_Get-4        10000000               238 ns/op               7 B/op          0 allocs/op
    16. Benchmark_Unsafe_StrStrMap_Get-4         5000000               229 ns/op               7 B/op          0 allocs/op

    不同类型map性能

    我们来看看基准测试对比结果：https://github.com/gogf/gf/blob/master/container/gmap/gmap_z_bench_syncmap_test.go

    1. goos: darwin
    2. goarch: amd64
    3. Benchmark_GMapSet-4                     10000000               209 ns/op              15 B/op          0 allocs/op
    4. Benchmark_SyncMapSet-4                   3000000               451 ns/op              67 B/op          3 allocs/op
    5. Benchmark_GMapGet-4                     30000000              66.4 ns/op               0 B/op          0 allocs/op
    6. Benchmark_SyncMapGet-4                  30000000              36.0 ns/op               0 B/op          0 allocs/op