亲宝软件园·资讯

展开

重学Go语言之数组的具体使用详解

程序员读书 人气:0

什么是数组

什么是数组?数组是有固定长度的相同数据类型元素的集合, 如下图所示:

从数组的定义以及上面的示例图我们可以得到数组的三个特征:

数组的创建

直接声明数组变量,在声明时必须指定长度:

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)

将数组作为函数参数

把数组作为参数传递给函数时,有几个注意的地方:

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},
		},
	}

上述三维数组的结构如下图所示:

小结

总结一下,这篇文章主要讲了以下几点:

加载全部内容

相关教程
猜你喜欢
用户评论