Go 语言数组(上)

2022-04-27 106

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： 引言数组是相同数据类型的一组数据的集合，数组一旦定义长度不能修改，数组可以通过下标（或者叫索引)来访问元素。相对于去声明 number0, number1, ..., number99 的变量，使用数组形式 numbers[0], numbers[1] ..., numbers[99] 更加方便且易于扩展。数组元素可以通过索引（位置）来读取（或者修改），索引从0 开始，第一个元素索引为 0，第二个索引为1，以此类推。

引言

数组是相同数据类型的一组数据的集合，数组一旦定义长度不能修改，数组可以通过下标（或者叫索引)来访问元素。

相对于去声明 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循环遍历数组，返回数组下标和对应的值；若不想要下标，可以使用空白标识符_来取代

三. 访问数组元素

1. 访问数组元素

数组元素可以通过索引（位置）来读取。
格式为数组名后加中括号，中括号中为索引的值。数组的最大下标为数组长度-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

示例 ②
package main
import "fmt"
func main() {
  //声明数组的同时快速初始化数组
  balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
  //输出数组元素
  for i := 0; i < 5; i++ {
    fmt.Printf("balance[i]: %f\n", balance[i])
  }
  //输出每个数组元素的值
  balance2 := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
  for x := 0; x < 5; x++ {
    fmt.Printf("balance2[x]: %f\n", balance2[x])
  }
  //将索引为1和3的元素初始化
  balance3 := [5]float32{1: 2.0, 3: 7.0}
  for y := 0; y < 5; y++ {
    fmt.Printf("balance3: %f\n", balance3[y])
  }
}
//输出结果如下
balance[i]: 1000.000000
balance[i]: 2.000000
balance[i]: 3.400000
balance[i]: 7.000000
balance[i]: 50.000000
balance2[x]: 1000.000000
balance2[x]: 2.000000
balance2[x]: 3.400000
balance2[x]: 7.000000
balance2[x]: 50.000000
balance3: 0.000000
balance3: 2.000000
balance3: 0.000000
balance3: 7.000000
balance3: 0.000000