Go语言-技巧set类实现

利用slice和map实现了个非线程安全的LinkedSet，map的value是元素的index。也支持排序。代码如下：

package collections

import (
	"encoding/json"
	"fmt"
	"sort"
)

// Set LinkedHashSet 支持数组排序
type Set struct {
	m       map[interface{}]int         //元素和索引映射
	list    []interface{}               //元素数组
	compare func(i, j interface{}) bool //排序函数
}

// NewSet 构造方法
func NewSet() *Set {
	s := new(Set)
	s.initEle()
	return s
}

// initEle 初始化数组元素
func (set *Set) initEle() {
	set.m = make(map[interface{}]int)
	set.list = make([]interface{}, 0)
}

// SortAble 设置排序依据
// compare--用于排序
func (set *Set) SortAble(compare func(i, j interface{}) bool) *Set {
	set.compare = compare
	return set
}

// Add 添加元素
func (set *Set) Add(keys ...interface{}) *Set {
	//set.Lock()
	//defer set.Unlock()
	for _, key := range keys {
		if _, ok := set.m[key]; !ok {
			set.list = append(set.list, key)
			set.m[key] = len(set.list) - 1
		}
	}
	return set
}

// Delete 删除元素
func (set *Set) Delete(keys ...interface{}) {
	//set.Lock()
	//defer set.Unlock()
	for _, key := range keys {
		if v, ok := set.m[key]; !ok {
			if len(set.list)-1 < v {
				set.list = append(set.list[0:v], set.list[v+1:]...)
			}
			delete(set.m, key)
		}
	}
}

// Get 获取元素
func (set *Set) Get(key interface{}) interface{} {
	//set.RLock()
	//defer set.RUnlock()
	if v, ok := set.m[key]; ok {
		return set.list[v]
	}
	return nil
}

// Contains 获取元素
func (set *Set) Contains(key interface{}) bool {
	//set.RLock()
	//defer set.RUnlock()
	_, ok := set.m[key]
	return ok
}

// IndexOf 获取元素下标
func (set *Set) IndexOf(key interface{}) int {
	//set.RLock()
	//defer set.RUnlock()
	if i, ok := set.m[key]; ok {
		return i
	}
	return -1
}

// Any 多个元素有人一个true 则为true
func (set *Set) Any(cond func(key interface{}) bool) bool {
	//set.RLock()
	//defer set.RUnlock()
	for _, key := range set.list {
		if cond(key) {
			return true
		}
	}
	return false
}

// Diff 查看俩个set不同的元素，返回新的set
func (set *Set) Diff(dest *Set) *Set {
	result := NewSet()
	set.Foreach(func(ele interface{}) {
		if dest == nil || dest.Size() == 0 || !dest.Contains(ele) {
			result.Add(ele)
		}
	})

	if dest != nil && dest.Size() > 0 {
		dest.Foreach(func(ele interface{}) {
			if !set.Contains(ele) {
				result.Add(ele)
			}
		})
	}
	return result
}

// Difference 取s和dest差集，返回新的set
func (set *Set) Difference(dest *Set) *Set {
	result := NewSet()
	set.Foreach(func(ele interface{}) {
		if dest == nil || dest.Size() == 0 || !dest.Contains(ele) {
			result.Add(ele)
		}
	})
	return result
}

// Union 取交集，返回新的set
func (set *Set) Union(dest *Set) *Set {
	result := NewSet()
	set.Foreach(func(ele interface{}) {
		if dest != nil && dest.Size() > 0 && dest.Contains(ele) {
			result.Add(ele)
		}
	})
	return result
}

// Size  返回set的size
func (set *Set) Size() int {
	//set.RLock()
	//defer set.RUnlock()
	return len(set.list)
}

// Elements 返回element列表
func (set *Set) Elements() []interface{} {
	//set.RLock()
	//defer set.RUnlock()
	return set.list
}

// SetIterateFunc 遍历的handler
type SetIterateFunc func(interface{})

// Foreach 遍历
func (set *Set) Foreach(foreach SetIterateFunc) {
	//set.RLock()
	//defer set.RUnlock()
	if len(set.list) == 0 {
		return
	}
	for _, item := range set.list {
		foreach(item)
	}
}

// Sort 排序
func (set *Set) Sort() {
	//set.Lock()
	//defer set.Unlock()
	sort.Sort(set)
}

func (set *Set) Swap(i, j int) {
	set.list[i], set.list[j] = set.list[j], set.list[i]
	set.m[set.list[i]] = i
	set.m[set.list[j]] = j
}
func (set *Set) Len() int { return len(set.list) }
func (set *Set) Less(i, j int) bool {
	if set.compare == nil {
		return false
	}
	return set.compare(set.list[i], set.list[j])
}

// SetIsEmpty 判断set是否为空
func SetIsEmpty(set *Set) bool {
	return set == nil || set.Size() == 0
}

// MarshalJSON 实现json.Marshaler接口
func (set *Set) MarshalJSON() ([]byte, error) {
	return json.Marshal(set.list)
}

// UnmarshalJSON 实现json.Unmarshaler接口
func (set *Set) UnmarshalJSON(b []byte) error {
	set.initEle()
	var ele []interface{}
	err := json.Unmarshal(b, &ele)
	if err != nil {
		return err
	}
	set.Add(ele...)
	return err
}

//////////////////////////////////////////
func (set Set) String() string {
	return fmt.Sprintf("%v", set.list)
}

排序方法的使用方法

s:=set.NewSet().Add(....).AddOrderBy(OrderByHandlerFunc(i,j interface{})bool{
	//排序逻辑
	return true
})
sort(s)