6Go语言基础之数组
Posted remixnameless
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了6Go语言基础之数组相关的知识,希望对你有一定的参考价值。
1、Array(数组)
数组是同一种数据类型元素的集合。 在Go语言中,数组从声明时就确定,使用时可以修改数组成员,但是数组大小不可变化。 基本语法:
// 定义一个长度为3元素类型为int类型的数组a
var a [3]int
1.1、数组定义:
var 数组变量名 [元素数量]T
比如:var a [5]int
, 数组的长度必须是常量,并且长度是数组类型的一部分。一旦定义,长度不能变。 [5]int
和[10]int
是不同的类型。
var a [3]int
var b [4]int
a = b //此时a和b是不同的类型,不允许赋值
数组可以通过下标进行访问,下标是从0
开始,最后一个元素下标是:len-1
,访问越界(下标在合法范围之外),则触发访问越界,会panic。
1.2、数组的初始化
数组的初始化也有很多方式。
方法一
初始化数组时可以使用初始化列表来设置数组元素的值。
package main
import "fmt"
func main() {
var a [5]int //数组会初始化为int类型的零值
var b = [5]int{1, 2, 3} //使用指定的初始值完成初始化
var c = [3]string{"北京", "上海", "广州"} //使用指定的初始值完成初始化
fmt.Println(a) //[0 0 0 0 0]
fmt.Println(b) //[1 2 3 0 0]
fmt.Println(c) //[北京 上海 广州]
}
方法二
上述的方法每次都要确保提供的初始值和数组长度一致,一般情况下可以让编译器根据初始值的个数自行推断数组的长度,然后给变量赋值类型,例如:
package main
import "fmt"
func main() {
var a [3]int
var b = [...]int{1, 2, 3, 4}
var c = [...]string{"北京", "上海", "广州"}
fmt.Println(a) //[0 0 0]
fmt.Println(b) //[1 2 3 4]
fmt.Printf("type of b:%T
", b) //type of b:[4]int
fmt.Println(c) //[北京 上海 广州]
fmt.Printf("type of c:%T
", c) //type of c:[3]string
}
方法三
我们还可以使用指定索引值的方式来初始化数组,例如:
package main
import "fmt"
func main() {
a := [...]int{3: 18, 5: 99}
fmt.Println(a) // [0 0 0 18 0 99]
fmt.Printf("type of a:%T
", a) //type of a:[6]int
}
1.3、数组的遍历(两种方法)
方法1:for循环遍历
package main
import "fmt"
func main() {
var a = [...]string{"北京", "上海", "广州"}
for i := 0; i < len(a); i++ {
fmt.Println(a[i])
}
}
>>>
北京
上海
广州
方法2:for range遍历
package main
import "fmt"
func main() {
var a = [...]string{"北京", "上海", "广州"}
for index, value := range a {
fmt.Println(index, value)
}
}
>>>
0 北京
1 上海
2 广州
1.4、多维数组
Go语言是支持多维数组的,以二维数组为例(数组中又嵌套数组)。
二维数组的定义
package main
import "fmt"
func main() {
a := [3][2]int{
{1, 2},
{3, 4},
{5, 6},
}
fmt.Println(a) //[[1 2] [3 4] [5 6]]
fmt.Println(a[2][1]) //支持索引取值:6
}
注意:多维数组除了第一层其它层都不能使用...
二维数组的遍历
法一:
package main
import "fmt"
func main() {
a := [3][2]int{
{1, 2},
{3, 4},
{5, 6},
}
for _, v1 := range a {
for _, v2 := range v1 {
fmt.Printf("%d ", v2)
}
fmt.Println()
}
}
>>>
1 2
3 4
5 6
法二:
func main() {
a := [...][2]int{
{1, 2},
{3, 4},
{5, 6},
}
for i := 0; i < len(a); i++ {
for j := 0; j < len(a[i]); j++ {
fmt.Printf("%d ", a[i][j])
}
fmt.Println()
}
}
>>>
1 2
3 4
5 6
注意: 多维数组只有第一层可以使用...
来让编译器推导数组长度。
例如:
//支持
a := [...][2]int{
{1, 2},
{3, 4},
{5, 6},
}
//不支持多维数组的内层使用...
a := [3][...]int{
{1, 2},
{3, 4},
{5, 6},
}
1.5、数组是值类型
数组是值类型,赋值和传参会复制整个数组直接拷贝。因此改变副本的值,不会改变本身的值。
package main
import "fmt"
func testArry1(c [3]int) {
c[0] = 100
fmt.Println(c) //[100 20 30]
}
func testArry2(d [3][2]int) {
d[2][0] = 100
fmt.Println(d) //[[1 2] [3 4] [100 6]]
}
func main() {
a := [3]int{10, 20, 30}
testArry1(a) //在testArry1中修改的是新拷贝的数组c
fmt.Println(a) //[10 20 30]
b := [3][2]int{
{1, 2},
{3, 4},
{5, 6},
}
testArry2(b) //在testArry2中修改的是新拷贝的数组d
fmt.Println(b) //[[1 2] [3 4] [5 6]]
}
注意:
- 数组支持 “==“、”!=” 操作符,因为内存总是被初始化过的。
[n]*T
表示指针数组,*[n]T
表示数组指针 。
练习题
1、求数组[1, 3, 5, 7, 8]
所有元素的和
package main
import "fmt"
func main() {
a := [...]int{1, 3, 5, 7, 8}
sum := 0
for _, v := range a {
sum += v
}
fmt.Println(sum)
}
>>>24
2、找出数组中和为指定值的两个元素的下标,比如从数组[1, 3, 5, 7, 8]
中找出和为8的两个元素的下标分别为(0,3)
和(1,2)
。
法一:
func main() {
a := [...]int{1, 3, 5, 7, 8}
for index1, value1 := range a {
total := 8 - value1
for index2, value2 := range a {
if value2 == total {
fmt.Printf("和为8的两个元素的下标为:(%d %d)
", index1, index2)
}
}
}
}
>>>
和为8的两个元素的下标为:(0 3)
和为8的两个元素的下标为:(1 2)
和为8的两个元素的下标为:(2 1)
和为8的两个元素的下标为:(3 0)
法二:
func main() {
a := [...]int{1, 3, 5, 7, 8}
for i := 0; i < len(a); i++ {
for j := i + 1; j < len(a); j++ {
if a[i]+a[j] == 8 {
fmt.Printf("和为8的两个元素的下标为:(%d, %d)
", i, j)
}
}
}
}
>>>
和为8的两个元素的下标为:(0, 3)
和为8的两个元素的下标为:(1, 2)
以上是关于6Go语言基础之数组的主要内容,如果未能解决你的问题,请参考以下文章
Go语言技巧之正确高效使用slice(听课笔记总结--简单易懂)
Go语言技巧之正确高效使用slice(听课笔记总结--简单易懂)