一.数组：

1.数组的定义

使用循环进行赋值；

使用循环进行for循环进行遍历。
使用for配合range对数组进行遍历。

使用println即可格式化输出数组元素。

package main

import “fmt”

func main(){

    var a [10]int
fmt.Println(len(a))
    //1.
for i := 0; i < len(a); i++{
    a[i] = i+1
    fmt.Println(a[i])
}
    //2.
for _, data := range a  {
    fmt.Println(data)
}
for i, _ := range a  {
    fmt.Println(a[i])
}
    //3.
    fmt.Println(a)

}

2.数组元素默认初始值

int(整型)：0

float64:0

string：空字符串

bool：false

//int(整型):0
    var arr1[10] int
    for i, _ := range arr1 {
        fmt.Println(arr1[i])
    }
    //string:空字符串
    var arr2[10] string
    for i, _ := range arr2 {
        fmt.Println(arr2[i])
    }
    //float64:0
    var arr3[10] float64
    for i, _ := range arr3 {
        fmt.Println(arr3[i])
    }
    //bool:false
    var arr4[10] bool
    for i, _ := range arr4 {
        fmt.Println(arr4[i])
    }

3.数组的初始化

四种数组元素初始化方式：

全部初始化，使用var定义的数组
全部初始化，使用自动类型推导
部分元素初始化
指定元素初始化

通过初始化来确定数组的长度

package main

import “fmt”

func main(){

//1.全部初始化
var a [5]int = [5]int{0, 1, 2, 3, 4}
for _, data := range a  {
    fmt.Println(data)
}
fmt.Println()
//2.全部初始化：自动类型推导
b := [5]int{0, 1, 2, 3, 4}
fmt.Println(b)
//3.部分初始化
c := [5]int{0, 1, 2}
fmt.Println(c)
//4.指定元素初始化
d := [5]int{0:5, 1:10}
fmt.Println(d)
    //5.通过初始化来确定数组长度
e := [...]int{1, 2, 3}
fmt.Println(e)

}

4.同类型数组之间的直接赋值与比较

注意，赋值与比较时需要使用同类型的数组，不同类型的数组是不允许这样操作的。

package main
import "fmt"
func main(){
    //同类型的数组可以使用==、!=进行比较，以及使用=进行赋值
    arr := [3][4]int{
   {1}, {2}, {3}}
    fmt.Println(arr)
    var b [3][4]int = arr
    fmt.Println(b)
    //如果数组类型不同，那么IDE就会报错
    c := [3][4]int{
   {1}, {2}, {3}}
    fmt.Println(c == b)
}

五.多维数组

有多少个[]就是多少维度；

多少维的数组就用多少个for循环进行遍历。

二.切片：

1.切片的定义

var
自动类型推导
make(类型, 长度, 容量)，容量可以省略。

截取切片作为一个新的切片s[0 : 3 : 5]，第二个参数可以理解为以一个参数+3，而是结束位置，及不包含结束位置元素。此时容量同样可以省略，但是截取后得到的切片容量有第一个参数决定：原切片的容量减去以一个参数，含义即从首元素跳过了多少个个位置。

package main

import “fmt”

func main() {

//1.切片的定义
//1.
a := []int{1, 2, 3}
a = append(append(a, 4, 5), 6, 7)
fmt.Println(a)
fmt.Printf("%T", a)
//2.
var b []int = []int{1, 2, 3}
fmt.Println(b)
//3.切片类型 长度len() 容量cap()
s := make([]int, 5, 10)
for i := 0; i < len(s); i++ {
    s[i] = i + 1
    fmt.Println(s[i])
}
fmt.Println(s)
fmt.Println(len(s))
fmt.Println(cap(s))
//4.切片的截取
//5为切片的容量
slice := s[0 : 3 : 5]
fmt.Println(slice)

}

需要注意make的容量问题，正如上面所提到的。

操作	含义
s[n]	切片s中索引位置为n的项
s[:]	从切片s的索引位置0到len(s)-1处所获得的切片
s[low:]	从切片s的索引位置low到len(s)-1处所获得的切片
s[:high]	从切片s的索引位置0到high处所获得的切片，len=high
s[low:high]	从切片s的索引位置low到high处所获得的切片，len=high-low
s[low:high:max]	从切片s的索引位置low到high处所获得的切片，len=high-low，cap=max-low
len(s)	切片s的长度，总是<=cap(s)
cap(s)	切片s的容量，总是>=len(s)

2.切片的追加和拷贝

1.追加：append()

append函数在容量1024之前容量不足时扩容一倍，容量在1024(当然也包括1024)之后则不按照此规律扩容。

package main
import "fmt"
func main() {
    //1024之前扩容一倍
    slice := []int{1}
    old_cap := cap(slice)
    for i:=0;i<10000 ;i++  {
        slice = append(slice, i)
        if old_cap < cap(slice){
            old_cap = cap(slice)
            fmt.Println(old_cap)
        }
    }
}

以上代码输出结果数值如下：

2     4     8     16
32    64    128   256
512   1024  1280  1696
2304  3072  4096  5120
7168  9216  12288

2.拷贝：copy(dest， src)

package main
import "fmt"
func main() {
    src_slice := []int{1, 2, 3}
    dest_slice := []int{4, 5, 6, 7, 8, 9}
    //copy(dest_slice, src_slice)
    copy(src_slice, dest_slice)
    //fmt.Println(dest_slice)
    fmt.Println(src_slice)
}