什么是数组
golang提供了数组类型的数据结构。数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型，例如（整形，字符串或者自定义类型）。
数组元素可以通过索引（位置）来读取（或者修改），索引从0开始，第一个元素索引为0，第二个索引为1，以此类推。（数组以 0 开始在所有类 C 语言中是相似的）数组的下标取值范围是从0开始的，到长度减1
数组长度必须是一个常量表达式，并且必须是一个非负整数。数组长度也是数组类型的一部分，所以[5]int和[10]int是属于不同类型的。
数组一旦定义后，大小不能更改（编译时需要知道数组长度以便分配内存）。
总结：
- 数组是长度固定的数据类型
- 数据元素的类型相同
- 数组是从0开始的，一直到长度减1为结束
- 数组长度是一个常量表达式，并且是一个非负整数
作用及应用场景
作用：应用场景：数组的定义和语法
一维数组的定义方式
初始化自定义
var arr [10] int
arr[0] = 100
arr[2] = 200
fmt.Println(arr) // [100, 0, 200, 0, 0, 0, 0, 0, 0, 0]
初始赋值定义法
var arr [2] int = [2] int {1, 2}
for i := 0; i < len(arr); i++ {
fmt.Println(i, arr[i])
}
var arr[2] int = [2]int{ 1, 2 }不用定义长度，简略赋值法
package main
import "fmt"
func main() {
arr := [...]int{1, 2, 3, 4, 5}
fmt.Println(arr)
}注意，简略赋值，不需要用var或者const声明
二维数组
package main
import "fmt"
func main() {
var arr1 [2][3]int
fmt.Println(arr1) // [[0 0 0] [0 0 0]]
arr2 := [2][3]int{{1, 2, 4}, {3, 4, 3}}
fmt.Println(arr2) // [[1 2 4] [3 4 3]]
arr3 := [4][3]int{1: {1, 1, 1}, 2: {2, 2, 2}}
fmt.Println(arr3) // [[0 0 0] [1 1 1] [2 2 2] [0 0 0]]
}:=type [2][3]int is not an expression[2][3]int多维度，多个数组
初始定义
package main
import "fmt"
func main() {
var arr [4][3][2]int = [4][3][2]int{}
fmt.Println(arr)
// [[[0 0] [0 0] [0 0]] [[0 0] [0 0] [0 0]] [[0 0] [0 0] [0 0]] [[0 0] [0 0] [0 0]]]
}示例：
package main
import "fmt"
func main() {
/*
一维数组：存储的多个数据是数值本身
a1 :=[3]int{1,2,3}
二维数组：存储的是一维的一维
a2 := [3][4]int{{},{},{}}
该二维数组的长度，就是3。
存储的元素是一维数组，一维数组的元素是数值，每个一维数组长度为4。
多维数组：。。。
*/
a2 := [3][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}
fmt.Println(a2)
fmt.Printf("二维数组的地址：%p\n", &a2)
fmt.Printf("二维数组的长度：%d\n", len(a2))
fmt.Printf("一维数组的长度：%d\n", len(a2[0]))
fmt.Println(a2[0][3]) // 4
fmt.Println(a2[1][2]) //7
fmt.Println(a2[2][1]) // 10
//遍历二维数组
for i:=0;i<len(a2);i++{
for j:=0;j<len(a2[i]);j++{
fmt.Print(a2[i][j],"\t")
}
fmt.Println()
}
fmt.Println("---------------------")
//for range 遍历二维数组
for key1,val1 := range a2{
for key2,val2 := range arr{
fmt.Print(val2,"\t")
}
fmt.Println()
}
}
其他类型的数组创建方式
var a [4] float32 // 等价于：var arr2 = [4]float32{}
fmt.Println(a) // [0 0 0 0]
var b = [5] string{"ruby", "王二狗", "rose"}
fmt.Println(b) // [ruby 王二狗 rose ]
var c = [5] int{'A', 'B', 'C', 'D', 'E'} // byte
fmt.Println(c) // [65 66 67 68 69]
d := [...] int{1,2,3,4,5}// 根据元素的个数，设置数组的大小
fmt.Println(d)//[1 2 3 4 5]
e := [5] int{4: 100} // [0 0 0 0 100]
fmt.Println(e)
f := [...] int{0: 1, 4: 1, 9: 1} // [1 0 0 0 1 0 0 0 0 1]
fmt.Println(f)数组是值类型
golang中的数组是值类型，而不是引用类型。这意味着当它们被分配给一个新变量时，将把原始数组的副本分配给新变量，如果对新变量进行了更改，则不会在原始数组中反映
package main
import "fmt"
func main() {
a := [...]string{"a", "b", "c"}
b := a
b[0] = "小阿肥"
fmt.Println("a is: ", a)
fmt.Println("b is: ", b)
}
数组的排序
数组的排序，就是让一个数组中的数据，根据一定的算法，最终是数值有顺序的，可以从小到大(升序)，也可以从大到小(降序)。默认是升序。
排序算法也有很多种，冒泡排序，选择排序，插入排序，希尔排序，快速排序，堆排序等等。
倒序
arr := [5]int{15, 23, 8, 10, 7}
for i := 0; i < len(arr) - 1; i++ {
if(arr[i] < arr[i + 1]) {
t := arr[i]
arr[i] = arr[i + 1]
arr[i + 1] = t
}
}
fmt.Println(arr)
数组的注意事项
- 数组是值类型
- len()获取长度
- 数组的长度是数组类型的组成部分
- 数组在内存当中是连续的存储空间
- 数组做为参数以引用形式传递函数，意义重大，当传递较大的数组时可以有效的提升cpu执行效率
- 数组做为值类型来传递函数,调用时是值拷贝，如果较大的数组传递对cpu的效能消耗是极其大的
最后
EntrepreneurialG