Go语言数据结构和算法-Dictionary(字典)

9/5/2018 Go算法

Go语言数据结构和算法-Dictionary(字典)Set(key,value) // 添加修改字典中的数据Delete(key) // 删除字典中keyHas(key) // 是否包含keyGet(key) // 根据key获取

# Go语言数据结构和算法-Dictionary(字典)

Set(key,value)      // 添加修改字典中的数据
Delete(key)         // 删除字典中key
Has(key)            // 是否包含key
Get(key)            // 根据key获取对应的value
Clear()             // 清空字典中的数据
Size()              // 获取字典的大小
Keys()              // 获取字典中的所有的key
Values()            // 获取字典中的所有的value
1
2
3
4
5
6
7
8

# 字典的数据结构

type Dictionary struct {
	element map[interface{}]interface{}
	lock    sync.RWMutex
}
1
2
3
4

# Set(key,value) 添加修改字典中的数据

func (d *Dictionary) Set(key interface{}, value interface{}) {
	d.lock.Lock()
	defer d.lock.Unlock()
	if d.element == nil {
		d.element = make(map[interface{}]interface{})
	}
	d.element[key] = value
}
1
2
3
4
5
6
7
8

# Delete(key) 删除字典中key

func (d *Dictionary) Delete(key interface{}) bool {
	d.lock.Lock()
	defer d.lock.Unlock()
	_, ok := d.element[key]
	if ok {
		delete(d.element, key)
	}
	return ok
}
1
2
3
4
5
6
7
8
9

# Has(key) 是否包含key

func (d *Dictionary) Has(key interface{}) bool {
	d.lock.Lock()
	defer d.lock.Unlock()
	_, ok := d.element[key]
	return ok
}
1
2
3
4
5
6

# Get(key) 根据key获取对应的value

func (d *Dictionary) Get(key interface{}) interface{} {
	d.lock.Lock()
	defer d.lock.Unlock()
	return d.element[key]
}
1
2
3
4
5

# Clear() 清空字典中的数据

func (d *Dictionary) Clear() {
	d.lock.Lock()
	defer d.lock.Unlock()
	d.element = make(map[interface{}]interface{})
}
1
2
3
4
5

# Size() 获取字典的大小

func (d *Dictionary) Size() int {
	d.lock.Lock()
	defer d.lock.Unlock()
	return len(d.element)
}
1
2
3
4
5

# Keys() 获取字典中的所有的key

func (d *Dictionary) Keys() []interface{} {
	d.lock.Lock()
	defer d.lock.Unlock()
	keys := make([]interface{}, 0)
	for key := range d.element {
		keys = append(keys, key)
	}
	return keys
}
1
2
3
4
5
6
7
8
9

# Values() 获取字典中的所有的value

func (d *Dictionary) Values() []interface{} {
	d.lock.Lock()
	defer d.lock.Unlock()
	values := make([]interface{}, 0)
	for key := range d.element {
		values = append(values, d.element[key])
	}
	return values
}
1
2
3
4
5
6
7
8
9

源码 (opens new window)