gset

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

    使用场景：

    集合操作。

    使用方式：

    1. package main
    3. import (
    4.     "github.com/gogf/gf/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.     })
    43.     // 并发安全读锁操作
    45.         fmt.Println(m)
    46.     })
    48.     // 清空集合
    49.     s.Clear()
    50.     fmt.Println(s.Size())
    51. }

    执行后，输出结果为：

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

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

    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/frame/g"
    6.     "github.com/gogf/gf/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. [4 5 6 7]
    2. [1 2 3 4 5 6]

    1. Marshal

      执行后，输出结果：

      1.  {"Id":1,"Name":"john","Scores":[100,99,98]}

    2. Unmarshal

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

      执行后，输出结果：

    性能测试

    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