Go语言笔记--数组

1.数组Array

1）定义数组的格式：var <varName> [n] <type>, n >=0

2）数组长度也是类型的一部分，因此具有不同长度的数组为不同类型

3）注意区分指向数组的指针和指针数组

4）数组在Go中为数值类型

5）数组直接可以使用==或者!=进行比较，但是不可以使用<或者>

6）可以使用new来创建数组，此方法返回一个指向数组的指针

7）Go支持多维数组

定义数组的几种形式代码实例：

package main


import (
    "fmt"
)


func main() {
    fmt.Println("定义与初始化")
    //直接定义不赋初值，默认为0
    var arr1 [5]int
    //直接赋值，只有3个元素
    arr2 := [3]int{1, 2, 3}
    //三个点代表任意多个元素
    arr3 := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
    //定义一个4行5列的二维数组
    var grid [4][5]int


    fmt.Println(arr1, arr2, arr3)
    //二维数组
    fmt.Println(grid)
}

输出：
API server listening at: 127.0.0.1:33951
定义与初始化
[0 0 0 0 0] [1 2 3] [1 2 3 4 5 6 7 8 9]
[[0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0]]
           

2.遍历

数组的遍历，代码中给出了三种不同的方法获取，前两种是获取下标在得到元素，第三种是直接得到元素

package main


import (
    "fmt"
)


func main() {
    //数组遍历
    arr := [...]int{1, 2, 3, 4}


    fmt.Println("第一种方法")
    for i := 0; i < len(arr); i++ {
        fmt.Println(arr[i])
    }


    //使用range遍历
    fmt.Println("第二种方法")
    for i := range arr {
        fmt.Println(arr[i])
    }


    //使用range遍历，不但可以获取下标，还可以直接获取到值
    fmt.Println("第三种方法")
    for i, v := range arr {
        fmt.Println(i, v)
    }
}

输出：
API server listening at: 127.0.0.1:27912
第一种方法
1
2
3
4
第二种方法
1
2
3
4
第三种方法
0 1
1 2
2 3
3 4
           

3.值类型

1）错误代码实例

package main


import (
    "fmt"
)


func printArray(arr [5]int) {
    for i, v := range arr {
        fmt.Println(i, v)
    }
}


func main() {
    var arr1 [5]int
    arr2 := [3]int{1, 2, 3}
    arr3 := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
    arr4 := [...]int{1, 2, 3, 4, 5}
    printArray(arr1)
    printArray(arr2)
    printArray(arr3)
    printArray(arr4)
}
           

上面的代码在编译的时候会出错，提示如下：

arry.go:19: cannot use arr2 (type [3]int) as type [5]int in argument to printArray

arry.go:20: cannot use arr3 (type [9]int) as type [5]int in argument to printArray

这是什么错误？这个错误就是printArray参数是一个长度为5的数组但是arr2，和arr3的长度都不是5，因此不符合，所以会报错，如果没有这两个的话则可以编译通过并且可以运行。

2）局部修改数值实例

package main


import (
    "fmt"
)


func printArray(arr [5]int) {
    arr[0] = 100
    for i, v := range arr {
        fmt.Println(i, v)
    }
}


func main() {
    var arr1 [5]int
    arr2 := [...]int{1, 2, 3, 4, 5}
    fmt.Println("print arr1")
    printArray(arr1)
    fmt.Println("print arr2")
    printArray(arr2)
    fmt.Println(arr1, arr2)
}

输出：
API server listening at: 127.0.0.1:36105
print arr1
0 100
1 0
2 0
3 0
4 0
print arr2
0 100
1 2
2 3
3 4
4 5
[0 0 0 0 0] [1 2 3 4 5]
           

可以看到两个数组的0元素在printArray里面都被修改为了100但是回到主函数打印还是原来的值，因此可以理解，这个数组的参数转递是进行的值传递也就是拷贝操作，并不是传递的地址。

上述例子如果换成指针效果如何，看下代码实例

package main


import (
    "fmt"
)


func printArray(arr *[5]int) {
    arr[0] = 100
    for i, v := range arr {
        fmt.Println(i, v)
    }
}


func main() {
    var arr1 [5]int
    arr2 := [...]int{1, 2, 3, 4, 5}
    fmt.Println("print arr1")
    printArray(&arr1)
    fmt.Println("print arr2")
    printArray(&arr2)
    fmt.Println(arr1, arr2)
}

输出：
API server listening at: 127.0.0.1:45480
print arr1
0 100
1 0
2 0
3 0
4 0
print arr2
0 100
1 2
2 3
3 4
4 5
[100 0 0 0 0] [100 2 3 4 5]
           

这次可以看到，数组中的0元素被修改了，这也说明go语言的数组为值类型

综合实例:

package main


import "fmt"


func main() {
    fmt.Println("冒泡排序")
    a := [...]int{5, 2, 6, 3, 9}
    fmt.Println(a)
    num := len(a)
    for i := 0; i < num; i++ {
        for j := i + 1; j < num; j++ {
            if a[i] < a[j] {
                temp := a[i]
                a[i] = a[j]
                a[j] = temp
            }
        }
    }
    fmt.Println(a)
}
输出：
API server listening at: 127.0.0.1:28022
冒泡排序
[5 2 6 3 9]
[9 6 5 3 2]