[golang note] 数组切片

红色多瑙河

数组
　　√ golang数组包含的每个数据称为数组元素（element），数组包含的元素个数被称为数组长度（length）。
　　√ golang数组的长度在定义后不可更改，并且在声明时可以是一个常量或常量表达式（在编译期即可计算结果的表达式）。golang数组长度是一个内置常量，可以用len()函数来获取。
　　√ golang数组是一个值类型，在赋值和作为参数传递时都将产生一次复制动作，因此在函数体中无法修改传入的数组的内容。

· 数组声明和初始化

▶ 数组声明

▪ 语法如下
　　

// 数组声明　　
var array [n]Type
　　

　　
// 数组声明和初始化
　　
var array [n]Type = [n]Type{v1, v2, ..., vn}
　　
var array = [n]Type{v1, v2, ..., vn}
　　
array := [n]Type{v1, v2, ..., vn}
　　


▪ 示例如下
　　

[32]byte                    // 长度为32的数组，每个元素为一个字节　　
[2*N] struct { x, y int32 } // 复杂类型数组
　　
[1000]*float64              // 指针数组
　　
[3][5]int                   // 二维数组
　　
[2][2][2]float64            // 等同于[2]([2]([2]float64))
　　


· 数组常用操作

▶ 遍历元素

⊙ 按下标遍历
　　√ 使用len()获取元素个数，然后按下标进行元素遍历操作。

▪ 语法如下
　　

for i := 0; i < len(array); i++ {　　
...
　　
}
　　


▪ 示例如下
　　

package main　　

　　
import "fmt"
　　

　　
func main() {
　　
array := [5]int{1, 2, 3, 4, 5}
　　
for i := 0; i < len(array); i++ {
　　
fmt.Println("array[", i, "] =", array)
　　
}
　　
}
　　


⊙ rang遍历
　　√ 可以使用range关键字来快速遍历所有元素。

▪ 语法如下
　　

for i, v :=range array {　　
...
　　
}
　　


▪ 示例如下
　　

package main　　

　　
import
"fmt"　　

　　
func
main() {　　
array :
= [5]int{1, 2, 3, 4, 5}　　

for i, v :=range array {　　
fmt.Println(
"array[", i, "] =", v)　　
}
　　
}
　　


数组切片
　　√ golang数组切片解决的问题：golang数组长度在定义之后无法再次修改，并且数组是值类型，每次传递都将产生一份副本。
　　√ golang数组切片拥有独立的数据结构，可抽象为3个变量：一个指向原数组的指针，数组切片中元素个数，数组切片分配的存储空间。

· 创建数组切片

▶ 基于数组

▪ 语法如下
　　

var arraySlice []Type = array[first:last]　　

　　√ 数组切片的元素范围为[first, last)。
　　√ first和last的值可以省略，缺省情况下，first=0，last=len(array)
　　√ first和last的值必须满足条件：非负，0 ≤ first ≤ last ≤ len(array)，否则编译器将给出错误：

▪ 示例如下
　　

package main　　

　　
import
"fmt"　　

　　
func
main() {　　

var array [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}　　

var arraySlice1 []int = array[:]   // 1, 2, 3, 4, 5, 6, 7, 8, 9, 10　　
var arraySlice2 []int = array[:5]  // 1, 2, 3, 4, 5
　　
var arraySlice3 []int = array[5:]  // 6, 7, 8, 9, 10
　　
var arraySlice4 []int = array[3:8] // 4, 5, 6, 7, 8
　　

　　
fmt.Println("\nElements of arraySlice1: ")
　　
for _, v :=range arraySlice1 {
　　
fmt.Print(v, " ")
　　
}
　　

　　
fmt.Println("\nElements of arraySlice2: ")
　　
for _, v :=range arraySlice2 {
　　
fmt.Print(v, " ")
　　
}
　　

　　
fmt.Println("\nElements of arraySlice3: ")
　　
for _, v :=range arraySlice3 {
　　
fmt.Print(v, " ")
　　
}
　　

　　
fmt.Println("\nElements of arraySlice4: ")
　　
for _, v :=range arraySlice4 {
　　
fmt.Print(v, " ")
　　
}
　　
fmt.Println()
　　
}
　　


▶ 直接创建
　　√ golang提供的内置函数make()可以用于灵活地创建数组切片。

