数组容器，提供普通数组，及排序数组，支持数据项唯一性矫正，支持并发安全开关控制。

使用场景：

数组操作。

使用方式：

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

接口文档：

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

简要说明：

  1. garray模块下的对象及方法较多，建议仔细看看接口文档。
  2. garray支持int/string/interface{}三种常用的数据类型。
  3. garray支持普通数组和排序数组，普通数组的结构体名称定义为*Array格式，排序数组的结构体名称定义为Sorted*Array格式，如下：
    • Array, intArray, StrArray
    • SortedArray, SortedIntArray, SortedStrArray
    • 其中排序数组SortedArray，需要给定排序比较方法，在工具包gutil中也定义了很多Comparator*比较方法

以下示例主要展示一些常见数组用法，更多的方法请参考接口文档或源码。

普通数组

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gogf/gf/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 true
  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. []

排序数组

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

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gogf/gf/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]

Iterate*数组遍历

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gogf/gf/container/garray"
  6.     "github.com/gogf/gf/frame/g"
  7. )
  9. func main() {
  10.     array := garray.NewStrArrayFrom(g.SliceStr{"a", "b", "c"})
  11.     // Iterator is alias of IteratorAsc, which iterates the array readonly in ascending order
  12.     //  with given callback function <f>.
  13.     // If <f> returns true, then it continues iterating; or false to stop.
  14.     array.Iterator(func(k int, v string) bool {
  15.         fmt.Println(k, v)
  16.         return true
  17.     })
  18.     // IteratorDesc iterates the array readonly in descending order with given callback function <f>.
  19.     // If <f> returns true, then it continues iterating; or false to stop.
  20.     array.IteratorDesc(func(k int, v string) bool {
  21.         fmt.Println(k, v)
  22.         return true
  23.     })
  25.     // Output:
  26.     // 0 a
  27.     // 1 b
  28.     // 2 c
  29.     // 2 c
  30.     // 1 b
  31.     // 0 a
  32. }

Pop*数组项出栈

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gogf/gf/container/garray"
  6. )
  8. func main() {
  9.     array := garray.NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})
  11.     // Any Pop* functions pick, delete and return the item from array.
  13.     fmt.Println(array.PopLeft())
  14.     fmt.Println(array.PopLefts(2))
  15.     fmt.Println(array.PopRight())
  16.     fmt.Println(array.PopRights(2))
  18.     // Output:
  19.     // 1 true
  20.     // [2 3]
  21.     // 9 true
  22.     // [7 8]
  23. }

Rand/PopRand数组项随机获取/出栈

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gogf/gf/container/garray"
  6.     "github.com/gogf/gf/frame/g"
  7. )
  9. func main() {
  10.     array := garray.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9})
  12.     // Randomly retrieve and return 2 items from the array.
  13.     // It does not delete the items from array.
  14.     fmt.Println(array.Rands(2))
  16.     // Randomly pick and return one item from the array.
  17.     // It deletes the picked up item from array.
  18.     fmt.Println(array.PopRand())
  19. }

Contains/ContainsI包含判断

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gogf/gf/container/garray"
  6. )
  8. func main() {
  9.     var array garray.StrArray
  10.     array.Append("a")
  11.     fmt.Println(array.Contains("a"))
  12.     fmt.Println(array.Contains("A"))
  13.     fmt.Println(array.ContainsI("A"))
  15.     // Output:
  16.     // true
  17.     // false
  18.     // true
  19. }

FilterEmpty/FilterNil空值过滤

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gogf/gf/container/garray"
  6.     "github.com/gogf/gf/frame/g"
  7. )
  9. func main() {
  10.     array1 := garray.NewFrom(g.Slice{0, 1, 2, nil, "", g.Slice{}, "john"})
  11.     array2 := garray.NewFrom(g.Slice{0, 1, 2, nil, "", g.Slice{}, "john"})
  12.     fmt.Printf("%#v\n", array1.FilterNil().Slice())
  13.     fmt.Printf("%#v\n", array2.FilterEmpty().Slice())
  15.     // Output:
  16.     // []interface {}{0, 1, 2, "", []interface {}{}, "john"}
  17.     // []interface {}{1, 2, "john"}
  18. }

