我正在参与「启航计划」
Go的数组是一种复合数据类型,在平时开发中并不常用,更常用的是切片(slice),能够把切片看作是能动态扩容的数组,切片的底层数据结构便是数组,所以数组虽不常用,但仍然有必要把握。
什么是数组
什么是数组?数组是有固定长度的相同数据类型元素的调集, 如下图所示:
从数组的界说以及上面的示例图咱们能够得到数组的三个特征:
- 固定长度,数组的长度在编译时就要确认。
- 每个元素的数据类型相同。
- 数组索引从0开始,索引的最大值为数组长度减1。
数组的创立
直接声明数组变量,在声明时有必要指定长度:
var iArray [2]int
var sArray [3]string
上面的代码中,咱们创立了一个长度为2
,元素数据类型为int
的数组和一个长度为3
,元素数据类型为string
的数组。
声明后,就能够经过索引给对应的元素赋值:
iArray[0] = 1
iArray[1] = 2
sArray[0] = "hello"
sArray[1] = "world"
sArray[2] = "!"
fmt.Println(iArray) //输出 [1,2]
fmt.Println(sArray) //输出 ["hello","world","!"]
也能够在声明时经过花括号{}
直接初始化数组元素的值:
var iArray [2]int = [2]int{1,2}
//花括号内初始化元素数量能够少于数组的长度,后边没有初始化的元素会被赋予该数据类型的默认值
var sArray [4]string = [4]string{"A","B","C"}
假如在声明时或许之后没有经过索引给数组的元素赋值,那么元素的值为对应数据类型的初始值:
var iArray [3]int
var sArray [4]string
fmt.Println(iArray) //输出:[0,0,0]
fmt.Println(sArray) //输出:[]
通知短变量能够让数组声明的更简洁:
i := [2]int{1,2}
也能够在声明数组不指定数组长度,而是经过...
和花括号{}
内的初始化值让Go
语言主动揣度数组的长度:
var i = [...]int{1, 2, 3, 4} //数组长度为4
拜访数组的元素
经过索引能够拜访数组中的某个元素:
fmt.Println(iArray[0])
无论是给数组的元素赋值,还是拜访数组的元素都不超过数组的长度,不然会数组越界的过错,数组的索引从0开始,因此数组的索引取值规模是0~len-1
(len表示数组的长度)。
iArray := [2]int{1,2}
sArray := [3]string{"A","B","C"}
iArray[2] = 10 //报错,该数组索引的取值规模是0~1
fmt.Println(sArray[10]) // 报错,该数组索引的取值规模是0~2
数组的长度
Go
内置的函数len()
能够用于取得数组的长度:
iArray := [4]int{1,2,3,4}
fmt.Println(len(iArray)) // 输出结果:4
怎么遍历数组
遍历数组运用for
句子,有两种方法:
- 运用
for
句子遍历数组:
for i := 0; i < len(iArray); i++ {
fmt.Println(iArray[i])
}
- 运用
for-range
遍历数组:
for k,v := range iArray {
fmt.Println(k,v)
}
for-range
遍历数组时,能够获取数组的索引和数组的元素,也能够在遍历时挑选疏忽索引或许元素值:
for _,v := range iArray { //疏忽数组的索引
fmt.Println(v)
}
for k,_ := range iArray{ //疏忽元素
fmt.Println(k)
}
数组的比较
数组只能进行持平(==
)或许不持平(!=
)的比较,而且两个进行比较的数组要契合以下要求,不然代码无法经过编译:
- 数组元素的数据类型有必要共同
- 数组的长度有必要共同
当数组满意上面的要求后,假如对应索引元素值相同,则数组持平,不然不持平:
iArray1 := [2]int{1, 2}
iArray2 := [2]int{1, 2}
if iArray1 == iArray2 {
print("持平")
} else {
print("不持平")
}
//输出:持平
iArray3 := [2]int{2, 1}
iArray4 := [2]int{1, 2}
if iArray1 == iArray2 {
print("持平")
} else {
print("不持平")
}
//输出:不持平
查找数组中的元素
对于数组来说,要查找数组中是否存在某个元素,并回来其对应索引,就要遍历一个数组,并对每个元素进行比较:
sArray := [5]string{"Java","PHP","Go","Python","JavaScript"}
for index, element := range sArray {
if element == needle {
fmt.Println(index)
}
}
假如咱们要查找的元素在数组的最后一个,那么要遍历整个数组才能查找到,查找元素的时刻复杂度为O(n)
。
将数组作为函数参数
把数组作为参数传递给函数时,有几个注意的当地:
- 当把数组作为参数传给函数时,Go会把数组仿制一份传给函数,所以数组作为函数参数时是值传递而不是引用传递。
- 数组作为参数,会被仿制,因此假如传递的数组很大,仿制就会很耗时。
- 传递给函数的数组,其长度与数据类型有必要函数形参共同,因此复用性很差。
func updateArray(haystack [5]int, index int, value int) error {
if index >= len(haystack) {
return errors.New("索引不能超过数组长度")
}
haystack[index] = value
fmt.Println(haystack) //[1 100 3 4 5]
return nil
}
func main() {
iArray := [5]int{1, 2, 3, 4, 5}
updateArray(iArray, 1, 100)
fmt.Println(iArray) // [1 2 3 4 5]
}
上面这个比如中,咱们期望updateArray
函数能够修正咱们指定索引的元素数组,但实践修正的仿制后数组,与咱们传给函数的数组无关,处理的方法是传递数组的指针:
func updateArray(haystack *[5]int, index int, value int) error {
if index >= len(haystack) {
return errors.New("索引不能超过数组长度")
}
haystack[index] = value
fmt.Println(haystack) //[1 100 3 4 5]
return nil
}
func main() {
iArray := [5]int{1, 2, 3, 4, 5}
updateArray(&iArray, 1, 100)
fmt.Println(iArray) // [1 100 3 4 5]
}
尽管传递数组指针能够避免数组仿制导致的性能问题,但是数组的长度和元素数据类型仍然要求共同,这大概便是数组不怎么被运用的原因吧:
func main() {
iArray := [6]int{1, 2, 3, 4, 5} //把数组长度改为6
updateArray(&iArray, 1, 100) //报错
}
同理,当咱们把一个数组变量赋值别的一个变量时,Go也是把数组仿制一份给新的变量,假如想把新的变量指向本来的数组,同样是用数组的指针:
iArray := [2]int{1,2}
iArray1 := iArray
iArray[0] = 10
fmt.Println(iArray1) //输出:[10,2]
fmt.Println(iArray) //输出:[1,2]
iArray2 := &iArray
iArray2[0] = 20;
fmt.Println(iArray2) //输出:&[20,2]
fmt.Println(iArray) //输出:[20,2]
二维与多维数组
Go也支撑二维和多维数组,其创立方法与一维数组相似:
- 二维数组:
iArrays := [3][2]string{{"A","B"},{"C","D"},{"E","F"}}
上述二维数组的结构如下图所示:
- 多维数组:
iArrays := [3][4][2]int{
{
{1, 2},
{3, 4},
{5, 6},
},
{
{7, 8},
{9, 10},
{11, 12},
},
{
{13, 14},
{15, 16},
{17, 18},
},
}
上述三维数组的结构如下图所示:
小结
总结一下,这篇文章首要讲了以下几点:
- 数组是一种固定长度的相同数据类型元素的调集,在实践开发中并不常用,而是作为slice的底层数据结构。
- Go支撑一维、二维和多维数组
- 数组能够进行持平或许不持平的比较
- 运用
for
或许for-range
能够遍历数组 - 经过数组索引拜访元素或许给元素赋值时,都不能超过数组的长度约束。