【Golang】map-学习笔记

最新推荐文章于 2024-08-10 18:08:33 发布

超长待机。

最新推荐文章于 2024-08-10 18:08:33 发布

阅读量595

点赞数

分类专栏： Golang学习笔记文章标签： golang 学习

本文链接：https://blog.csdn.net/qq_45070951/article/details/126052659

版权

Golang学习笔记专栏收录该内容

12 篇文章 1 订阅

订阅专栏

1.map的基本介绍

map是key-value数据结构，又称为字段或者关联数组。类似其它编程语言的集合，在编程中是经常使用到。

2.map的声明

2.1 基本语法

var map变量名map[keytype]valuetype

key可以是什么类型
golang 中的 map，的 key 可以是很多种类型，比如 bool，数字，string，指针， channel，还包含前面几个类型的接口，结构体，数组
通常key为int 、 string
注意： slice， map还有function不可以，因为这几个没法用 == 来判断
valuetype可以是什么类型
valuetype的类型和key基本一样
通常为：数字(整数，浮点数)，string，map，struct

2.2 map声明的举例

// map声明的举例
var a map[string]string
var a map[string]int
var a map[int]string
var a map[string]map[string]string

注：声明是不会分配内存的，初始化需要make ，分配内存后才能赋值和使用。
举个栗子

package main
import "fmt"
func main(){
    // map的声明和注意事项
    var a map[string]string
    // 在使用map前，需要先make,make的作用就是给map分配数据空间
    a = make(map[string]string,10)
    a["no1"] = "宋江"
    a["no2"] = "吴用"
    a["no1"] = "武松"
    a["no3"] = "吴用"
    fmt.Println(a)
}

