• gset
    • 使用示例
      • 示例1，基本使用
      • 示例2，交差并补集
    • 性能测试

    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