12、GO语言入门-

1.数组的概念

Go语言提供了数组类型的数据结构。数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整形、字符串或者自定义类型。
数组元素可以通过索引 (位置) 来读取 (或者修改)，索引从0开始第一个元素索引为0，第二个索引为 1，以此类推。数组的下标取值范围是从0开始，到长度减1。
数组一旦定义后，大小不能更改。

2.语法格式

// 写法1：
var variable_name [SIZE] variable_type

var arr1 [3]int
arr1[0] = 1
arr1[1] = 2
arr1[2] = 3
fmt.Println(arr1[0])
fmt.Println(arr1[1])
fmt.Println(arr1[2])

// 写法2：
var variable_name = [SIZE] variable_type {ele1,ele2......}
var arr2 = [5]int{1, 2, 3}
fmt.Println(arr2)
fmt.Println(arr2[2])
// 没赋值的地方会给默认值
fmt.Println(arr2[4])
// 注意：获取数组元素时，下标不要越界了
// fmt.Println(arr2[5])

// 写法3：
variable_name := [...] variable_type {元素......}
// 这种方式可以根据元素的个数自行推断数组长度
arr3 := [...]int{10, 20, 30}
fmt.Println(arr3)
fmt.Println(arr3[2])
fmt.Println(len(arr3))
fmt.Println(cap(arr3))

// 我们还可以指定位置初始化数据
arr4 := [...]int{1: 100, 3: 200, 9: 500}
fmt.Println(arr4)
fmt.Println(arr4[9])
fmt.Println(len(arr4))
fmt.Println(cap(arr4))

3.内置函数

• len(array/map/slice/string)：容器中实际存储的数据量 ==> 长度
• cap()：容器中能够存储的最大数量 ==> 容量
  值得注意的是：这两个内置函数不仅仅是在数组中有

4.数组的遍历

arr1 := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	// 方式一：
	for i := 0; i < len(arr1); i++ {
		fmt.Println(i, "位置的元素为：", arr1[i])
	}

	// 方式二：for_range
	for index, value := range arr1 { // 有一说一，这玩意儿怎么看怎么像vue中的v-for、thymeleaf中的for
		fmt.Printf("下标是：%d,值为：%d \n", index, value)
	}

	// 下划线舍弃index
	sum := 0
	for _, value := range arr1 {
		sum += value
	}
	fmt.Println("sum:", sum)

5.数组是值类型

数据类型:

• 基本类型:int，float，string，bool。
• 复合类型: array，slice，map，function，pointer，channel。

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

值类型:理解为存储的数值本身将数据传递给其他的变量，传递的是数据的副本(备份)
例如：int,float,string,bool,array

引用类型:理解为存储的数据的内存地址
例如：slice，map。。

arr2 := [4]int{1, 2}
arr3 := [4]string{"zs", "ls"}
arr4 := [4]float64{1, 2, 3}
arr5 := [4]int{1, 2, 3}

fmt.Printf("%T \n", arr2)
fmt.Printf("%T \n", arr3)
fmt.Printf("%T \n", arr4)
fmt.Printf("%T \n", arr5)

// 修改arr5的值不会影响arr6,这里和Java中不太一样
arr6 := arr5
fmt.Println("arr6的值为：", arr6)
arr5[2] = 10
fmt.Println("arr5的值为：", arr5)
fmt.Println("arr6的值为：", arr6)

fmt.Println(arr2 == arr5)

arr2[2] = 10
fmt.Println(arr2 == arr5)

6.数组的排序

arrayOne := [...]int{100, 120, 98, 33, 76, 43, 9, 23, 37, 98}

	// 冒泡排序
	for i := 0; i < len(arrayOne); i++ {
		for j := 0; j < len(arrayOne)-i-1; j++ {
			if arrayOne[j] > arrayOne[j+1] {
				arrayOne[j], arrayOne[j+1] = arrayOne[j+1], arrayOne[j]
			}
		}
	}

	fmt.Println(arrayOne)

7.二维数组

/**
 * @author ly (个人博客:https://www.cnblogs.com/qbbit)
 * @date 2023/4/2  20:02
 * @tags 喜欢就去努力的争取
 */
package main

import "fmt"

func main() {

	// 以为数组定义方式
	var arr1 = [3]int{1, 2, 3}
	fmt.Printf("数组的类型：%T,\t数组的内存地址：%p,\t数组的值：%d", arr1, arr1, arr1)

	/**
	二维数组定义方式
		值得注意的是二位数组里的存的是一维数组
		以为数组里存的才是最后的元素值
	*/
	var arr2 = [3][4]float64{{1.1, 1.2, 1.3, 1.4}, {2.1, 2.2, 2.3, 2.4}, {3.1, 3.2, 3.3, 3.4}}
	arr3 := [1][2]int{{10, 20}}
	arr4 := [...][7]int{{2: 5, 6: 9}, {1: 5, 5: 9}}

	// 获取一维数组
	float64Arr1 := arr2[1]
	fmt.Println(float64Arr1)

	// 获取元素值
	result := arr2[2][2]
	fmt.Println(result)

	// 获取以为二维数组中一维数组的个数
	fmt.Println("一维数组的个数：", len(arr3))

	// 获取一维数组中的元素个数
	fmt.Println("以为数组中元素的个数：", len(arr3[0]))

	// 输出内存地址
	fmt.Printf("内存地址为：%p \n", &arr4)

	// 普通方式遍历二维数组
	for j := 0; j < len(arr2); j++ {
		for i := 0; i < len(arr2[j]); i++ {
			fmt.Println("普通方式遍历二维数组", arr2[j][i])
		}
	}

	// for range 方式遍历
	for _, inner := range arr2 {
		for _, value := range inner {
			fmt.Println("for range 方式遍历二维数组", value)
		}
	}
}