6、Go语言基础之数组
1、Array(数组)
数组是同一种数据类型元素的集合。 在Go语言中，数组从声明时就确定，使用时可以修改数组成员，但是数组大小不可变化。 基本语法：
// 定义一个长度为3元素类型为int类型的数组a
var a [3]int
1.1、数组定义：
var 数组变量名 [元素数量]T
比如：var a [5]int， 数组的长度必须是常量，并且长度是数组类型的一部分。一旦定义，长度不能变。 [5]int和[10]int是不同的类型。
var a [3]int
var b [4]int
a = b //此时a和b是不同的类型，不允许赋值
数组可以通过下标进行访问，下标是从0开始，最后一个元素下标是：len-1，访问越界（下标在合法范围之外），则触发访问越界，会panic。
1.2、数组的初始化
数组的初始化也有很多方式。
方法一
初始化数组时可以使用初始化列表来设置数组元素的值。
package main
import "fmt"
func main() {
var a [5]int //数组会初始化为int类型的零值
var b = [5]int{1, 2, 3} //使用指定的初始值完成初始化
var c = [3]string{"北京", "上海", "广州"} //使用指定的初始值完成初始化
fmt.Println(a) //[0 0 0 0 0]
fmt.Println(b) //[1 2 3 0 0]
fmt.Println(c) //[北京 上海 广州]
}
方法二
上述的方法每次都要确保提供的初始值和数组长度一致，一般情况下可以让编译器根据初始值的个数自行推断数组的长度,然后给变量赋值类型，例如：
package main
import "fmt"
func main() {
var a [3]int
var b = [...]int{1, 2, 3, 4}
var c = [...]string{"北京", "上海", "广州"}
fmt.Println(a) //[0 0 0]
fmt.Println(b) //[1 2 3 4]
fmt.Printf("type of b:%T\n", b) //type of b:[4]int
fmt.Println(c) //[北京 上海 广州]
fmt.Printf("type of c:%T\n", c) //type of c:[3]string
}
//'...' 其实是go的一种语法糖,（糖衣语法）。
//它的第一个用法主要是用于函数有多个不定参数的情况，可以接受多个不确定数量的参数。
//第二个用法是slice可以被打散进行传递。
方法三
我们还可以使用指定索引值的方式来初始化数组，例如:
package main
import "fmt"
func main() {
a := [...]int{3: 18, 5: 99}
fmt.Println(a) // [0 0 0 18 0 99]
fmt.Printf("type of a:%T\n", a) //type of a:[6]int
}
1.3、数组的遍历(两种方法)
方法1：for循环遍历
package main
import "fmt"
func main() {
var a = [...]string{"北京", "上海", "广州"}
for i := 0; i < len(a); i++ {
fmt.Println(a[i])
}
}
>>>
北京
上海
广州
方法2：for range遍历
package main
import "fmt"
func main() {
var a = [...]string{"北京", "上海", "广州"}
for index, value := range a {
fmt.Println(index, value)
}
}
>>>
0 北京
1 上海
2 广州
1.4、多维数组
Go语言是支持多维数组的，以二维数组为例（数组中又嵌套数组）。
二维数组的定义
package main
import "fmt"
func main() {
a := [3][2]int{ //[3]第一层元素数量[2]第二层元素数量
{1, 2},
{3, 4},
{5, 6},
}
fmt.Println(a) //[[1 2] [3 4] [5 6]]
fmt.Println(a[2][1]) //支持索引取值:6
}
注意:多维数组除了第一层其它层都不能使用...
二维数组的遍历
法一：
package main
import "fmt"
func main() {
a := [3][2]int{
{1, 2},
{3, 4},
{5, 6},
}
for _, v1 := range a {
for _, v2 := range v1 {
fmt.Printf("%d\t", v2)
}
fmt.Println()
}
}
>>>
1 2
3 4
5 6
法二：
func main() {
a := [...][2]int{
{1, 2},
{3, 4},
{5, 6},
}
for i := 0; i < len(a); i++ {
for j := 0; j < len(a[i]); j++ {
fmt.Printf("%d\t", a[i][j])
}
fmt.Println()
}
}
>>>
1 2
3 4
5 6
注意： 多维数组只有第一层可以使用...来让编译器推导数组长度。
例如：
//支持
a := [...][2]int{
{1, 2},
{3, 4},
{5, 6},
}
//不支持多维数组的内层使用...
a := [3][...]int{
{1, 2},
{3, 4},
{5, 6},
}
1.5、数组是值类型
数组是值类型，赋值和传参会复制整个数组直接拷贝。因此改变副本的值，不会改变本身的值。
package main
import "fmt"
func testArry1(c [3]int) {
c[0] = 100
fmt.Println(c) //[100 20 30]
}
func testArry2(d [3][2]int) {
d[2][0] = 100
fmt.Println(d) //[[1 2] [3 4] [100 6]]
}
func main() {
a := [3]int{10, 20, 30}
testArry1(a) //在testArry1中修改的是新拷贝的数组c
fmt.Println(a) //[10 20 30]
b := [3][2]int{
{1, 2},
{3, 4},
{5, 6},
}
testArry2(b) //在testArry2中修改的是新拷贝的数组d
fmt.Println(b) //[[1 2] [3 4] [5 6]]
}
注意：**
-
数组支持 “==“、”!=” 操作符，因为内存总是被初始化过的。
-
[n]*T表示指针数组，*[n]T表示数组指针 。package main import "fmt" func main(){ x,y := 1, 2 var arr = [...]int{5:2} //数组指针 var pf *[6]int = &arr //数组指针 pf 的值得到的是一个指向arr 地址的一个指针 //指针数组 pfArr := [...]*int{&x,&y} fmt.Println(pf) fmt.Println(pfArr) //而指针数组 pfArr 则是一个数组内的元素全是指针类型 } >>> &[0 0 0 0 0 2] [0xc0000a0068 0xc0000a0080]
练习题
1、求数组[1, 3, 5, 7, 8]所有元素的和
package main
import "fmt"
func main() {
a := [...]int{1, 3, 5, 7, 8}
sum := 0
for _, v := range a {
sum += v
}
fmt.Println(sum)
}
>>>24
2、找出数组中和为指定值的两个元素的下标，比如从数组[1, 3, 5, 7, 8]中找出和为8的两个元素的下标分别为(0,3)和(1,2)。
法一：
func main() {
a := [...]int{1, 3, 5, 7, 8}
for index1, value1 := range a {
total := 8 - value1
for index2, value2 := range a {
if value2 == total {
fmt.Printf("和为8的两个元素的下标为:(%d %d)\n", index1, index2)
}
}
}
}
>>>
和为8的两个元素的下标为:(0 3)
和为8的两个元素的下标为:(1 2)
和为8的两个元素的下标为:(2 1)
和为8的两个元素的下标为:(3 0)
法二：
func main() {
a := [...]int{1, 3, 5, 7, 8}
for i := 0; i < len(a); i++ {
for j := i + 1; j < len(a); j++ {
if a[i]+a[j] == 8 {
fmt.Printf("和为8的两个元素的下标为:(%d, %d)\n", i, j)
}
}
}
}
>>>
和为8的两个元素的下标为:(0, 3)
和为8的两个元素的下标为:(1, 2)
