day05 数组array

数组

什么是数组

• 数组，即一维数组
  • 数组是容器型数据结构
  • 数组内的数据。必须是相同数据类型的数据
  • 数组是需要定义大小的
  • 数组的大小不可修改
  • 数组是有序
  • 使用any定义数组。该类型能接收不同类型的数组。

package main

import "fmt"

func main() {
	/*
		什么是数组？
			-  一维数组
				- 数组是容器型数据结构
				- 数组内的数据。必须是相同数据类型的数据
				- 数组是需要定义大小的
				- 数组的大小不可修改
				- 数组是有序
				- 使用any定义数组。该类型能接收不同类型的数组。
	*/

	// 定义数组。 int类型为0，string类型为空
	var arr01 [4]int
	var arr02 [4]string
	fmt.Println("打印空数组：", arr01)
	fmt.Println("打印空数组：", arr02)

	// 数组赋值使用下标赋值，默认从0开始
	arr01[0] = 1
	arr01[1] = 2
	arr01[2] = 3
	fmt.Println("打印赋值后的数组：", arr01)

	// 数组按照下标取值
	fmt.Println("数组，下标取值:", arr01[0])

	// 数组的常用方法
	// - len() 获取数组长度
	fmt.Println("数组长度：", len(arr01))
	// - cap() 获取数组容量
	fmt.Println("数组容量：", cap(arr01))

	// 修改数组某个下标数值
	arr01[0] = 10
	fmt.Println("修改后的数组：", arr01)

	// 初始化数组的几种方式
	// - 1 方式
	var arr03 [10]int
	fmt.Println("初始化数组1", arr03)

	// - 2 方式
	var arr04 = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	fmt.Println("初始化数组2", arr04)

	// - 3 方式
	arr05 := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	fmt.Println("初始化数组3", arr05)

	// - 4 方式 ... 自动推导长度,容量
	var arr06 = [...]int{1, 3, 4, 1, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 4}
	fmt.Println("初始化数组4", arr06)
	fmt.Println("初始化数组4,长度", len(arr06))
	fmt.Println("初始化数组4,容量", cap(arr05))

	// -5 方式。 给数组 某几个index 下标赋值 {下标：数值，下标：数值，下标：数值....}
	var arr007 [5]int
	arr007 = [5]int{0: 2, 2: 3}
	fmt.Println(arr007)
}

数组遍历

• for i 下标
• for range 循环
• 下标手动遍历

package main

import "fmt"

func main() {
	// 遍历数组
	// 1. for i 下标
	// 2. for range 循环
	// 3. 下标手动遍历

	var arrErgodic001 = [5]int{1, 2, 3, 4, 5}

	fmt.Println("手动下标取值：", arrErgodic001[0])
	fmt.Println("手动下标取值：", arrErgodic001[1])
	fmt.Println("手动下标取值：", arrErgodic001[2])
	fmt.Println("手动下标取值：", arrErgodic001[3])
	fmt.Println("手动下标取值：", arrErgodic001[4])
	//fmt.Println(arrErgodic001[5]) // 下标溢出。invalid argument: index 5 out of bounds [0:5]

	for i := 0; i < len(arrErgodic001); i++ {
		fmt.Println("for i 循环打印：", arrErgodic001[i])
	}

	// for range 自动迭代。【一个接收参数默认获取的是数据的下标】
	for index, value := range arrErgodic001 {
		// index 表示：数据下标
		// value 表示：该下标对应的数据
		fmt.Println("for range 打印：", index, value)
	}
}

数组 copy

• 数组重新赋值，会拷贝新的内存空间

package main

import "fmt"

func main() {
	// 数组重新赋值，会拷贝新的内存空间
	var arrCopy = [10]int{1, 2, 3, 4, 5}
	fmt.Println(arrCopy)
	// 数组变量 内存地址指向数组第一个元素的内存地址
	fmt.Printf("%p\n", &arrCopy)    // 0xc0000b8000
	fmt.Printf("%p\n", &arrCopy[0]) // 0xc0000b8000
	fmt.Printf("%p\n", &arrCopy[1]) // 0xc0000b8008
	// 打印数组类型
	fmt.Printf("%T\n", arrCopy) // [10]int

	arrCopy1 := arrCopy
	fmt.Printf("%p\n", &arrCopy1) // 0xc0000b80f0  新地址
	fmt.Printf("%T\n", arrCopy1)  // [10]int

	// 修改  arrCopy 不影响 arrCopy1
	arrCopy[0] = 10000
	fmt.Println("【值拷贝】arrCopy", arrCopy)
	fmt.Println("【值拷贝】arrCopy1", arrCopy1)
}

数组排序

• 冒泡排序

package main

import "fmt"

func main() {

	var arrSort = [10]int{16, 64, 23, 45, 67, 21, 22, 33, 1}
	fmt.Printf("%T", arrSort)
	fmt.Println("排序数组 【冒泡排序】：")

	// 冒泡排序

	// 控制循环次数
	for i1 := 1; i1 < len(arrSort); i1++ {
		// n*n-1，比较前后两个数据的大小
		for j1 := 0; j1 < len(arrSort)-i1; j1++ {
			fmt.Printf("外层：%d, 内层：第%d圈：比较：%d 和 %d\n", i1, j1, arrSort[j1], arrSort[j1+1])
			if arrSort[j1] > arrSort[j1+1] {
				arrSort[j1], arrSort[j1+1] = arrSort[j1+1], arrSort[j1]
			}
			fmt.Println()
			fmt.Printf("【第%d圈】：冒泡排序后的结果:%d\n", i1, arrSort)
			fmt.Println()

		}

	}
	fmt.Println("冒泡排序后的结果：", arrSort)
}

多维数组

• 嵌套结构的数组

package main

import "fmt"

func main() {
	/*
		多维数组
	*/

	// 定义二维数组
	twoDimensionalArr := [3][4]int{
		{2, 2, 3, 5},
		{1, 2, 3, 4},
		{1, 2, 3, 7},
	}
	fmt.Println("二维数组：", twoDimensionalArr)
	fmt.Println("二维数组取值：", twoDimensionalArr[0])
	fmt.Println("二维数组取值：", twoDimensionalArr[0][0])

	// for i 遍历二维数组
	for i := 0; i < len(twoDimensionalArr); i++ {
		for j := 0; j < len(twoDimensionalArr[i]); j++ {
			fmt.Println("for i【二维数组】：", twoDimensionalArr[i][j])
		}
	}
	// for range 遍历二维数组
	for index, v2 := range twoDimensionalArr {
		fmt.Println("for range【二维数组】：", index, v2)

	}
	// 定义三维数组
	threeDimensionalArr := [3][4][2]int{
		{{3, 2}, {3, 4}, {5, 6}, {5, 6}},
		{{1, 2}, {3, 4}, {5, 6}, {5, 6}},
		{{1, 2}, {3, 4}, {5, 6}, {5, 6}},
	}
	fmt.Println("三维数组:", threeDimensionalArr)
	fmt.Println("三维数组取值:", threeDimensionalArr[0])
	fmt.Println("三维数组取值:", threeDimensionalArr[0][0])
	fmt.Println("三维数组取值:", threeDimensionalArr[0][0][0])

}