Go基础编程：数组(Array)

原文链接 ：http://oldchen.iwulai.com/index.php/2019/01/10/go%E5%9F%BA%E7%A1%80%E7%BC%96%E7%A8%8B%EF%BC%9A%E6%95%B0%E7%BB%84array/

go语言数据类型-数组（array）

数组（Array）是一段固定长度的连续内存区域。

1. go语言数组简介

数组就是指一系列同一类型数据的集合。数组中包含的每个数据被称为数组元素（element），一个数组包含的元素个数被称为数组的长度。

在Go语言中，数组是一个值类型（value type）。

在Go语言中，数组从声明时就确定，使用时可以修改数组成员，但是数组大小不可变化。

2. 数组定义 

定义方式如下：

var arr [n]type
var 数组变量名 [元素数量]数据类型

其中：

• 数组变量名：(arr)数组声明及使用时的变量名。
• 元素数量：(n)数组的元素数量。可以是一个表达式，但最终通过编译期计算的结果必须是整型数值。也就是说，元素数量不能含有到运行时才能确认大小的数值。
• 数据类型：(type )type 可以是任意基本类型，包括 type 为数组本身。但类型为数组本身时，可以实现多维数组。

在Go语言中，数组长度在定义后就不可更改，在声明时长度可以为一个常量或者一个常量表达式（常量表达式是指在编译期即可计算结果的表达式）。数组的长度是该数组类型的一个内置常量，可以用Go语言的内置函数len()来获取。

arrLength := len(arr)

3. 数组声明 

常规声明方法

var a [5]byte        //长度为5的数组，每个元素为一个字节
var b [2*N] struct { x, y int5 } //复杂类型数组
var c [5]*int        // 指针数组
var d [2][3]int      //二维数组
var e [2][3][4]int   //等同于[2]([3]([4]int))

package main
import "fmt"
func main() {
    var team [3]string//将 team 声明为包含 3 个元素的字符串数组。
    team[0] = "hello"//赋值
    team[1] = "word"
    team[2] = "!!!"
    fmt.Println(team)//打印      
}

输出： [hello word !!!]

注意： 
指针数组：指的是这个数组存的是指针 

package main
import "fmt"
func main() {
    a, b := 1, 2
    p := [2]*int{&a, &b}
    fmt.Println(p)    
}

输出：[0xc00004e058 0xc00004e070]

数组指针：指的是指向数组的指针 

package main
import "fmt"
func main() {
    a := [5]int{3, 1, 5, 6, 3}
    var p *[5]int
    p = &a
    fmt.Println(p)       
}

输出：&[3 1 5 6 3]

4. 数组初始化 

4.1 先声明再初始化

a = {'1','2','3'}
d = {{1,2,3},{4,5,6}} 

4.2 直接声明并初始化

a := [3]byte{'1', '2', '3'} //声明并初始化一个长度为3的byte数组
a := [...]byte{'1', '2', '3'} //可以省略长度而采用`...`的方式，Go会自动根据元素个数来计算长度
d := [2][3]int{[3]int{1,2,3},[3]int{4,5,6}}
d := [2][3]int{{1,2,3},{4,5,6}} //如果内部的元素和外部的一样，那么上面的声明可以简化，直接忽略内部的类型

例如：

package main
import "fmt"
func main(){
    var arr1 [5]int
    arr2 := [5]int{1, 2, 3, 4, 5}   //指定长度为5，并赋5个初始值
    arr3 := [5]int{1, 2, 3}         //指定长度为5，对前3个元素进行赋值，其他元素为零值
    arr4 := [5]int{4: 1}            //指定长度为5，对第5个元素赋值
    arr5 := [...]int{1, 2, 3, 4, 5} //不指定长度，对数组赋以5个值
    arr6 := [...]int{8: 1}          //不指定长度，对第9个元素（下标为8）赋值1
    fmt.Println(arr1, arr2, arr3, arr4, arr5, arr6)
}

输出结果为：

5 .数组元素访问 

可以使用数组下标来访问数组中的元素。数组下标从0开始，len(arr)-1则表示最后一个元素的下标 
5.1 计算数组长度 
通过go语言内置函数len 

package main
import "fmt"
func main(){
   arr := [...]int {9: 1}
   fmt.Println(arr)
   fmt.Println(len(arr))
}

输出结果为：

5.2 普通访问方式

语法：

for i := 0; i < len(arr); i++ { 
    fmt.Println(i, arr[i]) 
}

示例： 

package main
import "fmt"
func main(){
   arr := [...]int {9: 1}
   for i := 0; i < len(arr); i++ {
       fmt.Println(i, arr[i])
    }
}

打印结果如下：

实例（冒泡排序）

package main
import "fmt"
func main(){
    arr := [5]int{5, 3, 2, 6, 8}//定义一个arr数组并赋值
    fmt.Println(arr)//输出原数组
    length := len(arr)//统计数组长度
    for i := 1; i < length; i++ {
        for j := 0; j < length-i; j++ {
            if arr[j] > arr[j+1] {//判断大小
                temp := arr[j]//定义一个中间数组来接受值
                arr[j] = arr[j+1]//交换位置
                arr[j+1] = temp
            }
        }
    }
    fmt.Println(arr)//输出新数组
}

输出：

5.3 通过range访问

语法：

for i, v := range arr {
    fmt.Println(i, v)
}

range具有两个返回值，第一个返回值i是元素的数组下标，第二个返回值v是元素的值。 
例如：

package main
import "fmt"
func main(){
    arr := [5]int {1, 2, 3, 4, 5}
    for i, v := range(arr) {
        fmt.Printf("arr[%d]=%d\n", i, v)
    }
}

打印结果如下：

6 数组值传递 

例如：

package main
import "fmt"
func modify(arr [5]int){
    arr[0] = 10
    fmt.Println("In modify(), arr values:", arr)
}

func main(){
    arr := [5]int{1, 2, 3, 4, 5}
    modify(arr)
    fmt.Println("In main(), arr values:", arr)
}

输出结果为：