go语言map、

一、map 的基本介绍

map 是 key-value 数据结构，又称为字段或者关联数组。

二、map 的声明

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

package main

import "fmt"

func main() {
   var a map[string]string
   var a map[string]string
   var a map[int]string
   var a map[string]map[string]string
}

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

2、分配空间

使用make函数为map分配内存空间

 

package main

import "fmt"

func main() {
   var m = make(map[int]interface{},1)
   m[1] = "A"
   m[2] = "B"
   fmt.Printf("m地址:%p;m的值:%v",m,m)

}

三、map 的使用

1、方式 1

var a map[string]string

2、方式 2

不指定长度

package main

import "fmt"

func main() {
   var m = make(map[int]interface{},1)
   m[1] = "A"
   m[2] = "B"
   fmt.Printf("m地址:%p;m的值:%v",m,m)

}

3、方式 3

直接声明并赋值，注意最后要加上,

package main

import "fmt"

func main() {
   var m = map[int]interface{}{
      1:"A",
      2:"B",
   }
   fmt.Printf("m地址:%p;m的值:%v",m,m)

}

四、map 操作

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

2、map 删除：
delete(map，“key”) ，delete 是一个内置函数，如果 key 存在，就删除该 key-value,如果 key 不存在，
不操作，但是也不会报错
​编辑

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

3、map 查找

value := m[key]

如果 m这个 map 中存在 key ， 那么 返回 对应的value,否则返回 对应value类型的默认值

4、map 遍历

map 的遍历使用 for-range 的结构遍历

package main

import "fmt"

func main() {
   var m = map[int]interface{}{
      1:"A",
      2:"B",
   }
   fmt.Printf("m地址:%p;m的值:%v\n",m,m)
   m[3] = "C"
   fmt.Printf("m地址:%p;m的值:%v\n",m,m)
   m[2] = "H"
   delete(m,3)
   for key,value := range m{
      fmt.Printf("key:%v ; value:%v\n",key,value)
   }
   fmt.Printf("m地址:%p;m的值:%v\n",m,m)
}

五、总结：

​​
map 在使用前一定要 make
map 的 key 是不能重复，如果重复了，则以最后这个 key-value 为准
map 的 value 是可以相同的
map 的 key-value 是无序
map 是引用类型，遵守引用类型传递的机制，在一个函数接收 map，修改后，会直接修改原来的 map
map 的容量达到后，再想 map 增加元素，会自动扩容，并不会发生 panic，也就是说 map 能动态的增长 键值对(key-value)
map 的 value 也经常使用 struct 类型，更适合管理复杂的数据(比前面 value 是一个 map 更好)，比如 value 为 Student 结构体

六、练习

1、

package main

import "fmt"

func main() {
   m := map[string]string{
      "name" :"shang",
      "course" : "mooc",
   }
   fmt.Println(m)
   m2 := map[string]int{}
   var m3 map[string]int
   fmt.Println(m2)
   fmt.Println(m3)
   fmt.Println("遍历map")
   for k,v := range m{
      fmt.Println(k,v)
   }
   fmt.Println("Getting values")
   username := m["name"]
   course := m["courseeeee"]
   fmt.Println(username,course)
   password,ok := m["password"]
   username,okk := m["name"]
   fmt.Println(username,okk)
   fmt.Println(password,ok)
   if password,ok = m["password"];ok{
      fmt.Println(password,ok)
   }else{
      fmt.Println("key does not exist")
   }
   fmt.Println("Deleting values")
   delete(m,"name")
   fmt.Println(m)
}

2、

package main

func main() {
   user := map[string]string{
      "username": "xiaoming",
      "password": "123456",
      // "token":    "1dsafaQEWDAadad",
   }
   token, exist := user["token"]
   if exist {
      println(token)
   } else {
      println("非法用户")
   }
}

3、

package main

import "fmt"
// 对于同一个字母x，我们让start始终指向目前不含重复字母的串的首位置，然后寻找la[x]
// la[x]不存在，或者小于start ， 无需操作
// la[x]>=start,则更新start，指向la+1 这个位置
// 更新la[x] 更新maxLength

func leng(s string) int{
   la := make(map[byte]int)
   start := 0
   maxLength := 0
   for i,ch := range []byte(s){
      //当该字符串出现过 => 重复出现了 且如果 以前出现的下标 比 start 大时,start后移一位
      if lastI,ok := la[ch];ok && lastI >= start{
         start = lastI +1
      }
      if i-start+1 > maxLength {
         maxLength= i -start +1
      }
      la[ch] = i
   }
   return maxLength
}
func main() {
   fmt.Println(leng("aaabccc"))
   fmt.Println(leng("bbbbb"))
   fmt.Println(leng("pks"))
}