go语言学习3-复合类型

概念

长度不定的类型，有指针，数组，切片，字典，结构体。

指针

概念：指针是一个代表着某个内存地址的值。这个内存地址往往是在内存中存储的另一个变量的值
的起始位置。

new函数创建内存空间

数组

数组作为函数的参数是值传递。

数组的初始化

func main() {
	//声明定义同时赋值,叫初始化
	//1、全部初始化
	var a [5]int = [5]int{1, 2,3,4,5}
	fmt.Println("a = ",a)
	b := [5]int{1, 2,3,4,5}
	fmt.Println("b = ",b)
	//部分初始化,没有初始化的元素,自动赋值为0
	c := [5]int{1, 2,3}
	fmt.Println("c =",c)
	//指定某个元素初始化
	d := [5]int{2: 10, 4: 20}
	fmt.Println("d = ",d)
}

数组的比较

func main() {
	//.支持比较，只支持==或!=，比较是不是每- -个元素都- -样，2个数组比较，数组类型要一样
	a := [5]int{1, 2, 3, 4, 5}
	b := [5]int{1, 2, 3, 4, 5}
	c := [5] int{1, 2, 3}
	fmt.Println(" a == k", a == b)
	fmt.Println("a==c", a == c)
	//同类型的数组可以赋值
	var d [5]int
	d = a
	fmt.Println("d = ", d)
}

切片slice

切片和数组的区别

func main() {
	//切片和数组的区别
	//数组[] 里面的长度时固定的一个常量， 数组不能修改长度，len和cap永远 都是5
	a := [5] int{}
	fmt.Printf("len = %d, cap = %d\n", len(a), cap(a))
	//切片， []里面为空，或者为...，切片的长度或容易可以不固定
	s := []int{}
	fmt.Printf("1: len = 8%d, cap = %d\n", len(s), cap(s))
	s = append(s, 11) //给切片末尾追加一个成员
	fmt.Printf("append: len = %d，cap = %d\n", len(s), cap(s))
}

切片的创建

func main() {
	//自动推导类型， 同时初始化
	s1 := []int{1, 2, 3, 4}
	fmt.Println("s1 = ", s1)
	//借助make函数，格式make (切片类型，长度，容量)
	s2 := make([]int, 5, 10)
	fmt.Printf("len = %d，cap = %d\n", len(s2), cap(s2))
	//没有指定容量，容量和长度-样
	s3 := make([]int, 5)
	fmt.Printf("len = %d，cap = %d\n", len(s3), cap(s3))
}

切片截取

切片的内建函数

copy

替换相同下标的内容

func main() {
	srcSlice := []int{1,2}
	dstSlice := [] int{6,6,6}
	copy (dstSlice, srcSlice)
	fmt.Println ("dst = ", dstSlice)
}

map

键值对类型，map作为函数参数是引用传递

创建

func main() {
	//先声明再创建
	var map1 map[int]string
	map1 = make(map[int]string,10)
	map1[1] = "第一个"
	fmt.Println(map1)

	//直接创建
	map2 := make(map[int]string,2)
	map2[1] = "第一个"
	map2[2] = "第二个"
	map2[3] = "空间不足自动扩容"
	fmt.Println(len(map2))
	fmt.Println(map2)

	//声明并初始化数据
	map3 := map[int]string{1:"第一个"}
	fmt.Println(map3)
}

常用方法

func main() {
	map1 :=map[int]string{1:"第一个",2:"第二个"}

	fmt.Println(map1)
	//map的遍历
	for key,value :=range map1{
		println(key,value)
	}
	//删除元素
	delete(map1,1)
	fmt.Println(map1)

	//判断key是否存在
	//第一个返回值是key对应的value，第一个为bool值，存在为true
	value,ok := map1[1]

	if ok == true {
		println(value)
	}else {
		println("不存在")
	}

}

结构体

type People struct {
	id int
	name string
}

func main() {
	//初始化
	var peo1  = People{111, "jack"}
	fmt.Println(peo1)
	//修改成员变量
	peo1.id = 111111
	fmt.Println(peo1)
	//指向结构体的指针
	var peo2 *People = &People{222, "jack2"}
	fmt.Println(*peo2)
	//修改成员变量
	peo2.id = 22222
	fmt.Println(*peo2)

	//相同结构体的可以互相赋值
	peo1 = *peo2
	fmt.Println(peo1)

}