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

执行后，输出结果为：

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

执行后，输出结果：

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