Go数组

1. 数组的创建和使用

package main

import "fmt"

func main() {
	/*
		数据类型：
			基本类型：整数，浮点，布尔，字符串
			复合类型：array，slice，map，struct，pointer，function，channel。。。

		数组：
			1.概念：存储一组相同数据类型的数据结构
					理解为容器，存储一组数据
			2.语法：
					var 数组名 [长度] 数据类型
					var 数组名 = [长度] 数据类型{元素1，元素2，。。。}
					数组名 := [...]数据类型{元素。。。}

			3.通过下标访问
				下标，也叫索引：index，
				默认从0开始的整数，直到长度减1
				数组名[index]
					赋值
					取值

				不能越界：[0,长度-1]

			4.长度和容量：go语言的内置函数
				len(array/map/slice/string)，长度
				cap()，容量
	 */

	var num1 int
	num1 = 100

	num1 = 200
	fmt.Println(num1)
	fmt.Printf("%p
",&num1)

	//step1：创建数组
	var arr1 [4] int
	fmt.Printf("%p
",&arr1)
	//step2：数组的访问
	arr1[0] = 1
	arr1[1] = 2
	arr1[2] = 3
	arr1[3] = 4
	fmt.Println(arr1[0])//打印第一个数值
	fmt.Println(arr1[2])//打印第三个数值
	//fmt.Println(arr1[4]) //invalid array index 4 (out of bounds for 4-element array)

	fmt.Println("数组的长度：",len(arr1)) //容器中实际存储的数据量
	fmt.Println("数组的容量：",cap(arr1)) //容器中能够存储的最大的数量
	//因为数组定长，长度和容量相同
	arr1[0] = 100
	fmt.Println(arr1[0])

	//数组的其他创建方式
	var a [4] int //同 var a= [4] int
	fmt.Println(a) //[0 0 0 0]

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

	var c = [5]int{1,2,4}
	fmt.Println(c) //[1 2 4 0 0]

	var d = [5]int{1:1,3:2}
	fmt.Println(d) //[0 1 0 2 0]

	var e = [5]string{"rose","王二狗","ruby"}
	fmt.Println(e) //[rose 王二狗 ruby  ]

	f := [...]int{1,2,3,4,5}
	fmt.Println(f) //[1 2 3 4 5]
	fmt.Println(len(f)) //5
	g:=[...]int{1:3,6:5}
	fmt.Println(g) //[0 3 0 0 0 0 5]
	fmt.Println(len(g)) //7
}

2. 数组的遍历

package main

import "fmt"

func main() {
	/*
	数组的遍历：
		依次访问数组中的元素
		方法一：arr[0],arr[1],arr[2]....

		方法二：通过循环，配合下标
			for i:=0;i<len(arr);i++{
				arr[i]
			}
		方法三：使用range
			range，词义"范围"
			不需要操作数组的下标，到达数组的末尾，自动结束for range循环。
				每次都数组中获取下标和对应的数值。

	 */
	arr1 := [5]int{1, 2, 3, 4, 5}
	fmt.Println(arr1[0])
	fmt.Println(arr1[1])
	fmt.Println(arr1[2])
	fmt.Println(arr1[3])
	fmt.Println(arr1[4])

	fmt.Println("---------------")
	for i := 0; i < len(arr1); i++ {
		arr1[i] = i*2 + 1
		fmt.Println(arr1[i])
	}
	fmt.Println(arr1)

	fmt.Println("----------------")
	for index, value := range arr1 {
		fmt.Printf("下标是：%d,数值是:%d
", index, value)
	}

	sum := 0
	for _, v := range arr1 {
		sum += v
	}
	fmt.Println(sum)
}

3. 数组是值类型

package main

import "fmt"

func main() {
	/*
		数据类型：
			基本类型：int，float，string，bool。。
			复合类型：array，slice，map，function，pointer，channel。。

		数组的数据类型：
			[size]type

		值类型：理解为存储的数值本身
			将数据传递给其他的变量，传递的是数据的副本(备份)
				int,float,string,bool,array
		引用类型：理解为存储的数据的内存地址
				slice，map。。
	 */

	//1.数据类型
	num := 10
	fmt.Printf("%T
", num)

	arr1 := [4]int{1, 2, 3, 4}
	arr2 := [3]float64{2.15, 3.18, 6.19}
	arr3 := [4]int{5, 6, 7, 8}
	arr4 := [2]string{"hello", "world"}
	fmt.Printf("%T
", arr1) //[4]int
	fmt.Printf("%T
", arr2) //[3]float64
	fmt.Printf("%T
", arr3) //[4]int
	fmt.Printf("%T
", arr4) //[2]string

	//2.赋值
	num2 := num            //值传递
	fmt.Println(num, num2) //10 10
	num2 = 20
	fmt.Println(num, num2) //10 20

	//数组呢
	arr5 := arr1 //值传递
	fmt.Println(arr1)
	fmt.Println(arr5)

	arr5[0] = 100
	fmt.Println(arr1)
	fmt.Println(arr5)

	a := 3
	b := 4
	fmt.Println(a == b)       //比较a和b的数值是否相等
	fmt.Println(arr5 == arr1) //比较数组的对应下标位置的数值是否相等
	//fmt.Println(arr1 == arr2) //invalid operation: arr1 == arr2 (mismatched types [4]int and [3]float64)

}

4. 数组排序（冒泡排序）

package main

import "fmt"

func main() {
	/*
	数组的排序：
		让数组中的元素具有一定的顺序。

		arr :=[5]int{15,23,8,10,7}
			升序：[7,8,10,15,23]
			将序：[23,15,10,8,7]

	排序算法：
		冒泡排序，插入排序，选择排序，希尔排序，堆排序，快速排序。。。。

	冒泡排序：（Bubble Sort）
		依次比较两个相邻的元素，如果他们的顺序（如从大到小）就把他们交换过来。
	 */
	arr := [5]int{15, 23, 8, 10, 7}
	////第一轮排序
	//for j := 0; j < 4; j++ {
	//	if arr[j] > arr[j+1] {
	//		arr[j], arr[j+1] = arr[j+1], arr[j]
	//	}
	//}
	//fmt.Println(arr)
	//
	////第二轮排序
	//for j:=0;j<3;j++{
	//	if arr[j] > arr[j+1] {
	//		arr[j], arr[j+1] = arr[j+1], arr[j]
	//	}
	//}
	//fmt.Println(arr)

	for i:=1;i<len(arr);i++{
		for j := 0; j < len(arr)-i; j++ {
			if arr[j] > arr[j+1] {
				arr[j], arr[j+1] = arr[j+1], arr[j]
			}
		}
		fmt.Println(arr)
	}

}
//[15 8 10 7 23] //第一轮，最大的23被找到
//[8 10 7 15 23] //第二轮，最大的15被找到（因为你len()-1,23最大不用比了）
//[8 7 10 15 23]
//[7 8 10 15 23]

5. 多维数组

package main

import "fmt"

func main() {
	/*

	一维数组：存储的多个数据是数值本身
		a1 :=[3]int{1,2,3}

	二维数组：存储的是一维的一维
		//3个一维数组，每个一维数组长度为4
		a2 := [3][4]int{{},{},{}}

		该二维数组的长度，就是3。
		存储的元素是一维数组，一维数组的元素是数值，每个一维数组长度为4。

	多维数组：。。。


	 */
	a2 := [3][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}
	fmt.Println(a2)
	fmt.Printf("二维数组的地址：%p
", &a2)
	fmt.Printf("二维数组的长度：%d
", len(a2))

	fmt.Printf("一维数组的长度：%d
", len(a2[0]))
	fmt.Println(a2[0][3]) // 4
	fmt.Println(a2[1][2]) //7
	fmt.Println(a2[2][1]) // 10

	//遍历二维数组
	for i:=0;i<len(a2);i++{
		for j:=0;j<len(a2[i]);j++{
			fmt.Print(a2[i][j],"	")
		}
		fmt.Println()
	}
	fmt.Println("---------------------")
	//for range 遍历二维数组
	for _,arr := range a2{
		for _,val := range arr{
			fmt.Print(val,"	")
		}
		fmt.Println()
	}
	
	//三维数组
	//第一个表示有几个二维数组
	//中间表示有几个一维数组
	//最后一个表示长度
	var threedim [2][3][2]int
	fmt.Println(threedim) //[[[0 0] [0 0] [0 0]] [[0 0] [0 0] [0 0]]]
	var threedim2 [3][2][2]int
	fmt.Print(threedim2) // [[[0 0] [0 0]] [[0 0] [0 0]] [[0 0] [0 0]]]
}