合并多个数组：

package main
import "fmt"

func main() {
    var arr1 = []int{1,2,3}
    var arr2 = []int{4,5,6}
    var arr3 = []int{7,8,9}
    var s1 = append(append(arr1, arr2...), arr3...)
    fmt.Printf("s1: %v\n", s1)
}

输出结果：

s1: [1 2 3 4 5 6 7 8 9]

numbers := []int{0,1,2,3,4,5,6,7,8}
number3 := numbers[2:5]
printSlice(number3)

结果为:

len=3 cap=7 slice=[2 3 4]

capacity 为 7 是因为 number3 的 ptr 指向第三个元素， 后面还剩 2,3,4,5,6,7,8, 所以 cap=7。

如：

number4 := numbers[5:]
printSlice(number4)

结果为：

len=4 cap=4 slice=[5 6 7 8]

capacity 为 4 是因为 number4 的 ptr 指向第六个元素， 后面还剩 5,6,7,8 所以 cap=4。

我们基于原数组或者切片创建一个新的切片后，那么新的切片的大小和容量是多少呢？

这里有个公式，对于底层数组容量是 k 的切片 slice[i:j] 来说：

长度: j-i
容量: k-i

例子：

package main

import "fmt"
func main() {
    numbers:=[]int{0,1,2,3,4,5,6,7,8,9,10}
    printSlice(numbers)
    fmt.Printf("%d\n",numbers[1:3])
    fmt.Printf("%d\n",numbers[2:7])
    fmt.Printf("%d\n",numbers[:3])
    fmt.Printf("%d\n",numbers[4:])
    number1:=make([]int,0,5)
    number2:=numbers[:3]
    printSlice(number1)
    printSlice(number2)
    number3:=numbers[2:5]
    printSlice(number3)
    number4:=numbers[3:8]
    printSlice(number4)
}

func printSlice(x []int) {
    fmt.Printf("len=%d  cap=%d   slice=%v\n",len(x),cap(x),x)
}

执行结果:

len=11  cap=11   slice=[0 1 2 3 4 5 6 7 8 9 10]
[1 2]
[2 3 4 5 6]
[0 1 2]
[4 5 6 7 8 9 10]
len=0  cap=5   slice=[]
len=3  cap=11   slice=[0 1 2]
len=3  cap=9   slice=[2 3 4]
len=5  cap=8   slice=[3 4 5 6 7]

package main

import "fmt"

func main() {
   sliceTest()
   twoDimensionArray()
}

func sliceTest() {
   arr := []int{1, 2, 3, 4, 5}
   s := arr[:]
   for e := range s {
      fmt.Println(s[e])
   }
   s1 := make([]int, 3)
   for e := range s1 {
      fmt.Println(s1[e])
   }
}

func twoDimensionArray() {
   /* 数组 - 5 行 2 列*/
   var a = [][]int{{0, 0}, {1, 2}, {2}, {3, 6}, {4, 8}}
   var i, j int

   /* 输出数组元素 */
   for i = 0; i < len(a); i++ {
      for j = 0; j < len(a[i]); j++ {
         fmt.Printf("a[%d][%d] = %d\n", i, j, a[i][j])
      }
   }
}

sliceTest 函数是切片测试代码，简单的两种初始化方式。

twoDimensionsArray 函数是二维数组测试函数。

测试结果:

1.二维数组中的元素(一位数组)个数 > 限制的列数,异常;

2.二维数组中的元素(一位数组)个数 <= 限制的列数,正常;

假设列数为 3, 某个一位数组 {1}, 则后两个元素,默认为 0。

package main
import "fmt"

func main() {
   numbers := []int{0,1,2,3,4,5,6,7,8}
   printSlice(numbers)
   fmt.Println("numbers ==",numbers)
   numbers1 := numbers[1:4]
   printSlice(numbers1)
   fmt.Println("numbers[:3] ==", numbers[:3])
   numbers2 :=numbers[4:]
   printSlice(numbers2)
   numbers3 := make([]int,0,5)
   printSlice(numbers3)
   numbers4 := numbers[:2]
   printSlice(numbers4)
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

输出结果：

len=9 cap=9 slice=[0 1 2 3 4 5 6 7 8]
numbers == [0 1 2 3 4 5 6 7 8]
len=3 cap=8 slice=[1 2 3]
numbers[:3] == [0 1 2]
len=5 cap=5 slice=[4 5 6 7 8]
len=0 cap=5 slice=[]
len=2 cap=9 slice=[0 1]

我们可以看出切片，实际的是获取数组的某一部分，len切片<=cap切片<=len数组，切片由三部分组成：指向底层数组的指针、len、cap。