▪ 语法如下
　　

// 创建一个初始元素个数为m的数组切片　　
arraySlice := make([]Type, m)
　　

　　
// 创建一个初始元素个数为m的数组切片，并预留n个元素的存储空间
　　
arraySlice := make([]Type, m, n)
　　

　　
// 直接创建并初始化包含m个元素的数组切片
　　
arraySlice := []Type{v1, v2, ..., vn}
　　


▪ 示例如下
　　

package main　　

　　
import
"fmt"　　

　　
func
main() {　　
arraySlice1 :
= make([]int, 5)       // 0 0 0 0 0　　
arraySlice2 := make([]int, 5, 10)   // 0 0 0 0 0
　　
arraySlice3 := []int{1, 2, 3, 4, 5} // 1 2 3 4 5
　　

　　
fmt.Println("\nElements of arraySlice1: ")
　　
for _, v :=range arraySlice1 {
　　
fmt.Print(v, " ")
　　
}
　　

　　
fmt.Println("\nElements of arraySlice2: ")
　　
for _, v :=range arraySlice2 {
　　
fmt.Print(v, " ")
　　
}
　　

　　
fmt.Println("\nElements of arraySlice3: ")
　　
for _, v :=range arraySlice3 {
　　
fmt.Print(v, " ")
　　
}
　　
}
　　


▶ 基于数组切片
　　√ 数组切片（newSlice）也可以基于另一个数组切片（oldSlice）创建。
　　√ newSlice元素范围可以超过oldSlice所包含的元素个数，只要选择范围不超过oldSlice的存储能力，即cap(oldSlice)的值，那么这个创建是合法的，newSlice中超出oldSlice元素的部分都会填上0。
　　√ newSlice的存储能力等同于oldSlice的存储能力，即cap(newSlice) = cap(oldSlice)。

▪ 语法如下
　　

newSlice := oldSlice[first:last] // 0 ≤ first ≤ last ≤ cap(oldSlice)　　


▪ 示例如下
　　

package main　　

　　
import
"fmt"　　

　　
func
main() {　　
oldSlice :
= make([]int, 5, 10)　　
newSlice :
= oldSlice[:8]　　

　　
fmt.Println(
"Length   of oldSlice: ", len(oldSlice)) // 5　　
fmt.Println("Capacity of oldSlice: ", cap(oldSlice)) // 10
　　

　　
fmt.Println("Length   of newSlice: ", len(newSlice)) // 8
　　
fmt.Println("Capacity of newSlice: ", cap(newSlice)) // 10
　　
}
　　


· 数组切片的元素个数和存储能力
　　√ 与数组相比，数组切片多了一个存储能力（capacity）的概念，即当前容纳的元素个数和分配的空间可以是两个不同的值。
　　√ 存储能力，可以理解为最大容纳元素个数，最大容纳元素个数减去当前容纳元素个数剩下的空间是隐藏的，不能直接使用。如果要往隐藏空间中新增元素，可以使用append()函数。
　　√ 取得当前容纳元素个数可以使用len()函数，取得最大容纳元素个数可以使用cap()函数。
　　

package main　　

　　
import
"fmt"　　

　　
func
main() {　　
arraySlice :
= make([]int, 5, 10)　　
fmt.Println(
"len(arraySlice):", len(arraySlice)) // len(arraySlice): 5　　
fmt.Println("cap(arraySlice):", cap(arraySlice)) // cap(arraySlice): 10
　　
}
　　


· 数组切片常用操作

▶ 遍历元素

⊙ 按下标遍历
　　√ 与遍历数组一样，使用len()获取元素个数，然后按下标进行元素遍历操作。

▪ 语法如下
　　

for i := 0; i < len(arraySlice); i++ {　　
...
　　
}
　　


▪ 示例如下
　　

package main　　

　　
import
"fmt"　　

　　
func
main() {　　
arraySlice :
= []int{1, 2, 3, 4, 5}　　

for i := 0; i < len(arraySlice); i++ {　　

fmt.Println("arraySlice[", i, "] =", arraySlice)　　
}
　　
}
　　


⊙ rang遍历
　　√ 与遍历数组一样，可以使用range关键字来快速遍历所有元素。

▪ 语法如下
　　

for i, v :=range arraySlice {　　
...
　　
}
　　


▪ 示例如下
　　

