详解Go语言中如何高效地处理集合

package main

import (
	"fmt"
)

func removeDuplicates(input []int) []int {
	unique := make([]int, 0, len(input))
	seen := make(map[int]struct{})
	for _, value := range input {
		if _, ok := seen[value]; !ok {
			unique = append(unique, value)
			seen[value] = struct{}{}
		}
	}
	return unique
}

func main() {
	input := []int{1, 2, 3, 3, 4, 5, 5, 6}
	unique := removeDuplicates(input)
	fmt.Println("Unique elements:", unique)
}

package main

import (
	"fmt"
	"strings"
)

func countWords(text string) map[string]int {
	wordCount := make(map[string]int)
	words := strings.Fields(text)
	for _, word := range words {
		wordCount[word]++
	}
	return wordCount
}

func main() {
	text := "go is awesome go is fast"
	count := countWords(text)
	fmt.Println("Word Count:", count)
}

package main

import (
	"fmt"
)

type IntSet struct {
	set map[int]struct{}
}

// 创建一个新的 IntSet 集合
func NewIntSet() *IntSet {
	return &IntSet{set: make(map[int]struct{})}
}

// 向集合中添加元素
func (s *IntSet) Add(value int) {
	s.set[value] = struct{}{}
}

// 判断集合是否包含某个元素
func (s *IntSet) Contains(value int) bool {
	_, exists := s.set[value]
	return exists
}

// 移除集合中的元素
func (s *IntSet) Remove(value int) {
	delete(s.set, value)
}

// 打印集合
func (s *IntSet) Print() {
	for value := range s.set {
		fmt.Println(value)
	}
}

func main() {
	set := NewIntSet()
	set.Add(1)
	set.Add(2)
	set.Add(3)

	fmt.Println("Contains 2:", set.Contains(2)) // true
	set.Remove(2)
	fmt.Println("Contains 2:", set.Contains(2)) // false

	fmt.Println("Set contents:")
	set.Print() // 1 3
}

package main

import (
	"fmt"
)

// 泛型集合
type Set[T comparable] struct {
	items map[T]struct{}
}

// 创建一个新的集合
func NewSet[T comparable]() *Set[T] {
	return &Set[T]{items: make(map[T]struct{})}
}

// 向集合中添加元素
func (s *Set[T]) Add(value T) {
	s.items[value] = struct{}{}
}

// 判断集合是否包含某个元素
func (s *Set[T]) Contains(value T) bool {
	_, exists := s.items[value]
	return exists
}

// 打印集合
func (s *Set[T]) Print() {
	for value := range s.items {
		fmt.Println(value)
	}
}

func main() {
	// 整型集合
	intSet := NewSet[int]()
	intSet.Add(1)
	intSet.Add(2)
	intSet.Add(3)
	fmt.Println("Integer Set:")
	intSet.Print()

	// 字符串集合
	strSet := NewSet[string]()
	strSet.Add("apple")
	strSet.Add("banana")
	strSet.Add("cherry")
	fmt.Println("String Set:")
	strSet.Print()
}

package main

import (
	"fmt"
	"sync"
)

type ConcurrentSet struct {
	set  map[int]struct{}
	lock sync.RWMutex
}

func NewConcurrentSet() *ConcurrentSet {
	return &ConcurrentSet{
		set: make(map[int]struct{}),
	}
}

func (s *ConcurrentSet) Add(value int) {
	s.lock.Lock()
	defer s.lock.Unlock()
	s.set[value] = struct{}{}
}

func (s *ConcurrentSet) Contains(value int) bool {
	s.lock.RLock()
	defer s.lock.RUnlock()
	_, exists := s.set[value]
	return exists
}

func (s *ConcurrentSet) Remove(value int) {
	s.lock.Lock()
	defer s.lock.Unlock()
	delete(s.set, value)
}

func main() {
	cs := NewConcurrentSet()

	// 使用 goroutine 并发访问集合
	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			cs.Add(i)
			fmt.Println("Added", i)
		}(i)
	}
	wg.Wait()

	// 查看集合内容
	for i := 0; i < 10; i++ {
		if cs.Contains(i) {
			fmt.Println("Contains", i)
		}
	}
}