8、golang-map

2022-05-09 14:01:43 作者：互联网

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

map是一种无序的基于key-value的数据结构，Go语言中的map是引用类型，必须初始化才能使用。map 这种数据结构在其他编程语言中也称为字典（Python）、hash 和 HashTable 等。

Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。

1. map的声明

map 是引用类型，可以使用如下方式声明：

/* 声明变量，默认 map 是 nil */
var mapname map[keytype]valuetype

/* 使用 make 函数 */
mapname := make(map[keytype]valuetype, [cap])

其中：

mapname 为 map 的变量名。
keytype 为键类型。
valuetype 是键对应的值类型。
cap表示map的容量，非必需，但是我们应该在初始化map的时候就为其指定一个合适的容量。

提示：[keytype] 和 valuetype 之间允许有空格。

在声明的时候不需要知道 map 的长度，因为 map 是可以动态增长的。

如果不初始化 map，那么就会创建一个 nil map。nil map 不能用来存放键值对。

使用函数 len() 可以获取 map 中 pair 的数目。

和数组不同，map 可以根据新增的 key-value 动态的伸缩，因此它不存在固定长度或者最大限制。当 map 增长到容量上限的时候，如果再增加新的 key-value，map 的大小会自动加 1，所以出于性能的考虑，对于大的 map 或者会快速扩张的 map，即使只是大概知道容量，也最好先标明。

2. map的基本使用

实例一：

初始化、赋值、遍历、判断元素是否存在

package main

import "fmt"

func main() {
    var countryCapitalMap map[string]string /*创建集合 */
    countryCapitalMap = make(map[string]string)

    /* map插入key - value对,各个国家对应的首都 */
    countryCapitalMap [ "France" ] = "巴黎"
    countryCapitalMap [ "Italy" ] = "罗马"
    countryCapitalMap [ "Japan" ] = "东京"
    countryCapitalMap [ "India " ] = "新德里"

    /*使用键输出地图值 */
    for country := range countryCapitalMap {
        fmt.Println(country, "首都是", countryCapitalMap [country])
    }

    /*查看元素在集合中是否存在 */
    capital, ok := countryCapitalMap [ "American" ] /*如果确定是真实的,则存在,否则不存在 */
    /*fmt.Println(capital) */
    /*fmt.Println(ok) */
    if (ok) {
        fmt.Println("American 的首都是", capital)
    } else {
        fmt.Println("American 的首都不存在")
    }
}

/*
France 首都是 巴黎
Italy 首都是 罗马
Japan 首都是 东京
India  首都是 新德里
American 的首都不存在
*/

3. 判断某个键是否存在

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

实例二：

初始化、赋值、删除、初始化时赋值、遍历、key是否存在

func mymap1() {
	// 声明一个map
	scoreMap := make(map[string]int, 8)
	scoreMap["小明"] = 8
	scoreMap["小红"] = 10
	fmt.Println(scoreMap)
	fmt.Println(scoreMap["小明"])
	delete(scoreMap, "小明") //将小明:100从map中删除
	fmt.Printf("type of scoreMap:%T \n", scoreMap)
	//map[小明:8 小红:10]
	//8
	//type of scoreMap:map[string]int

	// 声明一个map 并 赋值
	userinfo := map[string]string{
		"name": "Maggie",
		"age":  "18",
	}
	fmt.Println(userinfo)

	//map[age:18 name:Maggie]

	// 如果key存在ok为true,v为对应的值；不存在ok为false,v为值类型的零值
	v, ok := scoreMap["小明"]
	fmt.Println(v, ok) // 8 true
	if ok {
		fmt.Println(v)
	} else {
		fmt.Println("查无此人")
	}
    	// 遍历
	for k, v := range scoreMap {
		println(k, v)
	}
	//小明 8
	//小红 10

	for k := range scoreMap {
		println(k, scoreMap[k])
	}
	//小明 8
	//小红 10

}

4. 遍历

