golang中的map

map

注意map必须初始化才能使用,不然直接panic

m1 := make(map[int]string, 1)

m1[3] = "2222"
m1[1] = "2222"
m1[5] = "2222"
m1[7] = "2222"
m1[8] = "2222"
fmt.Println(m1)

map(映射,字典)是一种内置的数据结构,他是一个无序的key-value对的集合,比如以身份证号作为唯一键来标识一个人的信息

map的格式为

map[keyType]valueType

在一个map里所有的键都是唯一的,而且必须是支持==和!=操作符类型的,切片,函数,以及包含切片的结构类型这些类型由于具有引用语义,不能作为映射的键

key顺序是无序的

var m1 map[int]string    ---不能存储数据
map[int]string{}            ---能存储数据
make(map[int]string)        ---能存储数据

基本操作

func main() {
   var m1 map[int]string
   fmt.Println("m1 = ", m1)
   //对于map只有len,没有cap
   fmt.Println("len = ", len(m1))
   
   //可以通过make创建
   m2 := make(map[int]string)
   fmt.Println("m2 = ", m2)
   fmt.Println("len = ", len(m2))
}

输出

m1 =  map[]
len =  0
m2 =  map[]
len =  0

赋值

func main() {
   m1 := map[int]string{1: "mike", 2: "yoyo"}

   for key, value := range m1{
      fmt.Printf("%d ===> %s\n", key, value)
   }
}

判断值是否存在

two-value写法：

a, ok := m[key]

当key存在时，ok是true，否则是false

func main() {
   m1 := map[int]string{1: "mike", 2: "yoyo"}

   value, ok := m1[1]
   if ok==true {
      fmt.Println("m1[1] = ", value)
   } else {
      fmt.Println("key不存在")
   }
}

删除

func main() {
   m1 := map[int]string{1: "mike", 2: "yoyo"}

   fmt.Println("m = ", m1)
   //key不存在也没关系
   delete(m1, 1)
   fmt.Println(m1)
}

函数参数

引用传递

func test(m map[int]string) {
   delete(m, 1)
}

func main() {
   m1 := map[int]string{1: "mike", 2: "yoyo"}

   fmt.Println("m = ", m1)
   test(m1)
   fmt.Println("m = ", m1)
}

nil

只有仅写var m map[key_type]value_type才能得到nil map

一旦初始化，即m = make(map[key_type]value_type)就不是nil map了

nil map是无法通过%T看到，%T看到的都是map[key_type]value_type，比如map[string]int

若往nil map（即未make的map）中插入键值对，则会报错panic: assignment to entry in nil map

key和value可用struct

type Key struct {
    a, b string
}

type Value struct {
    c, d int
}

var m map[Key]Value

func main() {
    m = make(map[Key]Value)
    m[Key{
        "A", "B",
    }] = Value{
        1, 2,
    }
    fmt.Println(m[Key{
        "A","B",
    }])
    fmt.Println(m)
    fmt.Printf("%T\n", m)
}

输出

{1 2}
map[{A B}:{1 2}]
map[main.Key]main.Value