Go语言基础之数组

1 数组概述

　　数组是由一个固定长度、相同类型元素组成的连续序列，一个数组可以由零个或多个元素组成。数组存储的类型可以是内置类型，如整型或者字符串，也可以是某种结构类型。由于数组只能存储固定长度的相同类型的数据，所以在Go语言中很少直接使用。

　　下图是数组的内部实现，其中方框内的代表数组里的元素，数组中的元素存储在一段连续的内存空间中，且每个元素可以用一个唯一的索引（下标）来访问，这样就可以以固定的速度索引数组中的任意数据，速度非常快。

图1 数组的内部实现

　　数组的下标是从0开始的，最后一个元素的下标是len-1，也就是数组的长度（元素个数）减1，如果访下标在合法范围之外，则触发访问越界，会panic。

2 数组声明和初始化

2.1 数组声明

var 数量变量名 [元素个数]Type

　　比如： var a [8]int ，数组的长度必须是常量，并且长度是数组类型的一部分，长度是数组的一个属性，一旦定义数组的长度不能变。于是  [5]int  和  [8]int  不是同一个类型。

var a [5]int
var b [8]int
a = b    //不能这样使用，因为a和b不是同一个类型

2.2 数组初始化

　　数组的初始化有很多种方式：

方式一：

　　使用初始化列表来设置数组元素的值

 func main() {
    var array1 [3]int    //编译器会自动为数组初始化int类型的默认0值
    var numArray = [3]int{1, 2}        //指定初始值完成初始化    
    var cityArray = [3]string{"西安", "成都", "上海"}
    fmt.Println(array1)　　　　　　 //[0 0 0]
    fmt.Println(numArray)         //[1 2]
    fmt.Println(cityArray)        //[西安 成都 上海]
}

方式二：

　　方式一的弊端：每次声明的数组为指定的长度的数组，而后要确保提供的初始值的个数和数组长度一致。那么方式二可以让编译器根据初始值的个数自行推断数组的长度，也就是自动计算声明数组的长度。代码如下：

