go语言中的map,map定义不同的数据类型,循环map,map的无序性

make声明字符串类型的切片

package main
import ("fmt")
func main()  {
  // make 声明切片，长度是4， 容量是10
  var sliceArr1 = make([]string, 4, 10)
  fmt.Printf("切片：%v", sliceArr1)
}

map的默认值是nil

package main
import ("fmt")

func main()  {
	var mapObject = make([]map[string]string,3,3)
	fmt.Println(mapObject[0]== nil)
	// 输出true
} 

把map[string]string 把它看做是一个对象
map等价于{}对象，[string]string等价于key:value的形式
因为map中读取是obje["key"]，所以key的声明在括号里
整体如下：
{
key:value的形式，key是字符串，value也是字符串
}
make([]map[string]string,3,3)
就等价于
make([]{
key:value的形式，key是字符串，value也是字符串
})

切片定义一个对象数组

要定于对象数组，外层肯定是切片，内层是map
map[string]string => { key:value }
[]map[string]string => [{ key:value }]

package main
import ("fmt")

func main()  {
	var mapObject = make([]map[string]string,2,2)
	fmt.Println(mapObject[0]== nil)
	if mapObject[0] == nil {
		mapObject[0] = make(map[string]string)
		mapObject[0]["name"] = "xiaoming"
		mapObject[0]["age"] = "18"
	}
	if mapObject[1] == nil {
		mapObject[1] = make(map[string]string)
		mapObject[1]["name"] = "xiaohong"
		mapObject[1]["age"] = "19"
	}
	fmt.Println(mapObject)
} 

[map[age:18 name:xiaoming] map[age:19 name:xiaohong]]

循环map类型的数据

package main
import ("fmt")

func main()  {
	var mapObject = make([]map[string]string,2,2)
	if mapObject[0] == nil {
		mapObject[0] = make(map[string]string)
		mapObject[0]["name"] = "xiaoming"
		mapObject[0]["age"] = "18"
	}
	if mapObject[1] == nil {
		mapObject[1] = make(map[string]string)
		mapObject[1]["name"] = "xiaohong"
		mapObject[1]["age"] = "19"
	}
	for _,value := range mapObject {
		for key,valueInItem := range value {
			  fmt.Printf("key：%v, value:%v\n", key, valueInItem)
		}
	}
} 

key：name, value:xiaoming
key：age, value:18
key：name, value:xiaohong
key：age, value:19

map类型的值定义为切片

map ={}
map[string][]string = {
"key是字符串": [value1,value2]
}

package main
import ("fmt")

func main()  {
	var mapKeyObjet =make(map[string][]string)
	mapKeyObjet["likeArr"] = []string{"吃饭","睡觉","打豆豆"}
	mapKeyObjet["action"] = []string{"写代码","参加技术讨论"}
	fmt.Println(mapKeyObjet)
} 

map[action:[写代码 参加技术讨论] likeArr:[吃饭 睡觉 打豆豆]]

循环 map类型的值定义为切片

package main
import ("fmt")

func main()  {
	var mapKeyObjet =make(map[string][]string)
	mapKeyObjet["likeArr"] = []string{"吃饭","睡觉","打豆豆"}
	mapKeyObjet["action"] = []string{"写代码","参加技术讨论"}
	fmt.Println(mapKeyObjet)

	for key,v := range mapKeyObjet {
		for _,v2 := range v {
			fmt.Printf("key：%v, value:%v\n", key, v2)
		}
	}
} 

map[action:[写代码 参加技术讨论] likeArr:[吃饭 睡觉 打豆豆]]
key：likeArr, value:吃饭
key：likeArr, value:睡觉
key：likeArr, value:打豆豆
key：action, value:写代码
key：action, value:参加技术讨论

map 也是引用数据类型

值类型和引用类型

值类型: 改变变量副本值的时候，不会改变变量本身的值
引用类型:改变变量副本值的时候，会改变变量本身的值

引用类型:改变变量副本值的时候，会改变变量本身的值

package main
import ("fmt")

func main()  {
	var mapKeyObjet =make(map[string]string)
	mapKeyObjet["name"] = "小王"
	mapKeyObjet["age"] = "18"
	userInfo := mapKeyObjet
  // 改变副本的值，会改变变量本身的值
	userInfo["name"] = "大王"
	mapKeyObjet["age"] = "58"
	fmt.Println(userInfo)
	fmt.Println(mapKeyObjet)
} 

map[age:58 name:大王]
map[age:58 name:大王]

map的无序性

package main
import ("fmt")

func main()  {
	var mapObject =make(map[int]int)
	mapObject[1] = 45
	mapObject[5] = 50
	mapObject[3] = 98
	mapObject[4] = 78
	fmt.Println(mapObject)
  for key,value := range mapObject{
		fmt.Println(key,value)
	}
} 

输出的值是：map[1:45 3:98 4:78 5:50]
1 45
5 50
3 98
4 78
key值的顺序发生变化
每次执行代码，顺序可能都是不一样的哈

map类型让key进行升序然后输出

package main
import ("fmt")
import ("sort")

func main()  {
	var mapObject =make(map[int]int)
	mapObject[1] = 45
	mapObject[5] = 50
	mapObject[3] = 98
	mapObject[4] = 78	
	
	var keySlice []int
	for key,_:= range mapObject{
		// 1.通过循环把map中的key放入切片中去
		keySlice = append(keySlice,key)
	}
	// 2.让key进行升序排序
	sort.Ints(keySlice)
	fmt.Printf("map中的key：%v\n",keySlice)

	for _,value := range keySlice{
		// 3.通过key获取value
		fmt.Printf("key:%d,value:%d\n",value, mapObject[value])
	}
} 

统计字符串中单词出现的次数

package main
import ("fmt")
import ("strings")
func main()  {
	var str = "how do you do you"
	var strSlice = strings.Split(str, " ")
	// 输出：[how do you do you],转化为数组
	fmt.Println(strSlice)
  // 创建一个map对象，用来保存单词出现的次数
	var strMap = make(map[string]int)
	for _, v := range strSlice {
    //如果出现相同的单词，次数加1
		sreMap[v]++
	}
	fmt.Println(strMap)
}