golang基础--map字典

map 类似python语言中的dict（字典类型），以key-value形式存储数据

Key必须是支持==或！=比较运算的类型，不可以是函数，map或slice
map查找比线性搜素快很多，但比使用索引访问数据的类型慢100倍

map使用make()函数创建，支持 :=赋值的简单写法

 //基本操作
func main() {
	var m map[int]string //定义一个map变量
	m = map[int]string{}		//第一种方式
	m = make(map[int]string)  //第二种方式：使用make
	m := make(map[int]string) //第三种方式make直接初始化
	m[1] = "ok"               //赋值一对key-value
	a := m[1]                 //获取一个key对应的value值
	delete(m, 1)              //删除map中的某一个key
            fmt.Println(m)
	fmt.Println(m)
	fmt.Println(a)
	fmt.Println(m)
}
/*output
map_init---->	map[]
map_add---->	map[1:ok]
map_get---->	ok
map_del---->	map[]
*/

嵌套map: 类似python中的嵌套字典，取值，赋值时需要层层递进，且每次赋值时需要对内层map执行make初始化。

示例代码

 package main
import "fmt"
 
func main() {
	var m map[int]map[int]string     //嵌套字典
	m = make(map[int]map[int]string) //初始化map--最外层
	m[1] = make(map[int]string)      //make初始化嵌套字典，第一个键对应的map类型
	m[1][1] = "ok"                   //key1_value1赋值
	b, ok := m[1][1]                 //使用多返回值，第二值返回值时bool类型，如果前一个有返回值，返回true,反之返回false
	fmt.Println(b, ok)
	fmt.Println(m)
	a, ok := m[2][1] //由于key2，对应的value2赋值前没有make初始化，所以，
	fmt.Println(a, ok)
	if !ok {
		m[2] = make(map[int]string)
	}
	m[2][1] = "Good"
	a, ok = m[2][1]
	fmt.Println(a, ok)
	fmt.Println(m)
}
 
/*输出
a, ok--->	ok true
m ---> 		map[1:map[1:ok]]
a, ok--->		 false
a, ok--->	Good true			//初始化后
*/

for 迭代操作，类似python，dict操作，for k,v in dic.

示例代码

 //for 迭代操作slice
package main
import "fmt"
 
func main() {
	sum := make([]map[int]string, 5) //初始化一个slice,元素是map类型
	for i := range sum {
		sum[i] = make(map[int]string, 1)
		sum[i][1] = "ok"
		fmt.Println(sum[i])
	}
	fmt.Println(sum)
}
 
/*输出
i=0--->		map[1:ok]
i=1--->		map[1:ok]
i=2--->		map[1:ok]
i=3--->		map[1:ok]
i=4--->		map[1:ok]
sum--->		[map[1:ok] map[1:ok] map[1:ok] map[1:ok] map[1:ok]]
*/

map，间接排序，通过slice，对key进行排序。

示例代码

 //间接排序,对key进行排序
package main
 
import "fmt"
import "sort" //排序包
 
func main() {
	m := map[int]string{1: "a", 2: "b", 3: "c", 4: "d"}    //这是一个map类型
	s := make([]int, len(m))                                        //这是一个slice类型
	i := 0
	for k := range m {
		s[i] = k
		i ++
	}
	sort.Ints(s)
	fmt.Println(s)
}
/*输出
[1 2 3 4]
*/

posted @ 2018-07-10 00:59 failymao 阅读(440) 评论(2) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

深度思维者

永远年轻，永远热泪盈眶

failymao

golang基础--map字典

常用链接

我的标签

随笔分类 (124)

随笔档案 (133)

文章分类 (9)

评论排行榜

推荐排行榜

最新评论

	//基本操作
	func main() {
	var m map[int]string //定义一个map变量
	m = map[int]string{} //第一种方式
	m = make(map[int]string) //第二种方式：使用make
	m := make(map[int]string) //第三种方式make直接初始化
	m[1] = "ok" //赋值一对key-value
	a := m[1] //获取一个key对应的value值
	delete(m, 1) //删除map中的某一个key
	fmt.Println(m)
	fmt.Println(m)
	fmt.Println(a)
	fmt.Println(m)
	}
	/*output
	map_init----> map[]
	map_add----> map[1:ok]
	map_get----> ok
	map_del----> map[]
	*/

	package main
	import "fmt"

	func main() {
	var m map[int]map[int]string //嵌套字典
	m = make(map[int]map[int]string) //初始化map--最外层
	m[1] = make(map[int]string) //make初始化嵌套字典，第一个键对应的map类型
	m[1][1] = "ok" //key1_value1赋值
	b, ok := m[1][1] //使用多返回值，第二值返回值时bool类型，如果前一个有返回值，返回true,反之返回false
	fmt.Println(b, ok)
	fmt.Println(m)
	a, ok := m[2][1] //由于key2，对应的value2赋值前没有make初始化，所以，
	fmt.Println(a, ok)
	if !ok {
	m[2] = make(map[int]string)
	}
	m[2][1] = "Good"
	a, ok = m[2][1]
	fmt.Println(a, ok)
	fmt.Println(m)
	}

	/*输出
	a, ok---> ok true
	m ---> map[1:map[1:ok]]
	a, ok---> false
	a, ok---> Good true //初始化后
	*/

	//for 迭代操作slice
	package main
	import "fmt"

	func main() {
	sum := make([]map[int]string, 5) //初始化一个slice,元素是map类型
	for i := range sum {
	sum[i] = make(map[int]string, 1)
	sum[i][1] = "ok"
	fmt.Println(sum[i])
	}
	fmt.Println(sum)
	}

	/*输出
	i=0---> map[1:ok]
	i=1---> map[1:ok]
	i=2---> map[1:ok]
	i=3---> map[1:ok]
	i=4---> map[1:ok]
	sum---> [map[1:ok] map[1:ok] map[1:ok] map[1:ok] map[1:ok]]
	*/

	//间接排序,对key进行排序
	package main

	import "fmt"
	import "sort" //排序包

	func main() {
	m := map[int]string{1: "a", 2: "b", 3: "c", 4: "d"} //这是一个map类型
	s := make([]int, len(m)) //这是一个slice类型
	i := 0
	for k := range m {
	s[i] = k
	i ++
	}
	sort.Ints(s)
	fmt.Println(s)
	}
	/*输出
	[1 2 3 4]
	*/