容器(一）——数组和切片

容器：存储和组织数据的方式

3.1 数组—固定大小的连续空间

数组是一段固定长度的连续内存区域。

在Go语言中，数组从声明时就确定，使用时可修改数组成员，但数组大小不可变化。

3.1.1 声明数组

数组的写法如下：

var 数组变量名 [元素数量]T

其中

• 数组变量名： 数组声明及使用时的变量名。

• 元素数量： 数组的元素数量。可以是一个表达式，但最终通过编译期计算的结果必须是整型数值。也就是说，元素数量不能含有到运行时才能确认大小的数值

• T 可以是任意基本类型，包括 T为数组本身。但类型为数组本身时，可以实现多维数组。

数组演示例子：

var sports [3]string
sports[0] = "pingpang"
sports[1] = "basketball"
sports[2] = "football"
fmt.Println(sports)

3.1.2 初始化数组

数组可以在声明时使用初始化列表进行元素设置，参考下面的代码：

var test = [3]int{1,2,3}

这种方式编写时，需要保证大括号后面的元素数量与数组的大小一致。但一般情况下，这个过程可 以交给编译器，让编译器在编译时，根据元素个数确定数组大小。

var test = [...]int{1,3,4,5,6}

“… ”表示让编译器确定数组大小， 以上例子里编译器会自动为这个数组设置元素个数为5

3.1.3 遍历数组

遍历数据和遍历切片类似，如以下代码：

var sports [3]string
sports[0] = "pingpang"
sports[1] = "basketball"
sports[2] = "football"
for k, v := range sports {
	fmt.Println(k,v)
}

3.2 切片—动态分配大小的连续空间

Go 语言切片的内部结构包含地址、 大小和容量。 切片一般用于快速地操作一块数据集合。 如果将数据集合 比作切糕的话， 切片就是你要的“那一块”。

3.2.1 从数组或切片生成新的切片

切片默认指向一段连续内存区域，可以是数组，也可以是切片本身。

从连续内存区域生成切片是常见的操作，格式如下：

slice [开始位置:结束位置]

• slice 表示目标切片对象。

• 开始位置对应目标切片对象的索引。

• 结束位置对应目标切片的结束索引。

从数组或切片生成新的切片拥有如下特性。

• 取出的元素数量为：结束位置－开始位置。
• 取出元素不包含结束位置对应的索引，切片最后一个元素使用 slice [len(slice］获取。
• 当缺省开始位置时，表示从连续区域开头到结束位置。
• 当缺省结束位置时，表示从开始位置到整个连续区域末尾。
• 两者同时缺省时，与切片本身等效。
• 两者同时为空时，等效于空切片，一般用于切片复位。
• 根据索引位置取切片slice 元素值时，取值范围是（0~ len(slice)-1 ），超界会报运行时错误。生成切片时，结束位置可以填写len(slice）但不会报错。

1. 从指定范围生成切片

从指定范围生成切片示例代码如下：

var highBuilding [30]int

for i:=0; i < 30; i++ {
    highBuilding[i] = i + 1
}
//区间
fmt.Println(highBuilding[10:15])

//中间到尾部的所有元素
fmt.Println(highBuilding[20:])

//开头到中间的所有元素
fmt.Println(highBuilding[:20])

切片有点像C语言里的指针。指针可以做运算，但代价是内存操作越界。切片在指针基础上增加了大小，约束了切片对应的内存区域，切片使用中无法对切片内部的地址和大小进行手动调整，因此切片比指针更安全、 强大。

2. 表示原有的切片

生成切片格式中，当开始和结束的范围都被忽略，则生成的切片表示和原切片一致的切片，并切数据内容一致，代码如下：

a :=[]int{1,2,3}
fmt.Println(a[:])

3. 重置切片，清空元素

把切片的开始和结束位置都设为0，生产的切片将变空，代码如下：

 a :=[]int{1,2,3}
 fmt.Println(a[0:0])

3.2.2 声明切片

每一种类型都可以拥有其切片类型，表示多个类型元素的连续集合。因此切片类型可以被声明。切片类型声明格式如下：

var name []T

• name表示切片类型的变量名
• T表示切片类型对应的元素类型

下面的代码展示了切片声明的使用过程。

var strList []string //声明字符串切片
var numList []int	
var numListEmpty = []int{}	//声明一个空切片

//输出3个切片
fmt.Println(strList, numList, numListEmpty)
//切片判定空的结果
fmt.Println(strList == nil)			//结果：true
fmt.Println(numList == nil)			//结果：true
fmt.Println(numListEmpty == nil)	//结果：false

numListEmpty 已经被分配到了内存，但没有元素，因此和 nil 比较时是false，切片是动态结构，只能与nil判定相等，不能互相判等时。

3.2.3 使用make()函数构造切片

如果需要动态地创建 个切片，可以使用 make（）内建函数，格式如下:

make ( []T, size, cap )

• T： 切片的元素类型

• size：就是为这个类型分配多少个元素。

• cap：预分配的元素数 ，这个值设定后不影响 size，只是能提前分配空间，降低多次分配空间造成的性能问题。

示例如下：

a := make([]int, 2)
b := make([]int, 2, 10)

fmt.Println(a, b, len(a), len(b))

3.2.4 使用append()函数为切片添加元素

代码如下：

var nums []int

for i:=0; i < 10; i++ {
	nums = append(nums, i)
	fmt.Printf("len:%d cap:%d pointer:%p\n", len(nums), cap(nums), nums)
}

3.2.5 复制切片元素到另一个切片

使用Go语言的内建copy()函数，可以迅速地将一个切片的数据复制到另一个切片空间中，copy函数的使用格式如下：

copy(destSlice, srcSlice[]T) int

• srcSlice为数据来源切片
• destSlice为复制的目标。目标切片必须分配过空间且足够承载复制的元素个数。来源和目标的类型一致，copy的返回值表示实际发生复制的元素个数。

slice1 := []int{1, 2, 3, 4, 5}
slice2 := []int{5, 4, 3}
copy(slice2, slice1) // 只会复制slice1的前3个元素到slice2中
copy(slice1, slice2) // 只会复制slice2的3个元素到slice1的前3个位置

3.2.6 从切片中删除元素

Go语言并没有对删除切片元素提供专用的语法或者接口，需要使用切片本身的特性来删除元素。示例代码如下：

seq := []string{"a", "b", "c", "d", "e"}
index := 2
//查看删除位置之前的元素和之后的元素
fmt.Println(seq[:index], seq[index+1:])
//将删除点前后的元素连接起来
seq = append(seq[:index], seq[index+1:]...)
fmt.Println(seq)

Go 中切片删除元元素的本质 ：以被删除元素为分界点，将前后两个部分的内存重新连接起来。

提示：连续容器的元素删除无论是在任何语言中，都要将删除点前后的元素移动到新的位置。随着元素的增加，这个过程将会变得极为耗时 因此，当业务需要大量、频繁地从一个切片中删除元素时，如果对性能要求较高，就需要反思是否需要更换其他的容器（如双链表等能快速从删除点删除元素）。