Go 语言数组
Go 语言数组
引言
数组是相同数据类型的一组数据的集合,数组一旦定义长度不能修改,数组可以通过下标(或者叫索引)来访问元素。
相对于去声明 number0, number1, …, number99 的变量,使用数组形式 numbers[0], numbers[1] …, numbers[99] 更加方便且易于扩展。
数组元素可以通过索引(位置)来读取(或者修改),索引从0 开始,第一个元素索引为 0,第二个索引为1,以此类推。
一、数组的定义
1. 语法
var variable_name [SIZE] variable_type
variable_name:数组的名称
SIZE:数组长度,必须是常量
variable_type:数组保存元素的类型
2. 示例
package main
import “fmt”
func main() {
var a [3]int //定义一个int类型的数组a,长度是3
var b [2]string //定义一个字符串类型的数组b,长度是2
fmt.Printf("a: %T\\n", a) //使用%T来输出类型
fmt.Printf("b: %T\\n", b)
fmt.Printf("a: %v\\n", a)
fmt.Printf("b: %v\\n", b)
}
//输出结果如下,可以看到没初始化的值,int是0,而字符串则是空的字符串
a: [3]int
b: [2]string
a: [0 0 0]
b: [ ]
从上面运行的结果中可以看出来,数组和长度和元素类型共同组成了数组的类型
二、数组的初始化
初始化,就是给数组的元素赋值,没有初始化的数组,默认元素值都是零值
,布尔类型是false
,字符串是空字符串
。
1. 未初始化的数组
package main
import “fmt”
func main() {
var a [2]bool
var b [2]int
var c [3]string
var d [3]float32
fmt.Printf("a: %v\\n", a)
fmt.Printf("b: %v\\n", b)
fmt.Printf("c: %v\\n", c)
fmt.Printf("d: %v\\n", d)
}
//输出结果如下
a: [false false]
b: [0 0]
c: [ ]
d: [0 0 0]
2. 使用初始化列表
package main
import “fmt”
func main() {
var a = [3]int{1, 2, 3}
var b = [2]string{“hello world”}
var c = [2]bool{true, false}
a1 := \[2\]int{1, 2} //类型推断
fmt.Printf("a: %v\\n", a)
fmt.Printf("b: %v\\n", b)
fmt.Printf("c: %v\\n", c)
fmt.Printf("a1: %v\\n", a1)
}
//输出结果如下
a: [1 2 3]
b: [hello world ]
c: [true false]
a1: [1 2]
使用初始化列表,就是将值写在大括号
里面
3. 省略数组长度
如果数组长度不确定,可以使用 ...
代替数组的长度,编译器会根据元素个数自行推断数组的长度
package main
import “fmt”
func main() {
var a = […]int{1, 2, 3, 4, 5}
var b = […]string{“hello”, “world”, “hello”, “go”}
var c = […]bool{true, false}
a1 := \[...\]int{1, 2} //类型推断
fmt.Printf("a: %v\\n", a)
fmt.Printf("b: %v\\n", b)
fmt.Printf("c: %v\\n", c)
fmt.Printf("a1: %v\\n", a1)
}
//输出结果如下
a: [1 2 3 4 5]
b: [hello world hello go]
c: [true false]
a1: [1 2]
4. 指定索引值的方式来初始化
可以通过指定所有方式来初始化,未指定的所有默认值为零值
package main
import “fmt”
func main() {
var a = […]int{0: 1, 2: 2}
var b = […]string{1: “hello”, 2: “go”}
var c = […]bool{2: true, 5: false}
a1 := \[...\]int{1, 2} //类型推断
fmt.Printf("a: %v\\n", a)
fmt.Printf("b: %v\\n", b)
fmt.Printf("c: %v\\n", c)
fmt.Printf("a1: %v\\n", a1)
}
//输出结果如下
a: [1 0 2]
b: [ hello go]
c: [false false true false false false]
a1: [1 2]
总结
初始化数组中{}中的元素个数不能大于[]中的数字。
如果忽略[]中的数字不设置数组大小,Go 语言会根据元素的个数来设置数组的大小:
5. 访问数组元素
数组元素可以通过索引(位置)来读取。
格式为数组名后加中括号,中括号中为索引的值。数组的最大下标为数组长度-1,大于这个下标会发生数组越界。
示例
package main
import “fmt”
func main() {
var a [2]int
a[0] = 100
a[1] = 200
fmt.Printf(“a[0]: %v\n”, a[0])
fmt.Printf(“a[1]: %v\n”, a[1])
//对数组进行修改
a\[0\] = 1
a\[1\] = 2
fmt.Println("---------修改后--------")
fmt.Printf("a\[0\]: %v\\n", a\[0\])
fmt.Printf("a\[1\]: %v\\n", a\[1\])
}
//输出结果如下
a[0]: 100
a[1]: 200
———修改后——–
a[0]: 1
a[1]: 2
6. 根据数组长度遍历数组
可以根据数组长度,通过for
循环的方式来遍历数组,数组的长度可以使用len
函数获得
使用len()
函数获取数组的长度
package main
import “fmt”
func main() {
var a1 = [3]int{1, 2, 3}
fmt.Printf(“len(a1): %v\n”, len(a1))
var a2 = \[...\]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
fmt.Printf("len(a2): %v\\n", len(a2))
}
//输出结果如下
len(a1): 3
len(a2): 9
数组遍历,根据长度和下标
package main
import “fmt”
func main() {
a := […]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
for i := 0; i < len(a); i++ {
fmt.Printf(“a[%d]:%v\n”, i, a[i])
}
}
//输出结果如下
a[0]:1
a[1]:2
a[2]:3
a[3]:4
a[4]:5
a[5]:6
a[6]:7
a[7]:8
a[8]:9
使用for range
package main
import “fmt”
func main() {
var a = […]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
for i, v := range a { //i也可以使用空白标识符代替,不接受索引的值
fmt.Printf(“a[%v]:%v\n”, i, v)
}
}
//输出结果如下
a[0]:1
a[1]:2
a[2]:3
a[3]:4
a[4]:5
a[5]:6
a[6]:7
a[7]:8
a[8]:9
总结
- 数组的元素可以通过下标的方式来访问,下标的最大长度为数组长度-1,如果大于这个下标则会越界
- 遍历数组的两种方法:
① 通过for
循环,长度可以使用len()
获取
② 通过for range
循环遍历数组,返回数组下标和对应的值;若不想要下标,可以使用空白标识符_
来取代
自古英雄多磨难