go中的数组

1、声明数组语法：var variable_name [SIZE] variable_type, 其中SIZE即为长度和容量，variable_type可以为“内置类型”，也可以为某种“结构类型”；

2、若使用...替代数组的长度，Go语言会根据初始化时数组元素的数量来确定该数组的长度：

b := [...]int{1,2,3,4,5,6,7,8}
fmt.Printf("length: %d, capacity: %d, type: %s, value :%v", len(b), cap(b), reflect.TypeOf(b), b)
//运行结果：
length: 8, capacity: 8, type: [8]int, value :[1 2 3 4 5 6 7 8]

3、当一个数组的元素为指针类型时，该数组为指针数组。使用*运算符可访问元素指针所指向的值

array := [5]*int{0: new(int), 1: new(int)}
*array[1] = 20
fmt.Println(array)
fmt.Println(*array[0])
fmt.Println(*array[1])
//运行结果：
[0xc000066088 0xc0000660a0 <nil> <nil> <nil>]
0
20
//注意，new(int)返回int型的内存地址

 

4、数组只能为与其长度、元素类型相同的另一个数组赋值；

5、把一个指针数组赋值给另一个指针数组之后，两个指针数组指向相同的地址

func main(){
	var array1 [3]*string
	array2 := [3]*string{new(string), new(string), new(string)}
	*array2[0] = "Red"
	*array2[1] = "Blue"
	*array2[1] = "Green"
	array1 = array2
	fmt.Println(array1)
	fmt.Println(array2)
}
// 运行结果：
[0xc0000501c0 0xc0000501d0 0xc0000501e0]
[0xc0000501c0 0xc0000501d0 0xc0000501e0]

6、多维数组定义赋值方式

func main(){
	var array1, array2, array3 [4][2]int
	array1 = [4][2]int{{10, 11}, {20, 21}, {30, 31}, {40, 41}}
	array2 = [4][2]int{1: {20, 21}, 3: {40, 41}}
	array3 = [4][2]int{1: {0: 20}, 3: {1: 41}}
	fmt.Println(array1)
	fmt.Println(array2)
	fmt.Println(array3)
}
// 运行结果：
[[10 11] [20 21] [30 31] [40 41]]
[[0 0] [20 21] [0 0] [40 41]]
[[0 0] [20 0] [0 0] [0 41]]

7、为数组指定位置的值赋值，其余元组使用默认值：

c := [5]int{1:10, 2:20}
fmt.Println(c)
//运行结果：
[0 10 20 0 0]

 

8、数组在Go中为值类型，数组作为函数或方法的参数时，是对数组进行一个拷贝，而非传递一个地址给方法或函数；

#、当函数用到数组时，可以只传入指向数组的指针，这样可以提高数据传递速度，减小内存开销。注意，由于传递的是指针，所以如果改变指针指向的值，会改变共享内存。所以，使用切片能更好地处理内存共享问题。

9、数组之间可以使用“==”或“!=”进行比较，不可以使用<或>进行比较；

10、使用new关键字创建数组会返回一个数组的指针

p := new([10]int)
fmt.Println(p)
//运行结果：
&[0 0 0 0 0 0 0 0 0 0]

11、可以根据索引来为数组指定位置的元素赋值

 

a := [10]int{}
a[2] = 1
fmt.Println(a)
p := new([10]int)
p[2] = 1
fmt.Println(p)

12、数组索引

func main(){
	a := [10]int{0,1,2,3,4,5,6,7,8,9}
	b := a[5]   //指定位置索引
	c := a[6:10] //联系位置索引
	fmt.Println(b)
	fmt.Println(c)
}
//运行结果
5
[6 7 8 9]