「Go」map

不积跬步，无以至千里；不积小流，无以成江海。

Go语言中提供的映射关系容器为 map，其内部使用散列表（hash）实现。

map是一种无序的基于key-value的数据结构，Go语言中的map是 引用类型，（ ）必须 初始化才能使用。

map定义

map的定义语法如下：

map[KeyType]ValueType

• KeyType:表示键的类型。
• ValueType:表示键对应的值的类型。

map类型的变量默认初始值为 nil，需要使用 make() 函数来分配内存。语法为：

make(map[KeyType]ValueType, [cap])

其中cap表示map的 容量，该参数虽然 不是必须 的，但是我们应该在初始化map的时候就为其指定一个合适的容量。

map 基本使用

map中的数据都是 成对

<code>
func
 
main
() {

	
scoreMap 
:= 
make
(map[string]int,
8
)

	scoreMap[
"张三"
] = 
100
	scoreMap[
"李四"
] = 
90

	fmt.
Println
(scoreMap)
	fmt.
Println
(scoreMap[
"李四"
])
    fmt.
Printf
(
"type of a:%T\n"
, scoreMap)
}
/<code>

输出：

<code>
map
[张三:
100
 李四:
90
]
90
type
 of a:
map
[
string 
]
int
/<code>

map也支持在声明的时候填充元素，例如：

<code>userInfo := 
map
[
string
]
string
{
		
"username"
:
"admin"
,
		
"password"
:
"123456"
,
	}

	fmt.Println(userInfo)
/<code>

判断某个键是否存在

Go语言中有个判断map中键是否存在的特殊写法，格式如下:

value, ok := map[key]

<code>
func
 
main
()
 {
	scoreMap := 
make
(
map
[
string
]
int
)
	scoreMap[
"张三" 
] = 
90
	scoreMap[
"李四"
] = 
100
	 
	v, ok := scoreMap[
"张三"
]
	
if
 ok {
		fmt.Println(v)
	} 
else
 {
		fmt.Println(
"查无此人"
)
	}
}
/<code>

map 遍历

Go语言中也是使用for range遍历map。

<code>
func
 
main
() {
	
scoreMap 
:= 
make
(map[string]int)
	scoreMap[
"张三"
] = 
90
	scoreMap[
"李四"
] = 
100
	scoreMap[
"赵四"
] = 
60
	for k, v := range scoreMap {
		fmt.
Println
(k, v)
	}
}
/<code>

输出

<code> 
赵四
 
80
张三
 
100
李四
 
90
/<code>

注意： 遍历map时的元素顺序与添加键值对的顺序无关。

使用delete()函数删除键值对

使用delete()内建函数从map中删除一组键值对，delete()函数的格式如下：

delete(map, key)

• map:表示要删除键值对的map
• key:表示要删除的键值对的键

<code>
func
 
main
(){
	
scoreMap 
:= 
make
(map[string]int)
	scoreMap[
"张三"
] = 
90
	scoreMap[
"李四" 
] = 
100
	scoreMap[
"赵四"
] = 
60
	
delete
(scoreMap, 
"赵四"
)//将赵四:
60
从map中删除
	for k,v := range scoreMap{
		fmt.
Println
(k, v)
	}
}
/<code>

按照指定顺序遍历map

<code>rand.Seed(time.Now().UnixNano())  

	
var
 scoreMap = 
make
(
map
[
string
]
int
, 
200
)

	
for
 i := 
0
; i 
100
; i++ {
		key := fmt.Sprintf(
"stu%02d"
, i)  
		value := rand.Intn(
100
)           
		scoreMap[key] = value
	}
	 
	
var
 keys = 
make
([]
string
, 
0
,  
200
)
	
for
 key := 
range
 scoreMap {
		keys = 
append
(keys, key)
	}
	 
	sort.Strings(keys)
	 
	
for
 _, key := 
range
 keys {
		fmt.Println(key, scoreMap[key])
	}
/<code>

元素为map类型的切片

<code>
func
 
main
()
 {
	
var
 mapSlice = 
make
([]
map
[
string
]
string
, 
3
)
	
for
 index, value := 
range
 mapSlice {
		fmt.Printf(
"index:%d value:%v\n"
, index, value)
	}
	fmt.Println(
"after init"
)
	 
	mapSlice[
0
] = 
make
(
map
[
string 
]
string
, 
10
)
	mapSlice[
0
][
"name"
] = 
"admin"
	mapSlice[
0
][
"password"
] = 
"123456"
	mapSlice[
0
][
"age"
] = 
"20"
	
for
 index, value := 
range
 mapSlice {
		fmt.Printf(
"index:%d value:%v\n"
, index, value)
	}
}
/<code>

输出：

<code>0 
map
[]
1 
map
[]
2 
map
[]
after
 
init
index 
:0
 
value
:map
[age:20 name:admin password:123456]
index
:1
 
value
:map
[]
index
:2
 
value
:map
[]

/<code>

值为切片类型的map

<code>
var
 sliceMap = 
make
(
map
[
string
][]
string
, 
3
)
	fmt.Println(sliceMap)
	fmt.Println(
"after init"
)
	key := 
"中国"
	value, ok := sliceMap[key]
	
if 
 !ok {
		value = 
make
([]
string
, 
0
, 
2
)
	}
	value = 
append
(value, 
"北京"
, 
"上海"
)
	sliceMap[key] = value
	fmt.Println(sliceMap)
/<code>

输出：

<code>
map
[]
after 
init
map
[中国:[北京 上海]]
/<code>

点关注 不迷路

如果你从本篇内容有收获，求 点赞，求 关注，求 转发 ，让更多的人学习到。

如果本文有任何错误，请批评指教，不胜感激

關鍵字: 点赞 index 初始值