Go沒有內(nèi)置的集合類型，但可以通過map[T]struct{}實(shí)現(xiàn)高效且類型安全的集合。 1. 使用map[T]struct{}實(shí)現(xiàn)類型安全的集合：定義泛型Set結(jié)構(gòu)體並提供Add、Remove、Contains、Size和Values方法；2. struct{}作為值類型因其零內(nèi)存開銷比bool更高效；3. 可直接使用map[string]struct{}實(shí)現(xiàn)簡單集合操作；4. 若需並發(fā)安全，可結(jié)合sync.RWMutex封裝；5. 注意僅comparable類型可用作鍵，且原生map操作非線程安全。該方式簡潔、高效且符合Go語言習(xí)慣。

In Go, there's no built-in set data structure, but you can easily implement one using a map with keys of the desired type and struct{} (or bool ) as the value. The most common and idiomatic way is to use map[T]struct{} because struct{} takes up zero bytes, making it memory-efficient.

Here's how you can implement a basic set in Go:

1. Using map[T]struct{} for a Type-Safe Set

 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]) Remove(value T) {
    delete(s.items, value)
}

func (s *Set[T]) Contains(value T) bool {
    _, exists := s.items[value]
    return exists
}

func (s *Set[T]) Size() int {
    return len(s.items)
}

func (s *Set[T]) Values() []T {
    values := make([]T, 0, len(s.items))
    for item := range s.items {
        values = append(values, item)
    }
    return values
}

Example Usage

 set := NewSet[string]()
set.Add("apple")
set.Add("banana")
set.Add("apple") // Duplicate, will be ignored

fmt.Println(set.Contains("apple")) // true
fmt.Println(set.Size()) // 2

set.Remove("apple")
fmt.Println(set.Contains("apple")) // false

Why struct{} instead of bool ?

• struct{} takes zero memory , so it's more efficient than bool (which takes 1 byte).
• You're only using the key to represent membership — the value is irrelevant.

Alternative: Simple Map-Based Set (Without Struct)

If you don't need a dedicated type, you can use a raw map:

 set := make(map[string]struct{})

// Add
set["hello"] = struct{}{}

// Check
if _, exists := set["hello"]; exists {
    // present
}

// Remove
delete(set, "hello")

Notes

• Go generics (introduced in 1.18) allow you to make the set reusable for any comparable type.
• Only comparable types can be keys in maps (so you can't use slices, maps, or functions in a set).
• This implementation is not thread-safe. For concurrent use, wrap it with a sync.RWMutex .

Thread-Safe Version (Optional)

 import "sync"

type ConcurrentSet[T comparable] struct {
    items map[T]struct{}
    mu sync.RWMutex
}

func (s *ConcurrentSet[T]) Add(value T) {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.items[value] = struct{}{}
}

func (s *ConcurrentSet[T]) Contains(value T) bool {
    s.mu.RLock()
    defer s.mu.RUnlock()
    _, exists := s.items[value]
    return exists
}

Basically, use map[T]struct{} with generics to make a clean, reusable, and efficient set. It's simple, fast, and idiomatic Go.

以上是您如何在GO中實(shí)現(xiàn)設(shè)定的數(shù)據(jù)結(jié)構(gòu)？的詳細(xì)內(nèi)容。更多資訊請(qǐng)關(guān)注PHP中文網(wǎng)其他相關(guān)文章！