Golang 之 List数组

1. 定义数组

var arr1 [5]int   //整型类型
fmt.Println(arr1) //[0 0 0 0 0]
//赋值
arr1 = [5]int{1, 2, 3, 4, 5}
fmt.Println(arr1) //[1 2 3 4 5]
 
var arr2 [6]*int  //整型指针数组
fmt.Println(arr2) //[<nil> <nil> <nil> <nil> <nil> <nil>]
 
var arr3 [2][3]int //二维数组
fmt.Println(arr3)  //[[0 0 0] [0 0 0]]
 
//  使用简短的格式
arr4 := [5]int{2, 4, 6, 8, 10}
fmt.Println(arr4) //[2 4 6 8 10]
 
//其他方式，如果长度的位置是... 表示数组长度是根据后面的数据元素个数来计算
arr5 := [...]int{2, 3, 4, 5, 6, 7}
fmt.Println(arr5, len(arr5)) //[2 3 4 5 6 7]  6
 
//  指定数组的索引来赋值
arr6 := [...]int{5: 10, 7: 23}
//将数组下标为5的元素赋值为10，将数组下标为7的元素赋值为23
//数组长度为8
fmt.Println(arr6, len(arr6)) //[0 0 0 0 0 10 0 23] 8
 
arr7 := [2][3]int{{1, 2, 3}, {4, 5, 6}}
fmt.Println(arr7) //[[1 2 3] [4 5 6]]

2. 数组访问

arr1 := [5]int{2, 4, 6, 8, 10}
fmt.Println(arr1)                 // [2 4 6 8 10]
fmt.Println("length:", len(arr1)) //length: 5
//  arr1[5] = 100  //出错，数组越界
arr1[0] = 99
fmt.Println(arr1) //[99 4 6 8 10]
 
arr2 := [2][3]int{{1, 2, 3}, {4, 5, 6}}
fmt.Println(len(arr2))    //2
fmt.Println(len(arr2[0])) //3
fmt.Println(arr2[1][1])   //5

3. 数组遍历

arr1 := [5]int{2, 4, 6, 8, 10}
for i := 0; i < len(arr1); i++ {
    fmt.Println(arr1[i]) //2 4 6 8 10
}
for i, v := range arr1 {
    fmt.Print(i, "=>", v) // 0=>2,1=>4,2=>6,3=>8,4=>10
}
//  不需要索引的时候，可以将用_代替i
for _, v := range arr1 {
    fmt.Println(v) //2,4,6,8,10
}

4. 数组传参

// 数组作为函数作为参数时，如果是给形参传递数组名，那么就是传值操作，传递的是数组的副本，修改副本的内容，并不会影响实参。
// 要想在函数中对数组的修改作用到实参，可以用数组指针，即->使用指针的形式，将数组的地址传递给函数，并且函数定义时，接收一个指针类型的参数，那么就可以对数组内部进行修改，但是不能修修改数组长度。

package main
 
import "fmt"
 
func Double(arr [5]int) [5]int {
    for i := 0; i < 5; i++ {
        arr[i] *= 2
    }
    return arr
}
 
//接收的指针类型，即数组的地址
//注意这里的形参要写成 arr *[5]int   不要写成arr [5]*int
//arr [5]*int表示的是有五个元素的数组，每个元素是一个指针，即5个指针
//arr *[5]int表示的是一个指针，这一个指针指向一个拥有5个元素的数组，每个元素时一个int型变量
func Triple(arr *[5]int) {
    for i := 0; i < 5; i++ {
        arr[i] *= 3
    }
}
func main() {
    var arr2 [6]*int  //整型指针数组
    fmt.Println(arr2) //[<nil> <nil> <nil> <nil> <nil> <nil>]
    arr := [5]int{1, 2, 3, 4, 5}
    fmt.Println(arr) //[1 2 3 4 5]
 
    arr1 := Double(arr)
    fmt.Println(arr1) //[2 4 6 8 10]
    fmt.Println(arr)  //[1 2 3 4 5]
 
    Triple(&arr)
    fmt.Println(arr) //[3 6 9 12 15]
}

5. 数组比较

// 数组的长度一旦确定，就不能再改变。如果要改变，只能转换为slice，但是用了slice之后，改变的是slice的长度，但是数组长度始终不变。
// 数组长度不同，那么数组就不是同一个类型，不能相互赋值-->参数传递。
// 相同类型的数组可以进行比较，这里的类型不只是数组元素的类型，也包括数组的长度都要相同，才能进行比较。

package main
import "fmt"
func Double(arr [5]int) [5]int {
    for i := 0; i < 5; i++ {
        arr[i] *= 2
    }
    return arr
}
 
func main() {
    arr1 := [5]int{1, 2, 3, 4, 5}
    Double(arr1) //正确   形参和实参都是[5]int类型，注意[5]int是一个类型
 
    arr2 := [6]int{1, 2, 3, 4, 5, 6}
    Double(arr2) //错误，不能将类型为[6]int的实参，赋值给类型为[5]int的形参
    //[5]int和[6]int是两个不同的类型
}