6、golang-数组操作

数组

数组是同一种数据类型元素的集合。 在Go语言中，数组从声明时就确定，使用时可以修改数组成员，但是数组大小不可变化。

1、数组的初始化

var a [5]int， 数组的长度必须是常量，并且长度是数组类型的一部分。一旦定义，长度不能变。 [5]int和[10]int是不同的类型。

方法一

初始化数组时可以使用初始化列表来设置数组元素的值

func studyArray() {
	var numArray = [3]int{1, 2, 3}
	var numArray1 [4]int
	var cityArray = [3]string{"北京", "上海", "深圳"}
	fmt.Println(numArray)
	fmt.Println(numArray1)
	fmt.Println(cityArray)
//[1 2 3]
//[0 0 0 0]
//[北京 上海 深圳]
        fmt.Printf("type of numArray:%T,%v \n", numArray, numArray)
	fmt.Printf("type of numArray1:%T,%v \n", numArray1, numArray1)
	fmt.Printf("type of cityArray:%T,%v \n", cityArray, cityArray)
	//type of numArray:[3]int,[1 2 3]
	//type of numArray1:[4]int,[0 0 0 0]
	//type of cityArray:[3]string,[北京 上海 深圳]
}

方法二

一般我们可以让编译器根据初始值的个数自行推断数组的长度，例如：

func studyArray() {
	var numArray = [...]int{1, 2, 3}
	var cityArray = [...]string{"北京", "上海", "深圳"}
	fmt.Printf("type of numArray: %T, %v \n", numArray, numArray)
	fmt.Printf("type of cityArray: %T, %v \n", cityArray, cityArray)
	//type of numArray: [3]int, [1 2 3]
	//type of cityArray: [3]string, [北京 上海 深圳]
}

方法三

使用指定索引值来初始化数组，例如:

func studyArray() {
	var numArray = [...]int{1: 1, 2: 2, 5: 5}
	// type of numArray: [6]int, [0 1 2 0 0 5] 
	fmt.Printf("type of numArray: %T, %v \n", numArray, numArray)
}

2、数组的遍历

func studyArray() {
	var cityArray = [...]string{"北京", "上海", "深圳"}
    // 方法1：for循环遍历
	for i := 0; i < len(cityArray); i++ {
		fmt.Println(cityArray[i])
	}
    // 方法2：for range遍历
	for index, city := range cityArray {
		fmt.Println(index, city)
	}
	//北京
	//上海
	//深圳
	//0 北京
	//1 上海
	//2 深圳

}

3、多维数组

注意： 多维数组只有第一层可以使用...来让编译器推导数组长度

func main() {
	a := [3][2]string{
		{"北京", "上海"},
		{"广州", "深圳"},
		{"成都", "重庆"},
	}
	fmt.Println(a) //[[北京 上海] [广州 深圳] [成都 重庆]]
	fmt.Println(a[2][1]) //支持索引取值:重庆
}

//遍历
func main() {
	a := [3][2]string{
		{"北京", "上海"},
		{"广州", "深圳"},
		{"成都", "重庆"},
	}
	for _, v1 := range a {
		for _, v2 := range v1 {
			fmt.Printf("%s\t", v2)
		}
		fmt.Println()
	}
}
//北京	上海	
//广州	深圳	
//成都	重庆

//支持的写法
a := [...][2]string{
	{"北京", "上海"},
	{"广州", "深圳"},
	{"成都", "重庆"},
}
//不支持多维数组的内层使用...
b := [3][...]string{
	{"北京", "上海"},
	{"广州", "深圳"},
	{"成都", "重庆"},
}

4、数组是值类型

数组是值类型，赋值和传参会复制整个数组。因此改变副本的值，不会改变本身的值。

func modifyArray(x [3]int) {
	x[0] = 100
	fmt.Println(x) // [100 20 30]
}

func modifyArray2(x [3][2]int) {
	x[2][0] = 100
	x[1] = [2]int{3, 3}
	fmt.Println(x) // [[1 1] [3 3] [100 1]]
}
func copyArray() {
	a := [3]int{10, 20, 30}
	modifyArray(a) //在modify中修改的是a的副本x
	fmt.Println(a) //[10 20 30]
	b := [3][2]int{
		{1, 1},
		{1, 1},
		{1, 1},
	}
	modifyArray2(b) //在modify中修改的是b的副本x
	fmt.Println(b)  //[[1 1] [1 1] [1 1]]
}

 

同python的深拷贝【deepcopy；copy；直接赋值】

import copy

def modifyArray(a):
    a[0][0] = 100
    # 4482037200  a[0][0] is a[0][0]
    print("a", id(a[0][0]))


def modifyArray1(a):
    b = copy.copy(a)
    b[0][1] = 101
    b[1] = ["a", "b"]
    # b 4482037232  id(b[0][1]) is id(a[0][1])
    print("b", id(b[0][1]))
    # b 4484046208  id(b[1]) !=id(a[1])
    print("b", id(b[1]))


def modifyArray2(a):
    c = copy.deepcopy(a)
    c[0][1] = 102
    # c 4482037264  c[0][1] != a[0][1]
    print("c", id(c[0][1]))


a = [[1, 2], [1, 3], [2, 4]]
modifyArray(a)
modifyArray1(a)
modifyArray2(a)
# [[100, 101], [1, 3], [2, 4]]
print(a)
# 4482037200
print(id(a[0][0]))
# 4482037232
print(id(a[0][1]))
# 4483914432
print(id(a[1]))

注意：

1. 数组支持 “==“、”!=” 操作符，因为内存总是被初始化过的。
2. [n]*T表示指针数组，*[n]T表示数组指针 。

 

练习

func arrayPractice() {
	//求数组[1, 3, 5, 7, 8]所有元素的和
	aa := [...]int{1, 3, 5, 7, 8}
	var sum int = 0
	for _, value := range aa {
		sum += value
	}
	fmt.Printf("sum:%d \n", sum)
	//找出数组中和为指定值的两个元素的下标，比如从数组[1, 3, 5, 7, 8]中找出和为8的两个元素的下标分别为(0,3)和(1,2)。
	for i := 0; i < len(aa)-1; i++ {
		for j := i + 1; j < len(aa); j++ {
			if 8 == aa[i]+aa[j] {
				fmt.Printf("(%d,%d)", i, j)
				fmt.Println()
			}
		}
	}
}

参考链接：

https://www.liwenzhou.com/posts/Go/05_array/