【Go】数组

数组Array

重点：

数组是值类型

注意点:

    1. 数组：是同一种数据类型的固定长度的序列。2. 数组定义：var a [len]int，比如：var a [5]int，数组长度必须是常量，且是类型的组成部分。一旦定义，长度不能变。3. 长度是数组类型的一部分，因此，var a[5] int和var a[10]int是不同的类型。4. 数组可以通过下标进行访问，下标是从0开始，最后一个元素下标是：len-1for i := 0; i < len(a); i++ {}for index, v := range a {}5. 访问越界，如果下标在数组合法范围之外，则触发访问越界，会panic6. 数组是值类型，赋值和传参会复制整个数组，而不是指针。因此改变副本的值，不会改变本身的值。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 stringage  uint8}{{"user1", 10}, // 可省略元素类型。{"user2", 20}, // 别忘了最后一行的逗号。}

package mainimport ("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 stringage  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]intvar 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 mainimport("fmt"
)
// 全局var arr0 [5][3]int // 定义了就有默认值0var 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 mainimport ("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 mainimport "fmt"func printArr(arr *[5]int) {fmt.Println(arr)arr[0] = 10for i, v := range arr {fmt.Println(i, v)}
}func main() {var arr1 [5]intprintArr(&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 mainimport ("fmt""math/rand"
)func main() {var arr [10]int;num:=0for 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 mainimport("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)
}