Go语言基础之数组

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› Go›Go教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

Array数组

数组是同一种数据类型元素的集合.

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

package main

import "fmt"

func main() {
	var Array [3]int 		// 声明 数组为长度为3 元素必须是int类型 
	Array = [3]int{1,2,3}  // 初始化数组
	fmt.Println(Array)    // 输出
}

数组定义

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

比如:var a [5]int,数组的长度必须是常量,并切长度是数组类型的一部分.

一旦定义,长度不能变.[5]int 和 [10]int是不同的类型.

var a[3]int
var b[4]int
a = b

数组可以通过下标进行访问,下标是从0开始,最后一个元素下标:len-1,访问越界(下标在合法范围之外),则触发访问越界,会panic

package main

import "fmt"

func main() {
	var Array [3]int 		// 声明 数组为长度为3 元素必须是int类型
	Array = [3]int{1,2,3}  // 初始化数组
	fmt.Println(Array[0])
	fmt.Println(Array[1])
	fmt.Println(Array[2])
	

	// fmt.Println(Array[3])  3 就超出异常
	//# command-line-arguments
	//./print.go:13:19: invalid array index 3 (out of bounds for 3-element array)
}

数组的初始化

数组的初始化也有很多方式.

多种初始化方式

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

package main

import "fmt"

func main() {
	//  先声明 后初始化
	var testArray1 [3]int
	testArray1 = [3]int{1,2}
	fmt.Println(testArray1)

	// 直接声明初始化
	var testArray2 = [3]int{1,2,3}
	fmt.Println(testArray2)

	// := 简洁方式
	testArray3 := [6]string{"1","2","3"}
	fmt.Println(testArray3)

}

结果:

[1 2 0]
[1 2 3]
[1 2 3   ]

Process finished with exit code 0

看结果如果没有满足长度 int 类型或默认0 strings 会默认为 ""

`...` 自动化推导数组长度

现在有个需求.如果数组的长度太长,那我们数起来就太麻烦, a[...]int{1,2,3,4} 编译器会根据初始值的个数自行推断数组的长度

代码:

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var TextArray = [...]int{1,2,3,4,5,6,7}
	fmt.Println(len(TextArray))            // 数组的长度
	fmt.Println(TextArray)    	           // 输出
	fmt.Println(reflect.TypeOf(TextArray)) //类型
}

结果:

7
[1 2 3 4 5 6 7]
[7]int

Process finished with exit code 0

数组的遍历

遍历数组a有以下两种方法:

package main

import "fmt"

func main() {
	var a = [...]string{"北京","上海","深圳"}
	
	//方法: for 循环
	for i:=0;i<len(a);i++{
		fmt.Println(a[i])
	}
	
	// for range
	for i,v:=range a{
		fmt.Println(i,v)
	}
}

多维数组

Go语言是支持多维数组的,我们这里以二维数组为例(数组中嵌套数组)

二维数组定义

package main
import "fmt"
func main() {
	// 长度为3的二维数组嵌套数组长度为2
	a := [3][2]string{
		{"1","1"},
		{"2","2"},
		{"3","3"},
	}
	//
	fmt.Println(a)
	fmt.Println(a[1][1])
}

结果:

[[1 1] [2 2] [3 3]]
2

Process finished with exit code 0

二维数组的遍历

package main

import "fmt"

func main() {
	// 长度为3的二维数组嵌套数组长度为2
	a := [3][2]string{
		{"1","1"},
		{"2","2"},
		{"3","3"},
	}
	// 二维数组的遍历
	for _,v1:=range a{
		for _,v2:=range v1{
			fmt.Println(v2)
		}
	}
}

结果:

1       1       
2       2       
3       3       

Process finished with exit code 0

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

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

数值是值类型

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

package main

import "fmt"

func modifyArray(x [3]int)  {
	x[0] = 100
}

func modifyArray2(x [3][2]int)  {
	x[2][0] = 100
}

func main() {
	a := [3]int{10, 20, 30}
	modifyArray(a) //在modify中修改的是a的副本x
	fmt.Println(a) //[10 20 30]
	b := [3][2]int{
		{1, 1},
		{1, 1},
		{1, 1},
	}
	modifyArray2(b) //在modify中修改的是b的副本x
	fmt.Println(b)  //[[1 1] [1 1] [1 1]]

}

注意:

数组支持 ==、!=操作符,因为内存总数是被初始化过
[n]*T表示指针数组,*[n]T表示数组执政

练习题

1.求出数组[1,3,5,7,8]所有元素的和

package main

import "fmt"


func main() {
	
	var Array = [...]int{1,3,5,7,8}
	var num = 0
	for _,v1:=range Array{
		num += v1
	}
	fmt.Println(num)

}

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

package main
import "fmt"
func main() {
	// 找到 8和的下标
	var Array = [...]int{1,3,5,7,8}
	for i1,v1:=range Array{
		for i2,v2:=range Array[i1+1:]{
			var ret = v1 + v2
			if ret == 8{
				fmt.Println(i1,i2)
			}
		}
	}
}