1. map类型

map是一个无序的基于key-value的数据结构，复合数据类型，map是引用类型，必须初始化才能使用

2. map 语法

map[keyType]ValueType

其中：

• keyType: 表示键的类型
• ValueType: 表示键对应的值类型

map类型的变量默认初始值是nil,需要使用make()函数来分配内存，语法：

make: 用于slice ，map ，和channle 的初始化，相当于申请一块内存空间

make(map[keyType]ValueType,[cap])

其中cap 表示map的容量，该参数不是必须要配置的

3. map定义

3.1 直接声明

在声明的时候，在进行填充元素

var userinfo1 = map[string]string {
	"username": "bds1",
	"age": "19",
	"sex": "男",
}

3.2 字面量

类型推导

package main
import "fmt"
func main() {	
	userinfo2 := map[string]string {
		"username": "bds2",
		"age": "21",
	}
  fmt.Println(userinfo2)
}

3.3 make关键字

package main
import "fmt"
func main() {
	var userinfo = make(map[string]string,10)   //长度也可以不指定
	userinfo["name"] = "bds"										//进行赋值操作
	userinfo["age"] = "18"
	fmt.Println(userinfo["name"])
}

4 map 类型crud

针对map类型的 增删改查

4.1 for循环获取键值

for k,v := range userinfo2 {	
  fmt.Printf("key: %v,value: %v\n",k,v)
}

4.2 创建和更新map数据

package main

import (
	"fmt"
)

func main() {
	userinfo := map[string]string {
		"name": "bds",							 //创建值操作
		"age": "21",
	}
	userinfo["name"] = "dsb"       //更新值操作
	fmt.Println(userinfo)

}
//map[age:21 name:dsb]

4.3 获取和查找map 数据

package main

import (
	"fmt"
)

func main() {
	userinfo := map[string]string {
		"name": "dsb",							 //创建值操作
		"age": "21",
	}
	fmt.Println(userinfo)
	v, ok := userinfo["name"]     //这里通过一个布尔值判断有没有数据
	fmt.Println(v,ok)             //打印： dsb true

	v1, ok1 := userinfo["xxx"]
	fmt.Println(v1,ok1)           //打印： 空和false
}

4.4 删除map数据

package main

import (
	"fmt"
)
func main() {
	userinfo := map[string]string {
		"name": "bds",
		"age": "21",

		"height": "180",
		"sex": "男",
	}
	fmt.Println(userinfo)
	delete(userinfo,"sex")      //删除	
	fmt.Println(userinfo)
}
//map[age:21 height:180 name:bds sex:男]
//map[age:21 height:180 name:bds]

5 map类型与其他类型使用

5.1 元素为map类型的切片

想要在切片放一系列的信息，这时候我们就可以定一个map类型的切片

package main

import "fmt"

func main() {
  //1 第一种通过make来创建
	var userinfo = make([]map[string]string,3,3)
	if userinfo[0] == nil {
			userinfo[0] = make(map[string]string)
			userinfo[0]["name"] = "bds"
			userinfo[0]["age"] = "19"
			userinfo[0]["height"] = "180"

      userinfo[1] = map[string]string {
        "name": "budongshu",
        "age": "20",
        "height": "130",
    }
	}
  fmt.Println(userinfo)  //[map[age:19 height:180 name:bds] map[age:20 height:130 name:budongshu] map[]]
  //最后会有一个空map 因为我们定义切片的时候 设置长度为3 
  
  
  // 2 第二种创建方式
	s1 := []map[string]string {{"name": "bds1", "age": "19",}}
	fmt.Println(s1)
	s1[0]["name"] = "bds2"
	fmt.Println(s1)

 }

5.2 通过for 循环获取切片中的map

package main

import "fmt"

func main() {
	s1 := []map[string]string {{"name": "bds1", "age": "19",}}
	fmt.Println(s1)
	s1[0]["name"] = "bds2"
	
	fmt.Println(s1)
	for _,v := range s1 {
	   fmt.Println(v)
	   for k,v  :=  range v {
	      fmt.Printf("key: %v,Value: %v\n",k,v)
	   } 
	}
}
/*
[map[age:19 name:bds1]]
[map[age:19 name:bds2]]
map[age:19 name:bds2]
key: name,Value: bds2
key: age,Value: 19
*/

5.3 map 值为切片类型

想要在map的值中放一系列属性，这时候我们就可以定一个map类型的值类型为：切片

	var m1 = make(map[string][]string)
	m1["bobby"] = []string{
		"cf",
		"cs",
		"play game",
		"do girl",
	}
	m1["work"] = []string{
		"golang",
		"python",
	}
	fmt.Println(m1)
//map[bobby:[cf cs play game do girl] work:[golang python]]

对上面的数据进行for循环

for _,v := range m1 {
	fmt.Println(v)
	for _,val := range v {
		fmt.Println(val)
	}

6 map类型 引用数据类型

值类型：改变变量副本值的时候，不会改变变量本身的值 （基本数据类型，数组）

引用类型： 改变变量副本值的时候，会改变变量本身的值 （切片，map）

7 map 类型的一些使用

7.1 按照map的 key 升级

让其输出map的 key => value

package main

import (
	"fmt"
	"sort"
)

func main() {
	m1 := make(map[int]int)
	m1[1] = 10
	m1[5] = 5
	m1[10] = 1
	m1[2] = 40
	m1[20] = 3
	m1[3] = 2
	var s1  []int
	for key,_ := range m1 {
		s1 = append(s1,key)

	}

 	fmt.Println(m1)
	fmt.Println(s1)
	sort.Ints(s1)
	fmt.Println(s1)

	for _,v := range s1{
		fmt.Printf("key: %v,value: %v\n",v,m1[v])
	}
}
/*
key: 1,value: 10
key: 2,value: 40
key: 3,value: 2
key: 5,value: 5
key: 10,value: 1

*/

7.2 计算字符串中单词的次数

package main

import (
	"fmt"
	"strings"
)
func main() {
	var s1 = "how do you do"
	s2 := strings.Split(s1," ")
	fmt.Println(s2)

	map1 := make(map[string]int)

	for _,v := range s2 {
		map1[v]++
	}
	fmt.Println(map1)
}
/*
[how do you do]
map[do:2 how:1 you:1]

*/