package main　　

　　
import
"fmt"　　

　　
func
main() {　　
arraySlice :
= []int{1, 2, 3, 4, 5}　　

for i, v :=range arraySlice {　　
fmt.Println(
"arraySlice[", i, "] =", v)　　
}
　　
}
　　


▶ 增加元素
　　√ 为数组切片增加元素的方法是使用append()函数。

⊙ 追加元素
　　√ 追加元素时，会自动处理存储空间不足的问题，如果追加的内容超过当前最大容纳元素空间，那么数组切片会自动分配一块足够大的内存。自动分配内存策略为：当前存储能力 * 2，即cap(arraySlice) * 2。

▪ 语法如下
　　

arraySlice = append(arraySlice, v1, v2, ..., vn)　　


▪ 示例如下
　　

package main　　

　　
import
"fmt"　　

　　
func
main() {　　
arraySlice :
= make([]int, 0, 10)　　
arraySlice
= append(arraySlice, 1, 2, 3, 4, 5)　　

　　
fmt.Println(
"len(arraySlice) =", len(arraySlice)) // 5　　
fmt.Println("cap(arraySlice) =", cap(arraySlice)) // 10
　　

　　
for _, v :=range arraySlice {
　　
fmt.Print(v, " ")
　　
}
　　
fmt.Println()
　　

　　
arraySlice = append(arraySlice, 6, 7, 8, 9, 10, 11, 12, 13)
　　
fmt.Println("len(arraySlice) =", len(arraySlice)) // 13
　　
fmt.Println("cap(arraySlice) =", cap(arraySlice)) // 20
　　

　　
for _, v :=range arraySlice {
　　
fmt.Print(v, " ")
　　
}
　　
}
　　


⊙ 追加数组切片
　　√ 为数组切片arraySlice1追加数组切片arraySlice2时，注意在arraySlice2后面追加三个点，这三个点的意思是把arraySlice2所有元素打散后传递给append()函数，这是由于append()函数从第二个参数起的所有参数都必须是待附加的单个元素。

▪ 语法如下
　　

arraySlice = append(arraySlice, appendSlice...)　　


▪ 示例如下
　　

package main　　

　　
import
"fmt"　　

　　
func
main() {　　
arraySlice :
= []int{1, 2, 3}　　
appendSlice :
= []int{4, 5}　　

　　
arraySlice
= append(arraySlice, appendSlice...)　　
fmt.Println(
"len(arraySlice) =", len(arraySlice)) // 5　　
fmt.Println("cap(arraySlice) =", cap(arraySlice)) // 6
　　

　　
for _, v :=range arraySlice {
　　
fmt.Print(v, " ")
　　
}
　　
}
　　


▶ 删除元素
　　√ 数组切片可以动态添加元素，但没有删除元素的函数。代替方法是：可以使用数组切片重新组合的方式来删除一个或多个项。不过从数组切片这种数据结构来看，本身并不适合做删除操作，所以尽量减少使用。

▪ 示例如下
　　

package main　　

　　
import
"fmt"　　

　　
func
main() {　　
s :
= []int{1, 2, 3, 4, 5, 6}　　
i :
= 2　　
s
= append(s[:i], s[i+1:]...)　　

　　
fmt.Println(s)
// [1 2 4 5 6]　　
}
　　


▶ 切片之间元素复制
　　√ golang使用内置函数copy()将数组切片arraySlice2的内容复制到数组切片arraySlice1中。
　　√ 如果两个数组切片元素个数不同，那么就会按其中元素个数较少的数组切片元素个数进行复制操作。

▪ 示例如下
　　

package main　　

　　
import
"fmt"　　

　　
func
main() {　　
arraySlice1 :
= []int{1, 2, 3, 4, 5}　　
arraySlice2 :
= []int{5, 4, 3}　　
copy(arraySlice2, arraySlice1)
// 只会复制arraySlice1的前3个元素到arraySlice2中　　
fmt.Println(arraySlice2)       // [1 2 3]
　　

　　
arraySlice3 := []int{1, 2, 3, 4, 5}
　　
arraySlice4 := []int{5, 4, 3}
　　
copy(arraySlice3, arraySlice4) // 只会复制arraySlice4的3个元素到arraySlice3的前3个位置
　　
fmt.Println(arraySlice3)       // [5 4 3 4 5]
　　
}