咔叽游戏

 找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 390|回复: 0

[Golang] Golang通脉之map详情

[复制链接]
  • TA的每日心情
    无聊
    2019-5-27 08:20
  • 签到天数: 4 天

    [LV.2]圆转纯熟

    发表于 2021-12-31 21:44:54 | 显示全部楼层 |阅读模式
    目录

      1、定义2、基本使用3、判断键是否存在4、map的遍历5、delete()函数删除map元素6、指定顺序遍历map7、map类型的切片8、value为切片类型的map9、map是引用类型

    Go语言中提供的映射关系容器为map,其内部使用散列表(hash)实现。
    map 是一种无序的键值对的集合。map 最重要的一点是通过 key 来快速检索数据,key 类似于索引,指向数据的值 map 是一种集合,所以可以像迭代数组和切片那样迭代它。不过,map 是无序的,无法决定它的返回顺序,这是因为 map 是使用 hash 表来实现的,Go语言中的map是引用类型,必须初始化才能使用。
    使用map过程中需要注意的几点:
      map是无序的,每次打印出来的map都会不一样,它不能通过index获取,而必须通过key获取map的长度是不固定的,也就是和slice一样,也是一种引用类型内置的len函数同样适用于map,返回map拥有的key的数量map的key可以是所有可比较的类型,如布尔型、整数型、浮点型、复杂型、字符串型……也可以键。

    1、定义

    Go语言中 map的定义语法如下:
    map[KeyType]ValueType
    其中
      KeyType:表示键的类型。ValueType:表示键对应的值的类型。
    **map类型的变量默认初始值为nil,需要使用make()函数来分配内存 (声明并初始化) **。
    语法为:
    make(map[KeyType]ValueType, [cap])

    其中cap表示map的容量,该参数虽然不是必须的,但是我们应该在初始化map的时候就为其指定一个合适的容量。
    可以使用内建函数 make ,也可以使用 map 关键字来定义 Map:
    1. /* 声明变量,默认 map 是 nil */
    2. var mapVariable map[KeyType]ValueType
    3. /* 使用 make 函数 */
    4. mapVariable = make(map[keyType]ValueType)
    5. rating := map[string]float32 {"C":5, "Go":4.5, "Python":4.5, "C++":2 }
    复制代码
    如果不初始化 map,那么就会创建一个 nil map。nil map 不能用来存放键值对

    2、基本使用

    map中的数据都是成对出现的:
    1. func main() {
    2. scoreMap := make(map[string]int, 8)
    3. scoreMap["张三"] = 90
    4. scoreMap["小明"] = 100
    5. fmt.Println(scoreMap)
    6. fmt.Println(scoreMap["小明"])
    7. fmt.Printf("type of a:%T\n", scoreMap)
    8. }
    复制代码
    输出:
    map[小明:100 张三:90]
    100
    type of a:map[string]int

    map也支持在声明的时候填充元素,例如:
    1. func main() {
    2. userInfo := map[string]string{
    3.   "username": "张三",
    4.   "password": "123456",
    5. }
    6. fmt.Println(userInfo) //
    7. }
    复制代码
    3、判断键是否存在

    Go语言中有个判断map中键是否存在的特殊写法,格式如下:
    1. value, ok := map[key]
    2. func main() {
    3. /* 创建集合 */
    4.    countryCapitalMap := make(map[string]string)
    5.    /* map 插入 key-value 对,各个国家对应的首都 */
    6.    countryCapitalMap["France"] = "Paris"
    7.    countryCapitalMap["Italy"] = "Rome"
    8.    countryCapitalMap["Japan"] = "Tokyo"
    9.    countryCapitalMap["India"] = "New Delhi"
    10. // 如果key存在ok为true,v为对应的值;不存在ok为false,v为值类型的零值
    11. v, ok := countryCapitalMap["United States"]
    12. if ok {
    13.   fmt.Println("Capital of United States is", captial)  
    14.    }else {
    15.       fmt.Println("Capital of United States is not present")
    16.    }
    17. }
    复制代码
    4、map的遍历

    Go语言中使用for range遍历map。
    1. func main() {
    2. countryCapitalMap := make(map[string]string)
    3.    /* map 插入 key-value 对,各个国家对应的首都 */
    4.    countryCapitalMap["France"] = "Paris"
    5.    countryCapitalMap["Italy"] = "Rome"
    6.    countryCapitalMap["Japan"] = "Tokyo"
    7.    countryCapitalMap["India"] = "New Delhi"
    8. for k, v := range countryCapitalMap {
    9.   fmt.Println(k, v)
    10. }
    11. }
    复制代码
    只想遍历key的时候,可以按下面的写法:
    1. func main() {
    2. countryCapitalMap := make(map[string]string)
    3.    /* map 插入 key-value 对,各个国家对应的首都 */
    4.    countryCapitalMap["France"] = "Paris"
    5.    countryCapitalMap["Italy"] = "Rome"
    6.    countryCapitalMap["Japan"] = "Tokyo"
    7.    countryCapitalMap["India"] = "New Delhi"
    8. for k := range countryCapitalMap {
    9.   fmt.Println(k)
    10. }
    11. }
    复制代码
    注意: 遍历map时的元素顺序与添加键值对的顺序无关。

    5、delete()函数删除map元素

    使用delete()内建函数从map中删除一组键值对,删除函数不返回任何值,delete()函数的格式如下:
    delete(map, key)
    其中,
      map:表示要删除键值对的mapkey:表示要删除的键值对的键
    1. func main(){
    2. countryCapitalMap := make(map[string]string)
    3.    /* map 插入 key-value 对,各个国家对应的首都 */
    4.    countryCapitalMap["France"] = "Paris"
    5.    countryCapitalMap["Italy"] = "Rome"
    6.    countryCapitalMap["Japan"] = "Tokyo"
    7.    countryCapitalMap["India"] = "New Delhi"
    8. delete(countryCapitalMap, "France")//将"France":"Paris"从map中删除
    9. for k,v := range scoreMap{
    10.   fmt.Println(k, v)
    11. }
    12. }
    复制代码
    6、指定顺序遍历map
    1. func main() {
    2. rand.Seed(time.Now().UnixNano()) //初始化随机数种子
    3. var scoreMap = make(map[string]int, 200)
    4. for i := 0; i < 100; i++ {
    5.   key := fmt.Sprintf("stu%02d", i) //生成stu开头的字符串
    6.   value := rand.Intn(100)          //生成0~99的随机整数
    7.   scoreMap[key] = value
    8. }
    9. //取出map中的所有key存入切片keys
    10. var keys = make([]string, 0, 200)
    11. for key := range scoreMap {
    12.   keys = append(keys, key)
    13. }
    14. //对切片进行排序
    15. sort.Strings(keys)
    16. //按照排序后的key遍历map
    17. for _, key := range keys {
    18.   fmt.Println(key, scoreMap[key])
    19. }
    20. }
    复制代码
    7、map类型的切片

    下面的代码切片中的元素为map类型时的操作:
    1. func main() {
    2. var mapSlice = make([]map[string]string, 3)
    3. for index, value := range mapSlice {
    4.   fmt.Printf("index:%d value:%v\n", index, value)
    5. }
    6. fmt.Println("after init")
    7. // 对切片中的map元素进行初始化
    8. mapSlice[0] = make(map[string]string, 10)
    9. mapSlice[0]["username"] = "张三"
    10. mapSlice[0]["password"] = "123456"
    11. mapSlice[0]["address"] = "深圳"
    12. for index, value := range mapSlice {
    13.   fmt.Printf("index:%d value:%v\n", index, value)
    14. }
    15. }
    复制代码
    8、value为切片类型的map

    下面的代码演示了map中值为切片类型的操作:
    1. func main() {
    2. var sliceMap = make(map[string][]string, 3)
    3. fmt.Println(sliceMap)
    4. fmt.Println("after init")
    5. key := "中国"
    6. value, ok := sliceMap[key]
    7. if !ok {
    8.   value = make([]string, 0, 2)
    9. }
    10. value = append(value, "北京", "上海")
    11. sliceMap[key] = value
    12. fmt.Println(sliceMap)
    13. }
    复制代码
    9、map是引用类型

    与切片相似,map是引用类型。当将map分配给一个新变量时,它们都指向相同的内部数据结构。因此,一个的变化会反映另一个:
    1. func main() {  
    2.     personSalary := map[string]int{
    3.         "steve": 12000,
    4.         "jamie": 15000,
    5.     }
    6.     personSalary["mike"] = 9000
    7.     fmt.Println("Original person salary", personSalary)
    8.     newPersonSalary := personSalary
    9.     newPersonSalary["mike"] = 18000
    10.     fmt.Println("Person salary changed", personSalary)
    11. }
    复制代码
    运行结果:
    Original person salary map[steve:12000 jamie:15000 mike:9000]  
    Person salary changed map[steve:12000 jamie:15000 mike:18000]

    map不能使用操作符进行比较。只能用来检查map是否为空。否则会报错:invalid operation: map1 == map2 (map can only be comparedto nil)
    到此这篇关于Golang通脉之map详情的文章就介绍到这了,更多相关Golang map内容请搜索咔叽论坛以前的文章或继续浏览下面的相关文章希望大家以后多多支持咔叽论坛!

    原文地址:https://www.jb51.net/article/226057.htm

    QQ|免责声明|小黑屋|手机版|Archiver|咔叽游戏

    GMT+8, 2024-3-28 18:32

    Powered by Discuz! X3.4

    © 2001-2023 Discuz! Team.

    快速回复 返回顶部 返回列表