gset

集合，即不可重复的一组元素，元素项可以为任意类型。

同时，gset支持可选的并发安全参数选项，支持并发安全的场景。

使用场景：

集合操作。

使用方式：

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

接口文档：https://godoc.org/github.com/gogf/gf/g/container/gset

使用示例

示例1，基本使用

  1. package main
  3. import (
  4.     "github.com/gogf/gf/g/container/gset"
  5.     "fmt"
  6. )
  8. func main() {
  9.     // 创建一个非并发安全的集合对象
  10.     s := gset.New(true)
  12.     // 添加数据项
  13.     s.Add(1)
  15.     // 批量添加数据项
  16.     s.Add([]interface{}{1, 2, 3}...)
  18.     // 集合数据项大小
  19.     fmt.Println(s.Size())
  21.     // 集合中是否存在指定数据项
  22.     fmt.Println(s.Contains(2))
  24.     // 返回数据项slice
  25.     fmt.Println(s.Slice())
  27.     // 删除数据项
  28.     s.Remove(3)
  30.     // 遍历数据项
  31.     s.Iterator(func(v interface{}) bool {
  32.         fmt.Println("Iterator:", v)
  33.         return true
  34.     })
  36.     // 将集合转换为字符串
  37.     fmt.Println(s.String())
  39.     // 并发安全写锁操作
  40.     s.LockFunc(func(m map[interface{}]struct{}) {
  41.         m[4] = struct{}{}
  42.     })
  44.     // 并发安全读锁操作
  45.     s.RLockFunc(func(m map[interface{}]struct{}) {
  46.         fmt.Println(m)
  47.     })
  49.     // 清空集合
  50.     s.Clear()
  51.     fmt.Println(s.Size())
  52. }

执行后，输出结果为：

  1. 3
  2. true
  3. [1 2 3]
  4. Iterator: 1
  5. Iterator: 2
  6. [1 2]
  7. map[1:{} 2:{} 4:{}]
  8. 0

示例2，交差并补集

我们可以使用以下方法实现交差并补集，并返回一个新的结果集合，

  1. func (set *Set) Intersect(others ...*Set) (newSet *Set)
  2. func (set *Set) Diff(others ...*Set) (newSet *Set)
  3. func (set *Set) Union(others ...*Set) (newSet *Set)
  4. func (set *Set) Complement(full *Set) (newSet *Set)
  1. Intersect: 交集，属于set或属于others的元素为元素的集合。
  2. Diff: 差集，属于set且不属于others的元素为元素的集合。
  3. Union: 并集，属于set或属于others的元素为元素的集合。
  4. Complement: 补集，(前提: set应当为full的子集)属于全集full不属于集合set的元素组成的集合。如果给定的full集合不是set的全集时，返回full与set的差集.

通过集合方法我们可以发现，交差并集方法支持多个集合参数进行计算。以下为简化示例，只使用一个参数集合。

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gogf/gf/g"
  6.     "github.com/gogf/gf/g/container/gset"
  7. )
  9. func main() {
  10.     s1 := gset.NewFrom(g.Slice{1, 2, 3})
  11.     s2 := gset.NewFrom(g.Slice{4, 5, 6})
  12.     s3 := gset.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7})
  14.     // 交集
  15.     fmt.Println(s3.Intersect(s1).Slice())
  16.     // 差集
  17.     fmt.Println(s3.Diff(s1).Slice())
  18.     // 并集
  19.     fmt.Println(s1.Union(s2).Slice())
  20.     // 补集
  21.     fmt.Println(s1.Complement(s3).Slice())
  22. }

执行后，输出结果为：

  1. [1 2 3]
  2. [4 5 6 7]
  3. [1 2 3 4 5 6]
  4. [7 4 5 6]

性能测试

https://github.com/gogf/gf/blob/master/g/container/gset/gset_z_bench_test.go

  1. goos: darwin
  2. goarch: amd64
  3. Benchmark_IntSet_Add-4                  10000000               277 ns/op               8 B/op          0 allocs/op
  4. Benchmark_IntSet_Contains-4             20000000              60.6 ns/op               0 B/op          0 allocs/op
  5. Benchmark_IntSet_Remove-4               10000000               211 ns/op               0 B/op          0 allocs/op
  6. Benchmark_AnySet_Add-4                   5000000               312 ns/op              21 B/op          1 allocs/op
  7. Benchmark_AnySet_Contains-4             30000000              68.2 ns/op               0 B/op          0 allocs/op
  8. Benchmark_AnySet_Remove-4                5000000               267 ns/op               0 B/op          0 allocs/op
  9. Benchmark_StrSet_Add-4                   5000000               383 ns/op              20 B/op          1 allocs/op
  10. Benchmark_StrSet_Contains-4             10000000               160 ns/op               7 B/op          0 allocs/op
  11. Benchmark_StrSet_Remove-4                5000000               306 ns/op               7 B/op          0 allocs/op
  12. Benchmark_Unsafe_IntSet_Add-4           10000000               258 ns/op              35 B/op          0 allocs/op
  13. Benchmark_Unsafe_IntSet_Contains-4      20000000               146 ns/op               0 B/op          0 allocs/op
  14. Benchmark_Unsafe_IntSet_Remove-4        10000000               173 ns/op               0 B/op          0 allocs/op
  15. Benchmark_Unsafe_AnySet_Add-4            5000000               355 ns/op              41 B/op          1 allocs/op
  16. Benchmark_Unsafe_AnySet_Contains-4      10000000               150 ns/op               0 B/op          0 allocs/op
  17. Benchmark_Unsafe_AnySet_Remove-4        200000000             11.9 ns/op               0 B/op          0 allocs/op
  18. Benchmark_Unsafe_StrSet_Add-4            5000000               486 ns/op              59 B/op          1 allocs/op
  19. Benchmark_Unsafe_StrSet_Contains-4       5000000               298 ns/op               7 B/op          0 allocs/op
  20. Benchmark_Unsafe_StrSet_Remove-4        10000000               158 ns/op               7 B/op          0 allocs/op