func main() {
	scoreMap := make(map[string]int)
	scoreMap["张三"] = 90
	scoreMap["小明"] = 100
	scoreMap["娜扎"] = 60
	for k, v := range scoreMap {
		fmt.Println(k, v)
	}
}

// 但我们只想遍历key的时候，可以按下面的写法：
func main() {
	scoreMap := make(map[string]int)
	scoreMap["张三"] = 90
	scoreMap["小明"] = 100
	scoreMap["娜扎"] = 60
	for k := range scoreMap {
		fmt.Println(k)
	}
}

5. 进阶操作

1）按照指定顺序遍历map


func mymap2() {
	rand.Seed(time.Now().UnixNano()) //初始化随机数种子

	var scoreMap = make(map[string]int, 200)
	for i := 1; i < 200; i++ {
		key := fmt.Sprintf("stu%02d", i) //生成stu开头的字符串 fmt.Sprintf()有返回值
		value := rand.Intn(200)          //生成0~99的随机整数
		scoreMap[key] = value
	}

	//取出map中的所有key存入切片keys
	var keys = make([]string, 0, 200)
	for key := range scoreMap {
		keys = append(keys, key)
	}

	//对切片进行排序
	sort.Strings(keys)

	//按照排序后的key遍历map
	for _, key := range keys {
		fmt.Println(key, scoreMap[key])
	}
}

2）元素为map类型的切片

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")
	// 对切片中的map元素进行初始化
	mapSlice[0] = make(map[string]string, 10)
	mapSlice[0]["name"] = "小王子"
	mapSlice[0]["password"] = "123456"
	mapSlice[0]["address"] = "沙河"
	for index, value := range mapSlice {
		fmt.Printf("index:%d value:%v\n", index, value)
	}
}

3）值为切片类型的map

func mymap3() {
	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)

}

练习：

func mymap() {
	type Map map[string][]int
	m := make(Map)
	s := []int{1, 2}
	s = append(s, 3)
	fmt.Printf("%+v\n", s) // [1 2 3]
	m["q1mi"] = s
	s = append(s[:1], s[2:]...)
	fmt.Printf("%+v\n", s) // [1 3]
	fmt.Printf("%+v\n", m["q1mi"]) // [1 3 3] 还没看懂为啥
}

// 写一个程序，统计一个字符串中每个单词出现的次数。比如：”how do you do”中how=1 do=2 you=1。
func mymap4() {
	str1 := "how do you do"
	mylist := strings.Split(str1, " ")
	tmpmap := make(map[string]int)
	for _, key := range mylist {
		_, ok := tmpmap[key]
		if ok {
			tmpmap[key] += 1
		} else {
			tmpmap[key] = 1
		}
	}
	fmt.Println(tmpmap)
}

delete() 函数

delete() 函数用于删除集合的元素, 参数为 map 和其对应的 key。实例如下：

package main

import "fmt"

func main() {
        /* 创建map */
        countryCapitalMap := map[string]string{"France": "Paris", "Italy": "Rome", "Japan": "Tokyo", "India": "New delhi"}

        fmt.Println("原始地图")

        /* 打印地图 */
        for country := range countryCapitalMap {
                fmt.Println(country, "首都是", countryCapitalMap [ country ])
        }

        /*删除元素*/ delete(countryCapitalMap, "France")
        fmt.Println("法国条目被删除")

        fmt.Println("删除元素后地图")

        /*打印地图*/
        for country := range countryCapitalMap {
                fmt.Println(country, "首都是", countryCapitalMap [ country ])
        }
}
/*
原始地图
India 首都是 New delhi
France 首都是 Paris
Italy 首都是 Rome
Japan 首都是 Tokyo
法国条目被删除
删除元素后地图
Italy 首都是 Rome
Japan 首都是 Tokyo
India 首都是 New delhi
*/

参考链接：

https://www.runoob.com/go/go-map.html

https://www.liwenzhou.com/posts/Go/08_map/

http://c.biancheng.net/view/31.html

标签：map,string,fmt,golang,key,Println,scoreMap
来源： https://www.cnblogs.com/requal/p/16205080.html