数组Array
重点：
数组是值类型
注意点:
1. 数组：是同一种数据类型的固定长度的序列。
2. 数组定义：var a [len]int，比如：var a [5]int，数组长度必须是常量，且是类型的组成部分。一旦定义，长度不能变。
3. 长度是数组类型的一部分，因此，var a[5] int和var a[10]int是不同的类型。
4. 数组可以通过下标进行访问，下标是从0开始，最后一个元素下标是：len-1
for i := 0; i < len(a); i++ {
}
for index, v := range a {
}
5. 访问越界，如果下标在数组合法范围之外，则触发访问越界，会panic
6. 数组是值类型，赋值和传参会复制整个数组，而不是指针。因此改变副本的值，不会改变本身的值。
7.支持 "=="、"!=" 操作符，因为内存总是被初始化过的。
8.指针数组 [n]*T，数组指针 *[n]T。
一维数组定义:
全局：
var arr0 [5]int = [5]int{1, 2, 3}
var arr1 = [5]int{1, 2, 3, 4, 5}
// 通过初始化值确定数组长度。
var arr2 = [...]int{1, 2, 3, 4, 5, 6}
var str = [5]string{3: "hello world", 4: "tom"}
局部：
a := [3]int{1, 2} // 未初始化元素值为 0。
b := [...]int{1, 2, 3, 4} // 通过初始化值确定数组长度。
c := [5]int{2: 100, 4: 200} // 使用索引号初始化元素。
d := [...]struct { // 结构体数组，前段是结构定义，后段是初始化
name string
age uint8
}{
{"user1", 10}, // 可省略元素类型。
{"user2", 20}, // 别忘了最后一行的逗号。
}
package main
import (
"fmt"
)
var arr0 [5]int = [5]int{1, 2, 3}
var arr1 = [5]int{1, 2, 3, 4, 5}
var arr2 = [...]int{1, 2, 3, 4, 5, 6}
var str = [5]string{3: "hello world", 4: "tom"}
func main(){
a := [3]int{1, 2} // 未初始化元素值为 0。
b := [...]int{1, 2, 3, 4} // 通过初始化值确定数组长度。
c := [5]int{2: 100, 4: 200} // 使用引号初始化元素。
d := [...]struct {
name string
age uint8
}{
{"user1", 10}, // 可省略元素类型。
{"user2", 20},
{"刘小琦",21}, // 别忘了最后一行的逗号。
}
fmt.Printf("arr2的长度为：%d,str的长度为：%d\n", len(arr2), len(str))
fmt.Println(arr0, arr1, arr2, str)
fmt.Printf("b的长度为：%d,d的长度为：%d\n", len(a), len(d))
fmt.Println(a, b, c, d)
}
多维数组:
全局
var arr0 [5][3]int
var arr1 [2][3]int = [...][3]int{{1, 2, 3}, {7, 8, 9}}
局部：
a := [2][3]int{{1, 2, 3}, {4, 5, 6}}
b := [...][2]int{{1, 1}, {2, 2}, {3, 3}} // 第 2 纬度不能用 "..."。第1维度可以用。
package main
import(
"fmt"
)
// 全局
var arr0 [5][3]int // 定义了就有默认值0
var arr1 [2][3]int = [...][3]int{{1, 2, 3}, {7, 8, 9}}
func main(){
// 局部：
a := [2][3]int{{1, 2, 3}, {4, 5, 6}} // 初始化时就赋值
b := [...][2]int{{1, 1}, {2, 2}, {3, 3}} // 第 2 纬度不能用 "..."。
// 打印数组
fmt.Println("arr0:", arr0)
fmt.Println("arr1:", arr1)
fmt.Println("a:", a)
fmt.Println("b:", b)
}
数组是值传递
package main
import (
"fmt"
)
func test(x [2]int) {
fmt.Printf("x: %p\n", &x)
x[1] = 1000
}
func main() {
a := [2]int{}
fmt.Printf("a: %p\n", &a)
test(a)
fmt.Println(a)
}
内置函数 len 和 cap 都返回数组长度 (元素数量)。
内置函数 len 和 cap 在处理数组、切片和映射（map）时有所不同。
len函数用于获取数组、切片、映射、字符串等的长度。对于数组和切片，len返回的是元素的数量。对于映射，len返回的是键值对的数量。cap函数用于获取数组、切片的容量。容量指的是底层数组可以容纳的元素数量。对于数组，其容量和长度是相同的，都是数组定义时的大小。而对于切片，容量是从切片的起始位置到底层数组的结束位置之间的元素数量，这可能比切片的长度要大。
简单来说，对于数组，len 和 cap 返回的值是相同的。而对于切片，len 返回的是切片中实际包含的元素数量，而 cap 返回的是切片可以增长到的最大元素数量，直到需要分配新的底层数组。
数组指针
使用这种方式进行数组拷贝和传参，是可以改变原数组的
package main
import "fmt"
func printArr(arr *[5]int) {
fmt.Println(arr)
arr[0] = 10
for i, v := range arr {
fmt.Println(i, v)
}
}
func main() {
var arr1 [5]int
printArr(&arr1)
fmt.Println(arr1)
arr2 := [...]int{2, 4, 6, 8, 10}
printArr(&arr2)
fmt.Println(arr2)
}
输出：但是我们注意我们传进去的是数组的地址，传参时使用&取地址符
&[0 0 0 0 0]
0 10
1 0
2 0
3 0
4 0
[10 0 0 0 0]
&[2 4 6 8 10]
0 10
1 4
2 6
3 8
4 10
[10 4 6 8 10]
练习：
生成十个随机数，求和，求平均值
package main
import (
"fmt"
"math/rand"
)
func main() {
var arr [10]int;
num:=0
for i := 0; i < 10; i++ {
// 生成0到99的随机数
arr[i]=rand.Intn(100)
num+=arr[i]
}
fmt.Println(arr)
fmt.Println("数组元素之和为：",num)
fmt.Printf("数组元素平均值为：%.2f\n",float64(num)/10)
}
求两数之和是否存在
package main
import(
"fmt"
)
func Test(a [5]int,target int) (index1 int,index2 int){
for i := 0; i < len(a); i++ {
if a[i]>target{
return -1,-1
}else{
for j := i+1; j < len(a); j++ {
if a[j] == target-a[i] {
return i,j
}
}
}
}
return -1,-1
}
func main() {
b := [5]int{1, 3, 5, 8, 7}
index1,index2 := Test(b,10)
fmt.Println(index1,index2)
}
