make声明字符串类型的切片
go
package main
import ("fmt")
func main() {
// make 声明切片，长度是4， 容量是10
var sliceArr1 = make([]string, 4, 10)
fmt.Printf("切片：%v", sliceArr1)
}map的默认值是nil
go
package main
import ("fmt")
func main() {
var mapObject = make([]map[string]string,3,3)
fmt.Println(mapObject[0]== nil)
// 输出true
} 把mapstringstring 把它看做是一个对象
map等价于{}对象，stringstring等价于key:value的形式
因为map中读取是obje"key"，所以key的声明在括号里
整体如下：
{ key:value的形式，key是字符串，value也是字符串 }
make(\[\]mapstringstring,3,3)
就等价于
make(\[\]{ key:value的形式，key是字符串，value也是字符串 })
切片定义一个对象数组
要定于对象数组，外层肯定是切片，内层是map
mapstringstring => { key:value }
\]map\[string\]string =\> \[{ key:value }
go
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类型的数据
go
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 ={}
mapstring\[\]string = { "key是字符串": value1,value2 }
go
package main
import ("fmt")
func main() {
var mapKeyObjet =make(map[string][]string)
mapKeyObjet["likeArr"] = []string{"吃饭","睡觉","打豆豆"}
mapKeyObjet["action"] = []string{"写代码","参加技术讨论"}
fmt.Println(mapKeyObjet)
} mapaction:\[写代码 参加技术讨论 likeArr:吃饭 睡觉 打豆豆]
循环 map类型的值定义为切片
go
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)
}
}
} mapaction:\[写代码 参加技术讨论 likeArr:吃饭 睡觉 打豆豆]
key：likeArr, value:吃饭
key：likeArr, value:睡觉
key：likeArr, value:打豆豆
key：action, value:写代码
key：action, value:参加技术讨论
map 也是引用数据类型
值类型和引用类型
值类型: 改变变量副本值的时候，不会改变变量本身的值
引用类型:改变变量副本值的时候，会改变变量本身的值
引用类型:改变变量副本值的时候，会改变变量本身的值
go
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)
} mapage:58 name:大王 mapage:58 name:大王
map的无序性
go
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)
}
} 输出的值是：map1:45 3:98 4:78 5:50
1 45
5 50 3 98
4 78
key值的顺序发生变化
每次执行代码，顺序可能都是不一样的哈
map类型让key进行升序然后输出
go
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])
}
} 统计字符串中单词出现的次数
go
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)
}