Go语言

Array

数组是同一种数据类型元素的集合。 在Go语言中，数组从声明时就确定，使用时可以修改数组成员，但是数组大小不可变化。

1.数组 在定义阶段，长度和类型就固定了，以后不能更改
2.长度也是数组类型的一部分

数组定义：

var 数组变量名 [元素数量]T

// 定义一个长度为3元素类型为int的数组a
var a [3]int

 注意:

package main

import "fmt"

func main()  {
    var a [3]int
    var b [5]int
    fmt.Println(a, b)  // [0 0 0] [0 0 0 0 0]

　　　a = b //不可以这样做，因为此时a和b是不同的类型

　　// 注意: a与都是b数组, 单两者是不同类型的数组,因为长度不同 
　　// 数组的类型 = 数组内数据的类型 + 定义长度  
}

数组的初始化

•  方式一

package main

import "fmt"

func main()  {
    // var a1 [3]int = [3]int{1,2,3}
    var a1 = [3]int{1,2,3}
    var a2 = [5]int{1,2,3}
    var s1 = [3]string{"上海"}
    fmt.Println(a1)  // [1 2 3]
    fmt.Println(a2)  // [1 2 3 0 0] int类型数组内的数据数量小于定义数量时,默认用零补位
    fmt.Println(s1)  // [上海  ] string类型数组内的数据数量小于定义数量时,默认用空格补位
}

•  方式二

按照上面的方法每次都要确保提供的初始值和数组长度一致，一般情况下我们可以让编译器根据初始值的个数自行推断数组的长度

package main

import "fmt"

func main()  {
　　// 自动获取数组长度
    var a3 = [...]int{1,2,3,4,5}
    var s2 = [...]string{"上海", "北京"}
    fmt.Println(a3)  // [1 2 3 4 5]
    fmt.Println(s2)  // [上海 北京]
}

•  方式三

我们还可以使用指定索引值的方式来初始化数组

package main

import "fmt"

func main()  {
    var a4 [5]int
    a4 = [5]int{4:1}  // 索引4的数字为1其余为0
    fmt.Println(a4)  // [0 0 0 0 1]

　　　fmt.Printf("a4的类型是:%T", a4)  // a4的类型是:[5]int

}

 数组的取值

Go语言的数组可按索引取值

package main

import "fmt"

func main()  {
    var s3 = [...]string{"上海", "北京"}
    fmt.Println(s3[1])  // 北京
    fmt.Printf("%T 
", s3[1])  // string
　　 s4 := s3[0]
    fmt.Println(s4)  // 上海
}

 数组的遍历

package main

import "fmt"

func main()  {
    var s5 = [3]int{1,2,3}
    for i := 0; i < len(s5); i++{
        fmt.Print(s5[i]) // 123
    }

    for i, v := range s5{
        fmt.Printf("索引:%d 值:%d 
", i, v)  // 索引:0 值:1 ...
    }
}

练习 

• 求数组内元素的和

package main

import "fmt"

func main()  {
    var a5 = [...]int{1,3,5}
    value := 0
    for index := 0; index < len(a5); index++ {
        value = value + a5[index]
    }
    fmt.Println(value)  // 9

    var v = 0
    for _, i := range a5{
        v = v + i
    }
    fmt.Println(value)  // 9
}

• 查找[1,3,5,7,8]数组内和为8的元素组合 

package main

import "fmt"

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

 多维(层)数组

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

 多维数组的定义

package main

import "fmt"

func main()  {
　　// 初始化方式一
   var a9 [3][2]int
    a9 = [3][2]int{
        [2]int{1,2},
        [2]int{3,4},
    }
    fmt.Println(a8)  // [1 2 3]
    fmt.Println(a9)  // [[1 2] [3 4] [0 0]]
    // 初始化方式二
    var a10 = [...][2]int{
        {6,7},
        {8,9},
        {0,1},
    }
    fmt.Println(a10)  // [[6 7] [8 9] [0 1]]
    // 注意:多维数组除了第一次可以用[...], 其他层都不能用[...]
}

多维数组的取值

package main

import "fmt"

func main()  {
    var a10 = [...][2]int{
        {6,7},
        {8,9},
        {0,1},
    }
    fmt.Println(a10[1][0])  // 8
}

多维数组的遍历

package main

import "fmt"

func main()  {
    var a10 = [...][2]int{
        {6,7},
        {8,9},
        {0,1},
    }
    // 方式一
    for i := 0; i < len(a10); i++ {
        fmt.Print(a10[i])  // [6 7][8 9][0 1]
    }
    // 方式二
    for _, i := range a10{
        fmt.Print(i)  // [6 7][8 9][0 1]
    }
}

数组是值类型

数组是值类型，赋值和传参会复制整个数组。因此改变副本的值，不会改变本身的值。

package main

import "fmt"

func main()  {
    a11 := [2]int{1,2}
    a12 := a11  // 在内存中为变量a12开辟了内存空间,存入数组[1 2]
    a11[0] = 5  // 改变的是变量a11在内存中数组[1,2]里的值
    fmt.Println(a11)  // [5 2]
    fmt.Println(a12)  // [1 2]
}

 摘自