Reverse数组翻转

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gogf/gf/container/garray"
  6.     "github.com/gogf/gf/frame/g"
  7. )
  9. func main() {
  10.     array := garray.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9})
  12.     // Reverse makes array with elements in reverse order.
  13.     fmt.Println(array.Reverse().Slice())
  15.     // Output:
  16.     // [9 8 7 6 5 4 3 2 1]
  17. }

Shuffle随机排序

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gogf/gf/container/garray"
  6.     "github.com/gogf/gf/frame/g"
  7. )
  9. func main() {
  10.     array := garray.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9})
  12.     // Shuffle randomly shuffles the array.
  13.     fmt.Println(array.Shuffle().Slice())
  14. }

Walk遍历修改

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gogf/gf/container/garray"
  6.     "github.com/gogf/gf/frame/g"
  7. )
  9. func main() {
  10.     var array garray.StrArray
  11.     tables := g.SliceStr{"user", "user_detail"}
  12.     prefix := "gf_"
  13.     array.Append(tables...)
  14.     // Add prefix for given table names.
  15.     array.Walk(func(value string) string {
  16.         return prefix + value
  17.     })
  18.     fmt.Println(array.Slice())
  20.     // Output:
  21.     // [gf_user gf_user_detail]
  22. }

Join数组项串连

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gogf/gf/container/garray"
  6.     "github.com/gogf/gf/frame/g"
  7. )
  9. func main() {
  10.     array := garray.NewFrom(g.Slice{"a", "b", "c", "d"})
  11.     fmt.Println(array.Join(","))
  13.     // Output:
  14.     // a,b,c,d
  15. }

Chunk数组拆分

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gogf/gf/container/garray"
  6.     "github.com/gogf/gf/frame/g"
  7. )
  9. func main() {
  10.     array := garray.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9})
  12.     // Chunk splits an array into multiple arrays,
  13.     // the size of each array is determined by <size>.
  14.     // The last chunk may contain less than size elements.
  15.     fmt.Println(array.Chunk(2))
  17.     // Output:
  18.     // [[1 2] [3 4] [5 6] [7 8] [9]]
  19. }

Merge数组合并

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gogf/gf/container/garray"
  6.     "github.com/gogf/gf/frame/g"
  7. )
  9. func main() {
  10.     array1 := garray.NewFrom(g.Slice{1, 2})
  11.     array2 := garray.NewFrom(g.Slice{3, 4})
  12.     slice1 := g.Slice{5, 6}
  13.     slice2 := []int{7, 8}
  14.     slice3 := []string{"9", "0"}
  15.     fmt.Println(array1.Slice())
  16.     array1.Merge(array1)
  17.     array1.Merge(array2)
  18.     array1.Merge(slice1)
  19.     array1.Merge(slice2)
  20.     array1.Merge(slice3)
  21.     fmt.Println(array1.Slice())
  23.     // Output:
  24.     // [1 2]
  25.     // [1 2 1 2 3 4 5 6 7 8 9 0]
  26. }

JSON序列化/反序列

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

  1. Marshal 
  1. package mainimport (
  2.     "encoding/json"
  3.     "fmt"
  4.     "github.com/gogf/gf/container/garray"
  5. )
  7. func main() {
  8.     type Student struct {
  9.         Id     int
  10.         Name   string
  11.         Scores *garray.IntArray
  12.     }
  13.     s := Student{
  14.         Id:     1,
  15.         Name:   "john",
  16.         Scores: garray.NewIntArrayFrom([]int{100, 99, 98}),
  17.     }
  18.     b, _ := json.Marshal(s)
  19.     fmt.Println(string(b))
  20. }

执行后，输出结果：

  1.  {"Id":1,"Name":"john","Scores":[100,99,98]}
  1. Unmarshal
  1. package main
  4. import (
  5.     "encoding/json"
  6.     "fmt"
  7.     "github.com/gogf/gf/container/garray"
  8. )
  11. func main() {
  12.     b := []byte(`{"Id":1,"Name":"john","Scores":[100,99,98]}`)
  13.     type Student struct {
  14.         Id     int
  15.         Name   string
  16.         Scores *garray.IntArray
  17.     }
  18.     s := Student{}
  19.     json.Unmarshal(b, &s)
  20.     fmt.Println(s)
  21. }

执行后，输出结果：

  1. {1 john [100,99,98]}