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 mainimport "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]intb: [2]stringa: [0 0 0]b: [ ]

　　

 

从上面运行的结果中可以看出来，数组和长度和元素类型共同组成了数组的类型

 

二、数组的初始化

初始化，就是给数组的元素赋值，没有初始化的数组，默认元素值都是零值，布尔类型是false，字符串是空字符串。

1. 未初始化的数组

package mainimport "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 mainimport "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 mainimport "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 mainimport "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 mainimport "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]: 100a[1]: 200---------修改后--------a[0]: 1a[1]: 2

　　

 

 

 

6. 根据数组长度遍历数组

可以根据数组长度，通过for循环的方式来遍历数组，数组的长度可以使用len函数获得

使用len()函数获取数组的长度

package mainimport "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): 3len(a2): 9

　　

数组遍历，根据长度和下标

package mainimport "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]:1a[1]:2a[2]:3a[3]:4a[4]:5a[5]:6a[6]:7a[7]:8a[8]:9

　　

使用for range

package mainimport "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]:1a[1]:2a[2]:3a[3]:4a[4]:5a[5]:6a[6]:7a[7]:8a[8]:9

　　

 

总结

• 数组的元素可以通过下标的方式来访问，下标的最大长度为数组长度-1，如果大于这个下标则会越界

• 遍历数组的两种方法：
  ① 通过 for循环，长度可以使用len()获取
  ② 通过for range循环遍历数组，返回数组下标和对应的值；若不想要下标，可以使用空白标识符_来取代