Go的容器（四）

Go语言中提供了很多容器，用来存放数据的

Array(数组)

数组是同一种数据类型元素的集合。 在Go语言中，数组从声明时就确定，使用时可以修改数组成员，但是数组大小不可变化想改变大小，还得用另一个种数据类型
定义语法：
var 数组变量名 [元素数量]l类型

数组的长度必须是常量，并且长度是数组类型的一部分。一旦定义，长度不能变

var a [3]int
var b [4]int
a = b //不可以这样做，因为此时a和b是不同的类型

数组可以通过下标进行访问，下标是从0开始，最后一个元素下标是：len-1 不允许越界访问

数组初始化

1、 初始化数组时可以使用初始化列表来设置数组元素的值

   var testArray [3]int                        //数组会初始化为int类型的零值
	var numArray = [3]int{1, 2}                 //使用指定的初始值完成初始化
	var cityArray = [3]string{"北京", "上海", "深圳"} //使用指定的初始值完成初始化

2、根据初始值的个数自行推断数组的长度

    var numArray = [...]int{1, 2} //长度为2
	var cityArray = [...]string{"北京", "上海", "深圳"} // 长度为3

数组遍历

遍历数组a有以下两种方法分别是下标遍历和值遍历

下标遍历

var a = [...]string{"北京", "上海", "深圳"}
	// 方法1：for循环遍历
	for i := 0; i < len(a); i++ {
		fmt.Println(a[i])
	}

值遍历

var a = [...]string{"北京", "上海", "深圳"}
// 方法2：for range遍历
	for index, value := range a {
		fmt.Println(index, value)
	}

番外

Go语言的数组是支持多维数组的，创建方式与其他语言一样，可自行学习，
另外Go语言的数组是值类型，赋值和传参会复制整个数组。因此改变副本的值，不会改变本身的值

切片（slice）

因为数组的长度是固定的并且数组长度属于类型的一部分，所以数组有很多的局限性。

而切片（Slice）是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。它非常灵活，支持自动扩容。
切片是一个引用类型，它的内部结构包含地址、长度和容量。切片一般用于快速地操作一块数据集合。

语法

声明语法:

var name []T

与数组不同之处在于，没有了长度参数

    var a []string              //声明一个字符串切片
	var b = []int{}             //声明一个整型切片并初始化
	var c = []bool{false, true} //声明一个布尔切片并初始化
	var d = []bool{false, true} //声明一个布尔切片并初始化

切片的长度和容量

切片都有自己的长度和容量，可以通过内置函数len()函数求长度，使用内置的cap()函数求切片的容量。
切片的底层是数组，所以我们可以通过数组切片表达式得到切片

func main() {
	a := [5]int{1, 2, 3, 4, 5}
	s := a[1:3]  // 1为Low,3 为high 
	fmt.Printf("s:%v len(s):%v cap(s):%v\n", s, len(s), cap(s))
}

注意 ：对于数组或字符串，如果0 <= low <= high <= len(a)，则索引合法，否则就会索引越界

使用make()函数构造切片

make([]T, size, cap)

• T:切片的元素类型
• size:切片中元素的数量
• cap:切片的容量

更多

1、切片不能直接比较
切片之间是不能比较的，我们不能使用==操作符来判断两个切片是否含有全部相等元素

2、切片的赋值拷贝
两个变量共享底层数组，对一个切片的修改会影响另一个切片的内容

func main() {
	s1 := make([]int, 3) //[0 0 0]
	s2 := s1             //将s1直接赋值给s2，s1和s2共用一个底层数组
	s2[0] = 100
	fmt.Println(s1) //[100 0 0]
	fmt.Println(s2) //[100 0 0]
}

3、切片的遍历
切片的遍历方式和数组是一致的，支持索引遍历和值遍历

4、切片扩容
每个切片会指向一个底层数组，这个数组的容量够用就添加新增元素。当底层数组不能容纳新增的元素时，切片就会自动按照一定的策略进行“扩容”，此时该切片指向的底层数组就会更换。“扩容”操作往往发生在append()函数调用时，所以我们通常都需要用原变量接收append函数的返回值。

添加元素到切片

Go语言的内建函数append()可以为切片动态添加元素。 可以一次添加一个元素，可以添加多个元素，也可以添加另一个切片中的元素

func main(){
	var s []int
	s = append(s, 1)        // [1]
	s = append(s, 2, 3, 4)  // [1 2 3 4]
	s2 := []int{5, 6, 7}  
	s = append(s, s2...)    // [1 2 3 4 5 6 7]
}

通过var声明的零值切片可以在append()函数直接使用，无需初始化。

var s []int
s = append(s, 1, 2, 3)

Map

Go语言中提供的映射关系容器为map，其内部使用散列表（hash）实现。

map是一种无序的基于key-value的数据结构，Go语言中的map是引用类型，必须初始化才能使用

定义

map[KeyType]ValueType

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

map类型的变量默认初始值为nil，需要使用make()函数来分配内存。

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

其中cap表示map的容量，该参数虽然不是必须的，但是我们应该在初始化map的时候就为其指定一个合适的容量

Map的基本使用

map中的数据都是成对出现的

func main() {
	scoreMap := make(map[string]int, 8)
	scoreMap["摘星"] = 90
	scoreMap["断江"] = 100
	fmt.Println(scoreMap)
	fmt.Println(scoreMap["摘星"])
	fmt.Printf("type of a:%T\n", scoreMap)
}