go 数组 详解

---

数组：是指一系列同一类型数据的集合，在内存中有序存储的数据集合。

数组的定义和使用

数组定义格式：

var 数组名 [元素个数]数据类型

例如 1. （常用）

package main

import "fmt"

func main() {
	var a [5]int
// 通过数组下标找到具体元素 数组下标从0开始的 到数组元素个数-1为数组最大下标
//数组名[下标]   指向具体某一元素
	a[0] = 18
	a[1] = 3
	a[2] = 6
	fmt.Println(a) // [18 3 6 0 0]
fmt.Println(a[1]) // 3
}

2.在定义数组时 依次为数组元素赋值（常用）

package main
import "fmt"
func main() {
//在定义数组时 可以为部分元素赋值
	var a [5]int =[5]int{1,2,3,4}
	fmt.Println(a) // [1 2 3 4 0]
fmt.Println(a[1]) // 2
fmt.Println(len(a)) //5 len(数组名)计算数组元素个数
}

3. （常用）

package main
import "fmt"
func main() {
	//在定义数组时 可以为部分元素赋值
	var a [5]int = [5]int{1: 10, 3: 20, 0: 40}
	fmt.Println(a)      // [40 10 0 20 0]
	fmt.Println(a[1])   // 10
	fmt.Println(len(a)) //5 len(数组名)计算数组元素个数
}

4. 定义时写…可以根据元素个数赋值（不常用）

package main
import "fmt"
func main() {
	//在定义数组时 可以为部分元素赋值
	var a [5]int = [...]int{1, 2, 3, 4, 5} // 一定要5个
	fmt.Println(a)                         // [1 2 3 4 5]
	fmt.Println(a[1])                      // 2
	fmt.Println(len(a))                    // 5 len(数组名)计算数组元素个数
}

5. 自动类型推导

import "fmt"

func main() {

	arr := [3]int{2, 3}
	fmt.Println(arr) //[2 3 0]
}

数组的遍历

for

package main

import "fmt"

func main() {
	var a [5]int = [5]int{1, 2, 3, 4, 5}
	//遍历数组信息
	for i := 0; i < len(a); i++ {
		fmt.Println(a[i])
	}
}

for range

package main

import "fmt"

func main() {
	var a [5]int = [5]int{1, 2, 3, 4, 5}
	//遍历数组信息
	for i, v := range a {
		fmt.Println("索引：", i, ",值：", v)
	}
}

数组常见问题

package main
import "fmt"
func main() {
	//数组常见问题
	var arr [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	var arr2 [10]int
	var arr3 [6]int
	//数组下标越界 最大值下标：len(arr)-1
	//arr[10] = 666 //err:invalid argument: array index 10 out of bounds [0:10]无效的数组的下标为10
	//arr[-1] = 666//err: invalid argument: index -1 (constant of type int) must not be negative

	//arr是数组名  表示的是一个数组
	//arr = 123 //err

	//两个数组如果类型和元素个数相同可以赋值
	arr2 = arr //可以
	//arr3 = arr        //err: cannot use arr (variable of type [10]int) as type [6]int in assignment
	fmt.Println(arr)  //[1 2 3 4 5 6 7 8 9 10]
	fmt.Println(arr2) //[1 2 3 4 5 6 7 8 9 10]
	//数据类型
	fmt.Printf("%T\n", arr)  //[10]int
	fmt.Printf("%T\n", arr2) //[10]int

	fmt.Println(arr3)
	fmt.Printf("%T\n", arr3) //[6]int

	//i是一个变量
	//i := 10
	//var arr4 [i]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} //err
	//因为数组元素个数不能使用变量，数组长度在你编译之后，通过go build变成可执行文件的时候，这里面的元素个数一定要确定好。
	//而当你定义变量之后，这里面是没有定义好的，因为之后把i加载到内存中他才有具体数据，所以我们数组元素个数一定要写常量(例如10)或常量表达式

	const i = 10
	//var arr4 [i]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} //可以[1 2 3 4 5 6 7 8 9 10]
	//var arr4 [i + 1]int = [11]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}//可以[1 2 3 4 5 6 7 8 9 10 0]
	var arr4 [5 + 5]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} //可以[1 2 3 4 5 6 7 8 9 10]
	fmt.Println(arr4)
}

数组下标越界 最大值下标：len(arr)-1
两个数组如果类型和元素个数相同可以赋值
数组元素个数一定要写常量(例如10)或常量表达式

深入了解数组内存存储格式

package main
import "fmt"
func main() {
	//深入了解数组内存存储格式
	var arr [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	fmt.Println(arr)
	fmt.Printf("%T\n", arr) //[10]int
	//	打印数组地址
	//数组名表示整个数组 数组名对应的地址就是数组第一个元素的地址
	//fmt.Printf("数组地址：%p\n", &arr)         // 0xc000014190
	//fmt.Printf("数组第一个元素地址：%p\n", &arr[0]) //0xc000014190跟数组地址一样
	//fmt.Printf("数组第二个元素地址：%p\n", &arr[1]) //0xc000014198跟第一个元素隔了8个数据
	//fmt.Printf("数组第三个元素地址：%p\n", &arr[2]) //0xc0000141a0
	//fmt.Printf("数组第四个元素地址：%p\n", &arr[3]) //0xc0000141a8
	//	为什么是8个大小 因为每一个int类型在内存中占得就是8个大小
	//  int 我是64位操作系统 位是bit  1 Byte = 8 bit
	// 64bit =8 Byte
	/* 打印数组所有元素地址 */
	for i := 0; i < len(arr); i++ {
		fmt.Printf("%p\n", &arr[i])
	}
}

二维数组

前面学的都是一维数组，例如：var red [6]int，现在我们来学习二维数组。
二维数组定义的方式：

package main

import "fmt"

func main() {
	var arr [2][3]int
	//len(二维数组名)表示一个二维数组有几行
	fmt.Println(len(arr)) // 2
	//len(二维数组名[下标])表示一个二维数组有几列
	fmt.Println(len(arr[0])) // 3
	arr[0][1] = 666
	arr[1][2] = 123
	fmt.Println(arr) // [[0 666 0] [0 0 123]]
	fmt.Println("循环遍历二维数组")
	for i := 0; i < len(arr); i++ {
		for j := 0; j < len(arr[0]); j++ {
			fmt.Println(arr[i][j])
		}
	}
	fmt.Println("用for range")
	for i, v := range arr {
		fmt.Printf("%T ", v) //	[3]int
		fmt.Println(i, v)    //0 [0 666 0]
		for _, value := range v {
			fmt.Println(value) //0
		}
	}
}

自动类型推导:

package main

import "fmt"

func main() {
	arr := [2][3]int{{1, 6, 5}, {2, 3}}
	fmt.Println(arr) //[[1 6 5] [2 3 0]]
}