第六章第二节 Map和结构体

Map

概述

Go语言中的map(映射、字典)是一种内置的数据结构，它是一个无序的key—value对的集合，比如以身份证号作为唯一键来标识一个人的信息。

info := map[int]string{
	110: "mark",
	111: "yoyo",
	112: "lili",
}

：
map格式为：
map[KeyType]valueType
在一个map里所有的键都是唯一的，而且必须是支持==和!=操作符的类型，切片、函数以及包含切片的结构类型这些类型由于具有引用语义，不能作为映射的键，使用这些类型会造成编译错误：
dict := map[ []string ]int{} //err, invalid map key type []string
map值可以是任意类型，没有限制。map里所有键的数据类型必须是相同的，值也必须如何，但键和值的数据类型可以不相同。
注意：map是无序的，我们无法决定它的返回顺序，所以，每次打印结果的顺序有可能不同。

创建和初始化

map的创建

var m1 map[int]string	//只是声明一个map，没有初始化，此为空（nil）map
fmt.Println(m1 == nil)	//true
//m1[1] = "mike"	//err, panic: assignment to entry in nil map

// m2, m3的创建方法是等价的
m2 := map[int]string{}
m3 := mmake(map[int]string)
fmt.Printlnn(m2, m3)	//map[] map[]

m4 := make(mmap[int]string, 10)	//第二个参数指定容量
fmt.Println(m4)		//map[]

初始化

//1、定义同时初始化
var m1 map[int]string = map[int]string{1: "mike", 2: "yoyo"}
fmt.Println(m1)	//map[1:mike	2:yoyo]	

//2、自动推导类型 :=
m2 := map[int]string{1: "mike", 2: "yoyo"}
fmt.Println(m2)

常用操作

赋值

m1 := map[int]string{1: "mike", 2: "yoyo"}
m1[1] = "xxx"	//修改
m1[3] = "lily"	//追加，go底层会自动为map分配空间
fmt.Println(m1)	//map[1:xxx 2:yoyo 3: lily]

m2 := make(map[int]string, 10)	//创建map
m2[0] = "aaa"
m2[1] = "bbb"
fmt.Println(m2)	//map[0:aaa 1:bbb]
fmt.Println(m2[0], m2[1])	//aaa bbb

遍历

m1 := map[int]string{1: "mike", 2: "yoyo"}
//迭代遍历1，第一个返回值是key，第二个返回值是value
for k,v := range m1 {
	fmt.Printf("%d ----> %s\n", k, v)
	//1 ----> mike
   	//2 ----> yoyo
}

//迭代遍历2，第一个返回值是key，第二个返回值是value（可省略）
for k := range m1 {
	fmt.Printf("%d ----> %s\n", k, m1[k])
	//1 ----> mike
    //2 ----> yoyo
}

//判断某个key所对应的value是否存在, 第一个返回值是value(如果存在的话)
value, ok := m1[1]
fmt.Println("value = ", value, ",ok = ", ok)	//value = mike, ok = true

value2, ok2 := m1[3]
fmt.Println("value2 = ",value2, ", ok2 = ", ok2)	//value2 = , ok2 = false

删除

m1 := map[int]string{1: "mike", 2: "yoyo", 3: "lily"}
//迭代遍历1，第一个返回值是key，第二个返回值是value
for k，v := range m1 {
	fmt.Printf("%d ----> %s\n", k, v)
	//1 ----> mike
    //2 ----> yoyo
    //3 ----> lily
}

delete(m1, 2)	//删除key值为3的map

for k, v := range m1 {
	fmt.Printf("%d ----> %s\n", k, v)
	//1 ----> mike
    //3 ----> lily
}

map做函数参数

在函数间传递映射并不会制造出该映射的一个副本，不是值传递，而是引用传递：

func DeleteMap(m map[int]string,key int) {
	delete(m, key)	//删除key值为3的map
	
	for k, v := range m {
	fmt.Printf("len(m)=%d, %d ----> %s\n", len(m), k, v)
	//len(m)=2, 1 ----> mike
    //len(m)=2, 3 ----> lily
	}
}

func main() {
	m := map[int]strinng{1: "mike", 2: "yoyo", 3: "lily"}

	DeleteMap(m,2)	//删除key值为3的map

	for k, v := range m {
	fmt.Printf(""len(m)=%d, %d ----> %s\n", len(m), k, v)
	//len(m)=2, 1 ----> mike
    //len(m)=2, 3 ----> lily
	}
}

结构体

结构体类型

有时我们需要将不同类型的数据组合成一个有机的整体，如：一个学生有学号/姓名/性别/年龄/地址等属性。显然单独定义以上变量比较繁琐，数据不便于管理。

结构体是一种聚合的数据类型，它是由一系列具有相同类型或不同类型的数据构成的数据集合。每个数据称为结构体的成员。

结构体初始化

//1、打印成员
var s1 Student = Student{1, "mark", 'm', 18, "sz"}
//结果：id = 1, name = mark, sex = m, age =18, addr =sz

//2、成员变量赋值
var s2 Student
s2.id = 2
s2.name = "yoyo"
s2.sex = 'f'
s2.age = 16
s2.addr = "guangzhou"
fmt.Println(s2)	//{2 yoyo 102 16 guangzhou}

结构体比较

如果结构体的全部成员都是可以比较的，那么结构体也是可以比较的，那样的话两个结构体将可以使用 == 或 != 运算符进行比较，但不支持 > 或 < 。

func := Student{
	s1 := Student{1, "mike", 'm', 18, "sz"}
	s2 := Student{1, "mike", 'm', 18, "sz"}
	
	fmt.Println(fmt.Println("s1 == s2", s1 == s2) //s1 == s2 true
    fmt.Println("s1 != s2", s1 != s2) //s1 != s2 false
}

结构体数组

type Student struct {
	id int
	name string
	score int
}
func main() {
	
	//结构体数组
	var arr []Student = []Student{
		Student{1, "李白", 100},
		Student{2, "王维", 100},
		Student{3, "杜甫"， 100}，}

		fmt.Println(arr)
		//循环打印结构体信息
		for i := 0; i < len(arr); i++ {
		fmt.Println(arr[i])
	}
}

结构体作为函数参数

type Hero struct {
	name string
	age int
	power int
}
//结构体作为函数参数
func test18(h Hero)	{
	h.power = 120
	fmt.Println(h)
}

func main() {
	//结构体变量
	h := Hero{"钢铁侠", 30, 100}

	//值传递
	test18(h)

	fmt.Println(h)
}