• garray
    • 使用示例1,普通数组
    • 使用示例2,排序数组

    garray

    数组容器,提供普通数组,及排序数组,支持数据项唯一性矫正,支持可选的并发安全参数控制。

    使用场景

    数组操作。

    使用方式

    1. import "github.com/gogf/gf/g/container/garray"

    接口文档

    https://godoc.org/github.com/gogf/gf/g/container/garray

    由于garray模块下的对象及方法较多,支持int/string/interface{}三种数据类型,这里便不一一列举。garray下包含了多种数据类型的slice,可以使用 garray.New*Array/garray.NewSorted*Array 方法来创建,其中garray.New*Array为普通不排序数组,garray.NewSorted*Array为排序数组(当创建interface{}类型的数组时,创建时可以指定自定义的排序函数)。

    使用示例1,普通数组

    1. package main
    2. import (
    3. "fmt"
    4. "github.com/gogf/gf/g/container/garray"
    5. )
    6. func main () {
    7. // 创建普通的int类型数组,并关闭默认的并发安全特性
    8. a := garray.NewIntArray(true)
    9. // 添加数据项
    10. for i := 0; i < 10; i++ {
    11. a.Append(i)
    12. }
    13. // 获取当前数组长度
    14. fmt.Println(a.Len())
    15. // 获取当前数据项列表
    16. fmt.Println(a.Slice())
    17. // 获取指定索引项
    18. fmt.Println(a.Get(6))
    19. // 在指定索引前插入数据项
    20. a.InsertAfter(9, 11)
    21. // 在指定索引后插入数据项
    22. a.InsertBefore(10, 10)
    23. fmt.Println(a.Slice())
    24. // 修改指定索引的数据项
    25. a.Set(0, 100)
    26. fmt.Println(a.Slice())
    27. // 搜索数据项,返回搜索到的索引位置
    28. fmt.Println(a.Search(5))
    29. // 删除指定索引的数据项
    30. a.Remove(0)
    31. fmt.Println(a.Slice())
    32. // 并发安全,写锁操作
    33. a.LockFunc(func(array []int) {
    34. // 将末尾项改为100
    35. array[len(array) - 1] = 100
    36. })
    37. // 并发安全,读锁操作
    38. a.RLockFunc(func(array []int) {
    39. fmt.Println(array[len(array) - 1])
    40. })
    41. // 清空数组
    42. fmt.Println(a.Slice())
    43. a.Clear()
    44. fmt.Println(a.Slice())
    45. }

    执行后,输出结果为:

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

    使用示例2,排序数组

    排序数组的方法与普通数组类似,但是带有自动排序功能及唯一性过滤功能。

    1. package main
    2. import (
    3. "fmt"
    4. "github.com/gogf/gf/g/container/garray"
    5. )
    6. func main () {
    7. // 自定义排序数组,降序排序(SortedIntArray管理的数据是升序)
    8. a := garray.NewSortedArray(func(v1, v2 interface{}) int {
    9. if v1.(int) < v2.(int) {
    10. return 1
    11. }
    12. if v1.(int) > v2.(int) {
    13. return -1
    14. }
    15. return 0
    16. })
    17. // 添加数据
    18. a.Add(2)
    19. a.Add(3)
    20. a.Add(1)
    21. fmt.Println(a.Slice())
    22. // 添加重复数据
    23. a.Add(3)
    24. fmt.Println(a.Slice())
    25. // 检索数据,返回最后对比的索引位置,检索结果
    26. // 检索结果:0: 匹配; <0:参数小于对比值; >0:参数大于对比值
    27. fmt.Println(a.Search(1))
    28. // 设置不可重复
    29. a.SetUnique(true)
    30. fmt.Println(a.Slice())
    31. a.Add(1)
    32. fmt.Println(a.Slice())
    33. }

    执行后,输出结果:

    1. [3 2 1]
    2. [3 3 2 1]
    3. 3 0
    4. [3 2 1]
    5. [3 2 1]