Golang学习记录9——数组

数组：使用连续空间存储一组相同数据类型的数据

数组相关操作

1. 数组的声明：var 数组名 [数组长度] 数据类型
2. 数组存储的是空间首地址，第i个元素地址为：&数组名+数组类型所占字节*i——访问/查询/读取速度快
3. 要打印数组名的地址，需要使用%p
4. 使用数组名可打印数组所有值
5. 在批量键入赋值的时候，可以使用fmt.Scanf()进行赋值，可以一次性输入，循环赋值会自动接收输入的数据，至循环完成，如果多输入了数据，会自动丢弃。
6. 数组的遍历可使用普通for循环，也能使用for-range遍历

package main

import "fmt"

func main() {
	//数组存储的是相同类型的数据

	var arr1 [5]int16 //声明一个长度为5的int类型数组

	// 查看arr1的数据类型
	fmt.Println("===================数组类型===================")
	fmt.Printf("arr1的数据类型为：%T\n", arr1)

	// 查看arr1的地址和内部元素的地址
	//fmt.Println(&arr1)
	//fmt.Printf("数据arr1的地址为:%v\n", arr1) 
	//为什么此处答应的不是地址，而是数组
	//arr中存储的是地址值，且需要使用%p输出
	fmt.Println("===================数组地址===================")
	fmt.Printf("数据arr1的地址为:%p\n", &arr1) 
	
	//
	for i := 0; i < len(arr1); i++ {
		fmt.Printf("数据arr1[%d]的地址为:%v\n", i, &arr1[i])
	}

	//数组赋值
	fmt.Println("===================键入赋值===================")
	for i := 0; i < len(arr1); i++ {
		fmt.Println("请输入元素值")
		fmt.Scanf("%d",&arr1[i])		//可一次性输入，直到循环全部执行完
	}

	//打印数组
	fmt.Println("数组元素值为：",arr1)
	fmt.Println("===================遍历数组===================")
	//遍历数组
	//方式1:普通for循环
	fmt.Println("-------------------for-------------------")
	for i := 0; i < len(arr1); i++ {
		fmt.Printf("The %dth value is:%d\n",i+1,arr1[i])
	}
	//方式2:for range   
	fmt.Println("----------------for-range----------------")
	for i , value := range arr1{
		fmt.Printf("The %dth value is:%d\n",i+1,value) 
	}

===================数组类型===================
arr1的数据类型为：[5]int16
===================数组地址===================
数据arr1的地址为:0x1400000e082
数据arr1[0]的地址为:0x1400000e082
数据arr1[1]的地址为:0x1400000e084
数据arr1[2]的地址为:0x1400000e086
数据arr1[3]的地址为:0x1400000e088
数据arr1[4]的地址为:0x1400000e08a
===================键入赋值===================
请输入元素值
1 2 3 4 5 6 7
请输入元素值
请输入元素值
请输入元素值
请输入元素值
数组元素值为： [1 2 3 4 5]
===================遍历数组===================
-------------------for-------------------
The 1th value is:1
The 2th value is:2
The 3th value is:3
The 4th value is:4
The 5th value is:5
----------------for-range----------------
The 1th value is:1
The 2th value is:2
The 3th value is:3
The 4th value is:4
The 5th value is:5
dearfriend@dearfrienddeMacBook-Air demo1 % 6 7
zsh: command not found: 6

数组初始化

package main
import "fmt"

func main()  {
	//方式1：数组等于数组
	var arr1 [3]int = [3]int{1,2,3}
	fmt.Println(arr1)

	//方式2:自行判定类型
	var arr2 = [3]int{1,2,3}
	fmt.Println(arr2)

	//方式3:未至指定长度
	var arr3 = [...]int{1,2,3,4}
	fmt.Println(arr3)
	
	//方式4:指定索引初始化
	var arr4 = [...]int{3:6,2:1}
	fmt.Println(arr4)

	var arr5 [3]int
	arr5 = [3]int{1,3,4}
	fmt.Println(arr5)

}

[1 2 3]
[1 2 3]
[1 2 3 4]
[0 0 1 6]
[1 3 4]

PS：[…]的使用不能在定义中使用，在赋值中使用相当于通过后面的值自动判定，但可以在赋值的时候使用。在定义的时候可以参照变量声明

	var arr5 [3]int
	arr5 = [...]int{1,3,4}
	fmt.Println(arr5)

注意事项

• 在定义数组类型的时候，[长度]也是类型的一部分，一定不能忘记
• 数组类型是值类型数据，是值传递（非引用类数据类型——传递的是地址），所以传入函数为数组的值，对数组本身没有影响

package main

import "fmt"

func test(arr [3]int) {
	arr[1] = 9
}

func main() {

	arr3 := [3]int{1, 2, 3}
	test(arr1) //此处传入的不是数组的地址空间，或者说把数组传入了，而是将数组的三个值传入了
	fmt.Println(arr1)

}

[1 2 3]

• 如果想通过函数修改原数组的值，可以使用引用传递（指针）

package main

import "fmt"

func test(arr *[3]int){
	(*arr)[2] = 9      //注意此处格式
}

func main() {

	arr1 := [3]int{1, 2, 3}
	test(&arr1)    //将数组地址传入
	fmt.Println(arr1)

}

[1 2 9]

二维数组

• 二维数组的本质实际上就是一个存储数组类型的数组。
  
  

[[1 2 3] [1 2 3] [1 2 3]]
[[1 2 3] [4 5 6] [7 8 9]]

• 对于二维数组的地址，arr[0][0]的地址就是arr的地址

//地址
	fmt.Println("===========地址============")
	fmt.Printf("a1数组的地址为：%p\n",&arr)
	for i := 0; i < 3; i++ {
		for j := 0; j<3; j++{
			fmt.Printf("a[%d][%d]的地址为：%p\n",i+1,j+1,&arr[i][j])
		}
		
	}

===========地址============
a1数组的地址为：0x1400000e0b0
a[1][1]的地址为：0x1400000e0b0
a[1][2]的地址为：0x1400000e0b1
a[1][3]的地址为：0x1400000e0b2
a[2][1]的地址为：0x1400000e0b3
a[2][2]的地址为：0x1400000e0b4
a[2][3]的地址为：0x1400000e0b5
a[3][1]的地址为：0x1400000e0b6
a[3][2]的地址为：0x1400000e0b7
a[3][3]的地址为：0x1400000e0b8

• 二维数组的使用
  • 主要抓住存储数组类型的数组这句话。如果把二维数组当作一个普通的数组，那么只使用外层数组的索引能够得到存储的数组元素。
  • 对于二位数组的长度，其长度为外层数组长度

//地址
	fmt.Println("===========二维数组的使用============")
	fmt.Println("-----------二维数组的长度------------")
	fmt.Println("二维数组的长度",len(arr))
	fmt.Println("内层数组的长度",len(arr[1]))
	//使用矩阵的行：和普通数组一样
	fmt.Println("-----------二维数组行打印------------")
	for i:=0; i<len(arr);i++ {
		fmt.Printf("arr矩阵第%d行为：%v\n",i+1,arr[i])
	}

===========二维数组的使用============
-----------二维数组的长度------------
二维数组的长度 3
内层数组的长度 3
-----------二维数组行打印------------
arr矩阵第1行为：[1 2 3]
arr矩阵第2行为：[4 5 6]
arr矩阵第3行为：[7 8 9]

• 二维数组的遍历
  • 普通for循环：通过两次索引确定值
  • for-range：第一次使用将内层数组提出存储到value中，然后对value数组在进行遍历，将value数组中的元素存入到内层v中

//二维数组遍历
	fmt.Println("===========二维数组遍历============")
	//方式1:普通for循环
	fmt.Println("-----------for遍历-----------")
	for i := 0; i < 3; i++ {
		for j := 0; j<3; j++{
			fmt.Printf("a[%d][%d]的为：%v\n",i+1,j+1,arr[i][j])
		}
		
	}

	//方式2:for-range
	fmt.Println("-----------for-range遍历-----------")
	for i,value := range arr{       //此处得到的value是一个数组
		for j,v := range value{     
			fmt.Printf("a[%d][%d]的为：%v\n",i+1,j+1,v)
		}
	}

===========二维数组遍历============
-----------for遍历-----------
a[1][1]的为：1
a[1][2]的为：2
a[1][3]的为：3
a[2][1]的为：4
a[2][2]的为：5
a[2][3]的为：6
a[3][1]的为：7
a[3][2]的为：8
a[3][3]的为：9
-----------for-range遍历-----------
a[1][1]的为：1
a[1][2]的为：2
a[1][3]的为：3
a[2][1]的为：4
a[2][2]的为：5
a[2][3]的为：6
a[3][1]的为：7
a[3][2]的为：8
a[3][3]的为：9