func main() {
    var testArray [3]int
    var numArray = [...]int{1, 2}
    var cityArray = [...]string{"西安", "上海"}

    fmt.Println(testArray)                           //[0 0 0]
    fmt.Println(numArray)                            //[1 2]
    fmt.Printf("numArray的类型是：%T
", numArray)     //numArray的类型是：[2]int
    fmt.Println(cityArray)                           //[西安 上海]
    fmt.Printf("cityArray的类型是：%T
", cityArray)   //cityArray的类型是：[2]string
}

方式三：

　　声明数组并指定特定元素的值

func main() {
    a := [...]int{1: 1, 10: 10}
    fmt.Println(a)                      //[0 1 0 0 0 0 0 0 0 0 10]
    fmt.Printf("a的类型是：%T", a)        //a的类型是：[11]int
}

2 数组的遍历

2.1 for循环遍历

func main() {
    //for循环遍历
    var cityArray = [...]string{"北京", "上海", "西安"}

    for i := 0; i < len(cityArray); i++ {
        fmt.Printf("cityArray[%d]=%v
", i, cityArray[i])
    }
}

2.2 for range遍历

　　这是Go语言一种独有的结构，可以用来遍历访问数组的元素。

for-range的基本语法

for index, value := range array01 {
    ...
}

说明：

1. 第一个返回值index是数组的下标
2. 第二个value是在该下标位置的值
3. index和value仅在for循环内部可见的局部变量
4. 遍历数组元素的时候，如果不想使用下标index，可以直接把下标index标为下划线_
5. index和value的名称不是固定的，即程序员可以自行指定，一般命名为index和value

for-range的案例

func main() {
    //演示for-range遍历数组
    heroes := [...]string{"钢铁侠", "蜘蛛侠", "绿巨人"}

    for i, v := range heroes {
        fmt.Printf("i=%v v=%v
", i, v)
        fmt.Printf("heroes[%d]=%v
", i, heroes[i])
    }

    for _, v := range heroes {
        fmt.Printf("元素的值=%v
", v)
    }
}

3 多维数组

　　Go语言是支持多维数组的，这里以二维数组为例（数组中有嵌套数组）

3.1 二维数组的定义

func main() {
    a := [3][2]string{
        {"北京", "上海"},
        {"广州", "深圳"},
        {"成都", "重庆"},
    }
    fmt.Println(a) //[[北京 上海] [广州 深圳] [成都 重庆]]
    fmt.Println(a[2][1]) //支持索引取值:重庆
}

3.2 二维数组的遍历

func main() {
    a := [3][2]string{
        {"北京", "上海"},
        {"广州", "深圳"},
        {"成都", "重庆"},
    }
    for _, v1 := range a {
        for _, v2 := range v1 {
            fmt.Printf("%s	", v2)
        }
        fmt.Println()
    }
}

// 输出
// 北京    上海    
// 广州    深圳    
// 成都    重庆

　　注意：多维数组只有第一层可以使用 ... 来让编译器推导数组长度，例如：

//支持的写法
a := [...][2]string{
    {"北京", "上海"},
    {"广州", "深圳"},
    {"成都", "重庆"},
}
//不支持多维数组的内层使用...
b := [3][...]string{
    {"北京", "上海"},
    {"广州", "深圳"},
    {"成都", "重庆"},
}

4 数组使用的注意事项和细节总结

• 数组是多个相同类型数据的组和，一个数组一旦声明/定义了，其长度是固定的，不能动态变化
• 数组中的元素可以是任何数据类型，包括值类型和引用类型，但不能混用
• 数组创建后，如果没有赋值，有默认值（零值）

func main() {
    // 1. 数值（整数系列，浮点数系列）：0
    // 2. 字符串：""
    // 3. 布尔类型：false

    var arr01 [3]float32
    var arr02 [3]string
    var arr03 [3]bool
    fmt.Printf("arr01=%v arr02=%v arr03=%v", arr01, arr02, arr03)
}

• 用数组的步骤：声明数组并开辟空间；给数组各个元素赋值（默认零值）；使用数组

• 数组的小标是从0开始的

var arr [3]string
var index int = 3
arr[index] = "tom"    //因为下标是0-2，因此arr[3]就越界

• 数组下标必须在指定范围内使用，否则报panic；数组越界
• Go的数组属值类型，在默认情况下是值传递，因此会进行值拷贝，数组间不会相互影响

//修改数组第一个下标对应的值
func test(arr [3]int) {
    arr[0] = 0
    fmt.Println("test arr:", arr)
}

func main() {
    arr := [3]int{10, 20, 30}
    test(arr)
    fmt.Println("main arr:", arr)
}

• 如果想在其它函数中，去修改原来的数组，可以使用引用指针（指针方式）

//修改数组第一个下标对应的值
func test(arr *[3]int) {
    (*arr)[0] = 0
    // arr[0] = 0
    fmt.Println("test arr:", *arr)
}

func main() {
    arr := [3]int{10, 20, 30}
    test(&arr)
    fmt.Println("main arr:", arr)
}

• 长度是数组类型的一部分，在传递函数参数时，需要考虑数组的长度，看下面案例

     

• 数组支持 “==“、”!=” 操作符，因为内存总是被初始化过的。
• [n]*T表示指针数组，*[n]T表示数组指针 。

5 数组的应用案例

　　1、创建一个byte类型的26个元素的数组，分别放置'A'-'Z'。使用for循环访问所有元素并打印出来。

func main() {
    // 思路
    // 1. 声明一个数组 var myChars [26]byte
    // 2. 使用for循环，利用字符可以进行运算的特点来赋值
    // 3. for循环打印
    var myChars [26]byte

    for i := 0; i < 26; i++ {
        myChars[i] = 'A' + byte(i) // 需要将i转换为byte类型
    }

    for i := range myChars {
        fmt.Printf("%c", myChars[i])
    }
}

　　2、请求出一个数组的最大值，并得到对应的下标

func main() {
    // 思路
    // 1. 随机生成5个随机数，将其存储在intArr数组中
    // 2. 假设下标为0的数最大
    // 3. 然后依次向后比较，如果发现更大，则交换
    var intArr [5]int
    len := len(intArr)
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < len; i++ {
        intArr[i] = rand.Intn(100)
    }

    maxVal := intArr[0]
    maxValIndex := 0

    for i := 1; i < len; i++ {
        if maxVal < intArr[i] {
            maxVal = intArr[i]
            maxValIndex = i
        }
    }
    fmt.Println("intArr:", intArr)
    fmt.Printf("maxVal=%v maxValIndex=%v", maxVal, maxValIndex)
}

　　3、请求出一个数组的和和平均值。for-range

func main() {
    var intArr [5]int
    len := len(intArr)

    rand.Seed(time.Now().UnixNano())
    for i := 0; i < len; i++ {
        intArr[i] = rand.Intn(100)
    }

    fmt.Println("intArr:", intArr)

    sum := 0
    for _, val := range intArr {
        sum += val
    }

    // 如何让平均值保留到小数
    fmt.Printf("sum=%v 平均值=%v
", sum, float64(sum)/float64(len))
}

　　4、随机生成五个数，并将其反转打印

func main() {
    // 思路
    // 1. 随机生成五个数，rand.Intn() 函数
    // 2. 将随机数放入一个int数组内
    // 3. 反转打印，交换的次数是 len /2 ,倒数第一个和第一个元素交换
    var nums [5]int
    len := len(nums)

    // 为了每次生成的随机数不一样，需要给一个seed值
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < len; i++ {
        nums[i] = rand.Intn(100) // 0 <= n < 100
    }

    fmt.Println("交换前：", nums)

    temp := 0
    for i := 0; i < len/2; i++ {
        temp = nums[len-1-i]
        nums[len-1-i] = nums[i]
        nums[i] = temp
    }
    fmt.Println("交换后：", nums)
}

　　5、找出数组中和为指定值得两个元素的下标，比如从数组[1, 3, 5, 7, 8]中找出和为8的两个元素的下标分别为(0, 3)和(1, 2)。

func main() {
    var nums = [...]int{1, 3, 5, 7, 8}
    for i := 0; i < len(nums); i++ {
        for j := i + 1; j < len(nums); j++ {
            if nums[i]+nums[j] == 8 {
                fmt.Printf("(%d, %d)
", i, j)
            }
        }
    }
}