1.数组
数组 类型名是[n]elemetType，其中n是数组长度，elementType是数组元素类型。比如一个包 含2个int类型元素的数组类型可表示为[2]int。 数组一般在创建时通过字面量初始化，单独声明一个数组类型变量而不进行初始化是没有意义的。
package main
import (
"fmt"
)
func main() {
a := [3]int{1, 2, 3} \\指定长度和初始化字面量
b := [...]int{1, 2, 3} \\不指定长度，但是由后面的初始化列表来确定其长度
c := [3]int{1: 1, 2: 3} \\指定总长度，并通过索引值进行初始化，没有初始化的元素使用类型默认值0
d := [...]int{1: 1, 2: 3} \\不指定总长度，并通过索引值进行初始化，数组长度由最后一个索引值确定，没有初始化的元素使用类型默认值0
for i := 0; i < 3; i++ {
f := a[i]
g := b[i]
h := c[i]
j := d[i]
fmt.Printf("\r")
fmt.Println(f, g, h, j)
// fmt.Printf("\r")
}
}
1 1 0 0
2 2 1 1
3 3 3 3
数组的特点：
数组创建后长度就固定了，不可以在追加元素
数组是值类型，数组赋值或作为函数参数都是值拷贝
数组长度是数组类型的组成部分，[10]int和[20]int表示不同的类型
可以根据数组创建切片
2.切片
Go语言的数组的定长性和值拷贝限制了其使用场景，Go提供了另一种数据类型slice（切片），这是一种变长数组，其数据结构中有指向数组的指针，所以是一种引用类型。
Go为切片维护三个元素：指向底层数组的指针、切片的元素数量和底层数组的容量。
我们通过数组创建切片：
package main
import (
"fmt"
)
func main() {
var array = [...]int{0, 1, 2, 3, 4, 5, 6}
s1 := array[0:4]
s2 := array[:4]
s3 := array[2:]
fmt.Printf("%v\n", s1)
fmt.Printf("%v\n", s2)
fmt.Printf("%v\n", s3)
}
[0 1 2 3]
[0 1 2 3]
[2 3 4 5 6]
通过内置函数make创建切片，注意由make 创建的切片各元素被默认初始化为切片元素类型的零值：
package main
import (
"fmt"
)
func main() {
a := make([]int, 10)
fmt.Printf("%v\n", a)
}
[0 0 0 0 0 0 0 0 0 0]
注意：直接声明切片类型变量是没有意义的
package main
import (
"fmt"
)
func main() {
var a []int
fmt.Printf("%v\n", a)
}
[]
此时a的数据结构为：
切片支持的操作：
1.内置函数len()返回切片长度
2.内置函数cap()返回切片底层数组容量
3.内置函数append()对切片进行追加
4.内置函数copy()用于复制一个切片
package main
import (
"fmt"
)
func main() {
a := [...]int{0, 1, 2, 3, 4, 5, 6}
b := make([]int, 2, 4)
c := a[0:3]
fmt.Println(len(b))
fmt.Println(cap(b))
b = append(b, 1)
fmt.Println(b)
fmt.Println(len(b))
fmt.Println(cap(b))
b = append(b, c...)
fmt.Println(b)
fmt.Println(len(b))
fmt.Println(cap(b))
d := make([]int, 2, 2)
copy(d, c)
fmt.Println(d)
fmt.Println(len(d))
fmt.Println(cap(d))
}
2
4
[0 0 1]
3
4
[0 0 1 0 1 2]
6
8
[0 1]
2
2 字符串和切片的相互转换：
package main
func main() {
str := "hello,world"
a := []byte(str)
b := []rune(str)
}