运行结果
map声明
注：
(1) map在使用前一定要make
(2）map的 key是不能重复，如果重复了，则以最后这个key-value为准
(3）map的 value是可以相同的
(4）map的 key-value是无序
(5）make内置函数数目

3.map的使用

方式一

package main
import "fmt"
func main(){
    // map的声明和注意事项
    var a map[string]string
    // 在使用map前，需要先make,make的作用就是给map分配数据空间
    a = make(map[string]string,10)
    a["no1"] = "宋江"
    a["no2"] = "吴用"
    a["no1"] = "武松"
    a["no3"] = "吴用"
    fmt.Println(a)
}

运行结果

方式二

package main
import "fmt"
func main(){
    cities := make(map[string]string)
    cities["no1"]  = "北京"
    cities["no2"] = "天津"
    cities["no3"] = "上海"
    fmt.Println(cities)
}

运行结果

方式三

package main
import "fmt"
func main(){
    heroes := map[string]string{
        "hero1" : "宋江",
        "hero2" : "卢俊义",
        "hero3" : "吴用",
    }
    heroes["hero4"] = "林冲"
    fmt.Println("heroes=", heroes)
}

运行结果

4.map的增删改查操作

map增加和更新
map[“key”] = value //如果key还没有，就是增加，如果key存在就是修改。

package main
import "fmt"
func main(){
    cities := make(map[string]string)
    cities["no1"]  = "北京"
    cities["no2"] = "天津"
    cities["no3"] = "上海"
    fmt.Println(cities)
    // 因为no3这个key已经存在，因此下面这句话就是修改
    cities["no3"] = "上海~"
    fmt.Println(cities)
}

运行结果

map删除
说明：delete(map，“key”) ，delete是一个内置函数，如果key存在，就删除该key-value，如果 key不存在，不操作，但是也不会报错。
delete函数
举个栗子

package main
import "fmt"
func main(){
    cities := make(map[string]string)
    cities["no1"]  = "北京"
    cities["no2"] = "天津"
    cities["no3"] = "上海"
    fmt.Println(cities)
    delete(cities, "no1")
    fmt.Println(cities)
    // 当delete指定的key不存在，删除不会操作，也不会报错
    delete(cities, "no4")
fmt.Println(cities)
}

运行结果

注：
如果我们要删除map的所有key ，没有一个专门的方法一次删除，可以遍历一下key，
逐个删除。
或者map = make(…)，make一个新的，让原来的成为垃圾，被gc回收。

package main
import "fmt"
func main(){
    cities := make(map[string]string)
    cities["no1"] = "北京"
    cities["no2"] = "天津"
    cities["no3"] = "上海"
    fmt.Println(cities)
    // 当希望一次性删除所有的key
    // 1.遍历所有的key，如果逐一删除
    // 2.直接make一个新的空间
    cities = make(map[string]string)
    fmt.Println(cities)
}

运行结果

map查找
举个栗子

package main
import "fmt"
func main(){
    cities := make(map[string]string)
    cities["no1"] = "北京"
    cities["no2"] = "天津"
    cities["no3"] = "上海"
    // map的查找
    val, ok := cities["no2"]
    if ok{
        fmt.Printf("有no1 key 值为%v\n", val)
    }else{
        fmt.Printf("没有no1 key\n")
    }
}

运行结果

注：
如果heroes这个map中存在”nol”，那么findRes就会返回true，否则返回false

5.map遍历

举个栗子

package main
import(
    "fmt"
)
func main(){
    // 使用for-range遍历map
    cities := make(map[string]string)
    cities["no1"] = "北京"
    cities["no2"] = "天津"
    cities["no3"] = "上海"
    for k, v := range cities{
        fmt.Printf("k=%v v=%v\n", k, v)
    }
    // 使用for-range遍历一个结构比较复杂的map
studentMap := make(map[string]map[string]string)

    studentMap["stu01"] = make(map[string]string, 3)
    studentMap["stu01"]["name"] = "tom"
    studentMap["stu01"]["sex"] = "男"
studentMap["stu01"]["address"] = "北京长安街~"

    studentMap["stu02"] = make(map[string]string, 3)
    studentMap["stu02"]["name"] = "mary"
    studentMap["stu02"]["sex"] = "女"
studentMap["stu02"]["address"] = "上海黄浦江~"

    for k1, v1 := range studentMap{
        fmt.Println("k1=", k1)
        for k2, v2 := range v1{
            fmt.Printf("\t k2=%v v2=%v\n", k2, v2)  
        }
        fmt.Println()
    }
}

运行结果

map的长度
len函数
len测试

6.map切片

6.1基本介绍

切片的数据类型如果是map，则我们称为slice of map，map切片，这样使用则map个数就可以动态变化了。

6.2举个栗子

要求：使用一个map来记录monster 的信息 name和 age，也就是说一个monster对应一个map,并且妖怪的个数可以动态的增加=>map切片
代码

package main
import (
    "fmt"
)
func main(){
    //演示map切片的使用
    /*
    使用一个map来记录monster的信息 name和 age，
    也就是说一个monster对应一个map,并且妖怪的个数可以动态的增加=>map切片
    */
    //1.声明一个map切片
    var monsters []map[string]string
    monsters = make([]map[string]string, 2)
    // 2.增加第一个妖怪信息
    if monsters[0] == nil{
        monsters[0] = make(map[string]string, 2)
        monsters[0]["name"] = "牛魔王"
        monsters[0]["age"] = "500"
    }
    if monsters[1] == nil{
        monsters[1] = make(map[string]string, 2)
        monsters[1]["name"] = "玉兔精"
        monsters[1]["age"] = "300"
    }
    // 这里使用切片的append函数，可以动态的增加monster
    // 先定义monster信息
    newMonster := map[string]string{
        "name" : "新的妖怪~火云邪神",
        "age" : "200",
    }
    monsters = append(monsters, newMonster)
    fmt.Println(monsters)

}

运行结果

7.map排序

7.1基本介绍

（1）golang中没有一个专门的方法针对map的key进行排序
（2）golang 中的 map默认是无序的，注意也不是按照添加的顺序存放的，你每次遍历，得到的输出可能不一样
（3）golang中 map 的排序，是先将key进行排序，然后根据key值遍历输出即可

7.2举个栗子

package main
import (
    "fmt"
    "sort"
)
func main(){
    // map排序
    map1 := make(map[int]int, 10)
    map1[10] = 100
    map1[1] = 13
    map1[4] = 56
    map1[8] = 90
    fmt.Println(map1)
    // 如果按照map的key的顺序进行排序输出
    //1．先将map的key放入到切片中
    // 2．对切片排序
    //3．遍历切片,然后按照key来输出map的值
    var keys []int
    for k, _ := range map1{
        keys = append(keys, k)
    }
    // 排序
    sort.Ints(keys)
    fmt.Println(keys)

    for _, k := range keys{
        fmt.Printf("map1[%v]=%v\n", k, map1[k])
    }
}

运行结果

8.map 使用细节

（1）map是引用类型，遵守引用类型传递的机制，在一个函数接收map，修改后，会直接修改原来的map【举个栗子】

package main
import (
    "fmt"
)
func modify(map1 map[int]int){
    map1[10] = 100
}
func main()  {
    // map是引用类型，遵守引用类型传递的机制，在一个函数接收map
    // 修改后，会直接修改原来的map
    map1 := make(map[int]int)
    map1[10] = 80
    map1[1] = 13
    map1[4] = 56
    map1[8] = 90
    map1[20] = 3
    modify(map1)
    fmt.Println(map1)
}

运行结果

（2）map的容量达到后，再想 map增加元素，会自动扩容，并不会发生panic，也就是说map能动态的增长键值对(key-value)
（3）map的 value也经常使用struct类型，更适合管理复杂的数据(比前面value是一个map更好)，比如value为Struct结构体

package main
import(
    "fmt"
)
type Stu struct{
    name string 
    age int 
    address string
}
func main(){
    // map的value也经常使用struet类型,
    // 1/更适合管理复杂的数据(比前面value是一个map更好),
    //比如value为 student结构体
    //1.map的key为学生的学号,是唯一的
    //2.map的value为结构体,包含学生的名字,年龄,地址

    students := make(map[string]Stu, 10)
    stu1 := Stu{"tom", 18, "北京"}
    stu2 := Stu{"mary", 28, "上海"}
    students["no1"] = stu1
    students["no2"] = stu2
    fmt.Println(students)
    // 遍历各个学生信息
    for k, v := range students{
        fmt.Printf("学生编号是%v\n", k)
        fmt.Printf("学生姓名是%v\n", v.name)
        fmt.Printf("学生年龄是%v\n", v.age)
        fmt.Printf("学生地址是%v\n", v.address)
        fmt.Println()
    } 
}