数组

数组是同一类型元素的集合。所有元素全部都应该是同一种类型。例如，整数集合 5,8,9,79,76 形成一个数组。Go 语言中不允许混合不同类型的元素，例如包含字符串和整数的数组。（当然，如果是 interface{} 类型数组，可以包含任意类型）

一、数组的定义

1、声明数组

语法：

var 数组名 [元素个数]元素类型  // 数组大小固定，不能多

数组的默认值和数组存放的类型有关。

var lis [3] int
fmt.Println(lis)  // [0 0 0] int的默认值是0

2、初始化设值

语法：

var 数组名 [元素个数]元素类型 = [元素个数]元素类型{元素1,元素2,元素3}

定义每个元素
//var lis [3]int = [3]int{1, 2, 3}
// lis := [3]int{1, 2, 3}
var lis = [3]int{1, 2, 3}
fmt.Println(lis)   // [1 2 3]
fmt.Printf("%T",lis)  // [3]int

3、指定位置设值

只想设置某个位置的元素。

语法：

[元素个数]元素类型{索引:值} ，其它都是默认值

var a [30]int=[30]int{28:1,23:999}

4、不指定长度初始化(了解)

[]内不指定长度，而是[...]，这样声明的数组长度为初始化的最大长度。而不是变长数组。

了解 (这不是可变长)
a :=[...]int{28:1,23:999}  //长度为29
a :=[...]int{2,3,4}  //长度为3
// a :=[3]int{2,3,4}  //长度为3

二、数组的使用

索引取值

var lis = [3]int{2, 4, 6}
fmt.Println(lis[0],lis[2])

2 6

直接修改值

var lis = [3]int{2, 4, 6}
fmt.Println(lis)
lis[1] = 666
fmt.Println(lis)

[2 4 6]
[2 666 6]

三、数组的类型

[元素个数]元素类型   // 合在一起才是一个数组的类型，数组的大小也是类型的一部分

数组是值类型，而不是引用类型(地址)。

go语言中函数传参，都是copy传递。不管是值类型还是引用类型。都会copy一份，传进这个函数。

如果是值类型的变量，传进函数后被修改，则不会影响被copy的变量。因为已经是不同的变量了。

但如果是引用类型的变量，传进函数后被修改，是会影响到其他的引用这个地址的变量的。因为直接将这个地址的值修改了。

四、数组的长度

用内置函数len()来获取数组的长度。

var a =[30]int{2,4,6}
fmt.Println(len(a))  //3

五、迭代数组

1、初始化迭代

var lis  = [3]int{2,4,6}
for i:=0;i<len(lis);i++{
    fmt.Println(lis[i])
}

2
4
6

2、使用range迭代

//for i:=range a{}   //只用一个值来接收，就是索引
//for i,v:=range a{}  //如果两个值来接收，就是索引(i)和值(v)
//for _,v:=range a{}  //只接受值

var lis  = [3]int{2,4,6}

for i,v:=range lis{
    fmt.Println(i,v)
}

0 2
1 4
2 6

六、多维数组

var a [3][3]int
fmt.Println(a)
[[0 0 0] [0 0 0] [0 0 0]]
----------------------------------
var a [3][3]int=[3][3]int{{1,2,3},{4,5,6},{7,8}}
a[0][1]=999
fmt.Println(a)
[[1 999 3] [4 5 6] [7 8 0]]
----------------------------------
var a [3][3][3]int
fmt.Println(a)
[
    [[0 0 0] [0 0 0] [0 0 0]] 
    [[0 0 0] [0 0 0] [0 0 0]] 
    [[0 0 0] [0 0 0] [0 0 0]]
]

Go的数组

数组