Documentation
¶
Index ¶
- func Keys[K comparable, V any](m map[K]V) []K
- func KeysValues[K comparable, V any](m map[K]V) ([]K, []V)
- func Merge[K comparable, V any](ms ...map[K]V) map[K]V
- func MergeFunc[K comparable, V any](mergeFunc func(val1, val2 V) V, ms ...map[K]V) map[K]V
- func ToMap[K comparable, V any](keys []K, values []V) (m map[K]V, err error)
- func Values[K comparable, V any](m map[K]V) []V
- type HashMap
- func (m *HashMap[T, ValType]) Delete(key T) (ValType, bool)
- func (m *HashMap[T, ValType]) Get(key T) (ValType, bool)
- func (m *HashMap[T, ValType]) Iterate(cb func(key T, val ValType) bool)
- func (m *HashMap[T, ValType]) Keys() []T
- func (m *HashMap[T, ValType]) Len() int64
- func (m *HashMap[T, ValType]) Put(key T, val ValType) error
- func (m *HashMap[T, ValType]) Values() []ValType
- type Hashable
- type LinkedMap
- func (l *LinkedMap[K, V]) Delete(key K) (V, bool)
- func (l *LinkedMap[K, V]) Get(key K) (V, bool)
- func (l *LinkedMap[K, V]) Iterate(cb func(K, V) bool)
- func (l *LinkedMap[K, V]) Keys() []K
- func (l *LinkedMap[K, V]) Len() int64
- func (l *LinkedMap[K, V]) Put(key K, val V) error
- func (l *LinkedMap[K, V]) Values() []V
- type MultiMap
- func (m *MultiMap[K, V]) Delete(k K) ([]V, bool)
- func (m *MultiMap[K, V]) Get(k K) ([]V, bool)
- func (m *MultiMap[K, V]) Iterate(cb func(K, V) bool)
- func (m *MultiMap[K, V]) Keys() []K
- func (m *MultiMap[K, V]) Len() int64
- func (m *MultiMap[K, V]) Put(k K, v V) error
- func (m *MultiMap[K, V]) PutMany(k K, v ...V) error
- func (m *MultiMap[K, V]) Values() [][]V
- type TreeMap
- func (treeMap *TreeMap[T, V]) Delete(k T) (V, bool)
- func (treeMap *TreeMap[K, V]) Get(key K) (V, bool)
- func (treeMap *TreeMap[K, V]) Iterate(cb func(key K, value V) bool)
- func (treeMap *TreeMap[T, V]) Keys() []T
- func (treeMap *TreeMap[T, V]) Len() int64
- func (treeMap *TreeMap[K, V]) Put(key K, value V) error
- func (treeMap *TreeMap[T, V]) Values() []V
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Keys ¶
func Keys[K comparable, V any](m map[K]V) []K
Keys 返回 map 里面的所有的 key。 需要注意：这些 key 的顺序是随机。
func KeysValues ¶
func KeysValues[K comparable, V any](m map[K]V) ([]K, []V)
KeysValues 返回 map 里面的所有的 key,value。 需要注意：这些 (key,value) 的顺序是随机,相对顺序是一致的。
func Merge ¶ added in v0.0.10
func Merge[K comparable, V any](ms ...map[K]V) map[K]V
Merge 如果同一个键对应多个值，则会使用最后一个值
Example ¶
package main
import (
"fmt"
"github.com/ecodeclub/ekit/mapx"
)
func main() {
m1 := map[int]int{1: 1, 2: 2, 3: 3}
m2 := map[int]int{4: 4, 5: 5, 6: 6}
got := mapx.Merge(m1, m2)
fmt.Println(got)
m3 := map[int]int{1: 1, 2: 2, 3: 3}
m4 := map[int]int{1: 5, 2: 6, 3: 7}
got = mapx.Merge(m3, m4)
fmt.Println(got)
var m map[int]int
got = mapx.Merge(m)
fmt.Println(got == nil) // 不会返回 nil map
}
Output: map[1:1 2:2 3:3 4:4 5:5 6:6] map[1:5 2:6 3:7] false
func MergeFunc ¶ added in v0.0.10
func MergeFunc[K comparable, V any](mergeFunc func(val1, val2 V) V, ms ...map[K]V) map[K]V
MergeFunc 如果同一个键对应多个值，需要指定合并方式
Example ¶
package main
import (
"fmt"
"github.com/ecodeclub/ekit/mapx"
)
func main() {
m1 := map[int]int{1: 1, 2: 2, 3: 3}
m2 := map[int]int{1: 2, 2: 3, 3: 4}
got := mapx.MergeFunc(func(val1, val2 int) int {
return val1 + val2
}, m1, m2)
fmt.Println(got)
}
Output: map[1:3 2:5 3:7]
func ToMap ¶ added in v0.0.9
func ToMap[K comparable, V any](keys []K, values []V) (m map[K]V, err error)
ToMap 将会返回一个map[K]V 请保证传入的 keys 与 values 长度相同，长度均为n 长度不相同或者 keys 或者 values 为nil则会抛出异常 返回的 m map[K]V 保证对于所有的 0 <= i < n m[keys[i]] = values[i]
注意： 如果传入的数组中存在 0 <= i < j < n使得 keys[i] == keys[j] 则在返回的 m 中 m[keys[i]] = values[j] 如果keys和values的长度为0，则会返回一个空map
func Values ¶
func Values[K comparable, V any](m map[K]V) []V
Values 返回 map 里面的所有的 value。 需要注意：这些 value 的顺序是随机。
Types ¶
type HashMap ¶
func NewHashMap ¶
Example ¶
package main
import (
"fmt"
"github.com/ecodeclub/ekit/mapx"
)
func main() {
m := mapx.NewHashMap[MockKey, int](10)
_ = m.Put(MockKey{}, 123)
val, _ := m.Get(MockKey{})
fmt.Println(val)
}
type MockKey struct {
values []int
}
func (m MockKey) Code() uint64 {
res := 3
for _, v := range m.values {
res += v * 7
}
return uint64(res)
}
func (m MockKey) Equals(key any) bool {
k, ok := key.(MockKey)
if !ok {
return false
}
if len(k.values) != len(m.values) {
return false
}
if k.values == nil && m.values != nil {
return false
}
if k.values != nil && m.values == nil {
return false
}
for i, v := range m.values {
if v != k.values[i] {
return false
}
}
return true
}
Output: 123
func (*HashMap[T, ValType]) Iterate ¶ added in v0.0.10
Iterate 随机顺序遍历，并对每个键值对执行cb(k, v) 如果cb的返回值为 true 则继续遍历，否则遍历结束
Example ¶
package main
import (
"fmt"
"hash/crc32"
"sort"
)
type testStringData struct {
data string
}
func (ts testStringData) Code() uint64 {
return uint64(crc32.ChecksumIEEE([]byte(ts.data)))
}
func (ts testStringData) Equals(other any) bool {
otherv, ok := other.(testStringData)
if !ok {
return false
}
return ts.data == otherv.data
}
func main() {
hashMap := NewHashMap[testStringData, int](0)
strArr := make([]string, 0)
_ = hashMap.Put(testStringData{data: "hello"}, 1)
_ = hashMap.Put(testStringData{data: "world"}, 2)
_ = hashMap.Put(testStringData{data: "ekit"}, 3)
hashMap.Iterate(
func(key testStringData, val int) bool {
strArr = append(strArr, key.data)
return true
})
sort.Strings(strArr)
for _, s := range strArr {
fmt.Println(s)
}
}
Output: ekit hello world
type LinkedMap ¶ added in v0.0.8
func NewLinkedHashMap ¶ added in v0.0.8
func NewLinkedTreeMap ¶ added in v0.0.8
func (*LinkedMap[K, V]) Iterate ¶ added in v0.0.10
Iterate 按照随机顺序遍历, 并对每个键值对执行cb(k, v) 如果cb的返回值为 true 则继续遍历，否则遍历结束
Example ¶
linkedMap := NewLinkedHashMap[testStringData, int](0)
strArr := make([]string, 0)
_ = linkedMap.Put(testStringData{data: "hello"}, 1)
_ = linkedMap.Put(testStringData{data: "world"}, 2)
_ = linkedMap.Put(testStringData{data: "ekit"}, 3)
linkedMap.Iterate(
func(key testStringData, val int) bool {
strArr = append(strArr, key.data)
return true
})
sort.Strings(strArr)
for _, s := range strArr {
fmt.Println(s)
}
Output: ekit hello world
type MultiMap ¶ added in v0.0.8
MultiMap 多映射的 Map 它可以将一个键映射到多个值上
func NewMultiBuiltinMap ¶ added in v0.0.8
func NewMultiBuiltinMap[K comparable, V any](size int) *MultiMap[K, V]
func NewMultiHashMap ¶ added in v0.0.8
NewMultiHashMap 创建一个基于 HashMap 的 MultiMap
func NewMultiTreeMap ¶ added in v0.0.8
NewMultiTreeMap 创建一个基于 TreeMap 的 MultiMap 注意： - comparator 不能为 nil
func (*MultiMap[K, V]) Get ¶ added in v0.0.8
Get 从 MultiMap 中获取已有键 k 的值 如果键 k 不存在，则返回的 bool 值为 false 返回的切片是一个副本，你对该切片的修改不会影响原本的数据。
func (*MultiMap[K, V]) Iterate ¶ added in v0.0.10
Iterate 遍历整个map, 对每个键值对执行cb(k, v), 如果cb的返回值为 true 则继续遍历，否则遍历结束 具体遍历顺序取决于MultiMap包装的mapi的实现
Example ¶
multiMap := NewMultiHashMap[testStringData, int](0)
arr := make([]pair.Pair[string, int], 0)
_ = multiMap.Put(testStringData{data: "hello"}, 1)
_ = multiMap.Put(testStringData{data: "world"}, 2)
_ = multiMap.Put(testStringData{data: "world"}, 3)
_ = multiMap.Put(testStringData{data: "world"}, 4)
_ = multiMap.Put(testStringData{data: "ekit"}, 3)
multiMap.Iterate(
func(key testStringData, val int) bool {
arr = append(arr, pair.NewPair(key.data, val))
return true
})
sort.Slice(arr, func(i, j int) bool {
if arr[i].Key == arr[j].Key {
return arr[i].Value < arr[j].Value
}
return arr[i].Key < arr[j].Key
})
for _, pa := range arr {
fmt.Println(pa.Key, pa.Value)
}
Output: ekit 3 hello 1 world 2 world 3 world 4
func (*MultiMap[K, V]) Keys ¶ added in v0.0.8
func (m *MultiMap[K, V]) Keys() []K
Keys 返回 MultiMap 所有的键
type TreeMap ¶
TreeMap 是基于红黑树实现的Map
func NewTreeMap ¶
NewTreeMap TreeMap构造方法,创建一个的TreeMap 需注意比较器compare不能为nil
Example ¶
package main
import (
"fmt"
"github.com/ecodeclub/ekit"
"github.com/ecodeclub/ekit/mapx"
)
func main() {
m, _ := mapx.NewTreeMap[int, int](ekit.ComparatorRealNumber[int])
_ = m.Put(1, 11)
val, _ := m.Get(1)
fmt.Println(val)
}
Output: 11
func NewTreeMapWithMap ¶
func NewTreeMapWithMap[K comparable, V any](compare ekit.Comparator[K], m map[K]V) (*TreeMap[K, V], error)
NewTreeMapWithMap TreeMap构造方法 支持通过传入的map构造生成TreeMap
func (*TreeMap[K, V]) Iterate ¶ added in v0.0.10
Iterate 按照key的顺序遍历并执行cb，如果cb返回值为false则结束遍历，否则继续遍历
Example ¶
package main
import (
"fmt"
"github.com/ecodeclub/ekit"
"github.com/ecodeclub/ekit/mapx"
)
func main() {
m, _ := mapx.NewTreeMap[int, int](ekit.ComparatorRealNumber[int])
_ = m.Put(1, 11)
_ = m.Put(-1, 12)
_ = m.Put(100, 13)
_ = m.Put(-100, 14)
_ = m.Put(-101, 15)
m.Iterate(func(key, value int) bool {
if key > 1 {
return false
}
fmt.Println(key, value)
return true
})
}
Output: -101 15 -100 14 -1 12 1 11
func (*TreeMap[T, V]) Keys ¶ added in v0.0.8
func (treeMap *TreeMap[T, V]) Keys() []T
Keys 返回了全部的键 目前我们是按照中序遍历来返回的数据，但是你不能依赖于这个特性
Source Files
Click to show internal directories.
Click to hide internal directories.