Go语言基础之数组
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)
}
}
}
}