/*
01-arrays.go - Go 语言数组详解

学习目标：
1. 理解数组的概念和特性
2. 掌握数组的声明和初始化
3. 学会数组的基本操作
4. 了解数组的内存布局
5. 掌握数组的实际应用场景

知识点：
- 数组的定义和特性
- 数组的声明和初始化方式
- 数组的访问和修改
- 数组的长度和容量
- 多维数组
- 数组的比较和拷贝
- 数组 vs 切片的区别
*/

package main

import "fmt"

func main() {
	fmt.Println("=== Go 语言数组详解 ===\n")
	
	// 演示数组的基本概念
	demonstrateBasicArrays()
	
	// 演示数组的声明和初始化
	demonstrateArrayDeclaration()
	
	// 演示数组的操作
	demonstrateArrayOperations()
	
	// 演示多维数组
	demonstrateMultiDimensionalArrays()
	
	// 演示数组的特性
	demonstrateArrayProperties()
	
	// 演示数组的实际应用
	demonstratePracticalApplications()
	
	// 演示数组 vs 切片
	demonstrateArrayVsSlice()
}

// demonstrateBasicArrays 演示数组的基本概念
func demonstrateBasicArrays() {
	fmt.Println("1. 数组的基本概念:")
	
	// 数组的基本特性
	fmt.Printf("   数组的基本特性:\n")
	fmt.Printf("     - 固定长度的元素序列\n")
	fmt.Printf("     - 元素类型相同\n")
	fmt.Printf("     - 长度是类型的一部分\n")
	fmt.Printf("     - 零值是所有元素都为零值的数组\n")
	fmt.Printf("     - 值类型，赋值和传参会拷贝整个数组\n")
	
	// 基本数组示例
	fmt.Printf("   基本数组示例:\n")
	
	var numbers [5]int // 声明长度为5的整数数组
	fmt.Printf("     声明数组: %v\n", numbers)
	fmt.Printf("     数组长度: %d\n", len(numbers))
	fmt.Printf("     数组类型: %T\n", numbers)
	
	// 数组元素访问
	numbers[0] = 10
	numbers[1] = 20
	numbers[2] = 30
	fmt.Printf("     修改元素后: %v\n", numbers)
	fmt.Printf("     第一个元素: %d\n", numbers[0])
	fmt.Printf("     最后一个元素: %d\n", numbers[len(numbers)-1])
	
	fmt.Println()
}

// demonstrateArrayDeclaration 演示数组的声明和初始化
func demonstrateArrayDeclaration() {
	fmt.Println("2. 数组的声明和初始化:")
	
	// 方式1: 声明后赋值
	fmt.Printf("   方式1 - 声明后赋值:\n")
	var arr1 [3]int
	arr1[0] = 1
	arr1[1] = 2
	arr1[2] = 3
	fmt.Printf("     arr1: %v\n", arr1)
	
	// 方式2: 声明时初始化
	fmt.Printf("   方式2 - 声明时初始化:\n")
	var arr2 = [3]int{10, 20, 30}
	fmt.Printf("     arr2: %v\n", arr2)
	
	// 方式3: 短变量声明
	fmt.Printf("   方式3 - 短变量声明:\n")
	arr3 := [4]string{"Go", "Python", "Java", "C++"}
	fmt.Printf("     arr3: %v\n", arr3)
	
	// 方式4: 自动推断长度
	fmt.Printf("   方式4 - 自动推断长度:\n")
	arr4 := [...]int{1, 2, 3, 4, 5} // ... 让编译器计算长度
	fmt.Printf("     arr4: %v (长度: %d)\n", arr4, len(arr4))
	
	// 方式5: 指定索引初始化
	fmt.Printf("   方式5 - 指定索引初始化:\n")
	arr5 := [5]int{1: 10, 3: 30, 4: 40} // 指定索引1,3,4的值
	fmt.Printf("     arr5: %v\n", arr5)
	
	// 方式6: 混合初始化
	fmt.Printf("   方式6 - 混合初始化:\n")
	arr6 := [...]string{0: "first", 2: "third", "fourth"} // 混合指定索引和顺序
	fmt.Printf("     arr6: %v (长度: %d)\n", arr6, len(arr6))
	
	// 不同类型的数组
	fmt.Printf("   不同类型的数组:\n")
	boolArray := [3]bool{true, false, true}
	floatArray := [4]float64{1.1, 2.2, 3.3, 4.4}
	stringArray := [2]string{"hello", "world"}
	
	fmt.Printf("     布尔数组: %v\n", boolArray)
	fmt.Printf("     浮点数组: %v\n", floatArray)
	fmt.Printf("     字符串数组: %v\n", stringArray)
	
	fmt.Println()
}

// demonstrateArrayOperations 演示数组的操作
func demonstrateArrayOperations() {
	fmt.Println("3. 数组的操作:")
	
	// 数组遍历
	fmt.Printf("   数组遍历:\n")
	fruits := [4]string{"apple", "banana", "cherry", "date"}
	
	// 使用索引遍历
	fmt.Printf("     使用索引遍历:\n")
	for i := 0; i < len(fruits); i++ {
		fmt.Printf("       fruits[%d] = %s\n", i, fruits[i])
	}
	
	// 使用 range 遍历
	fmt.Printf("     使用 range 遍历:\n")
	for index, value := range fruits {
		fmt.Printf("       fruits[%d] = %s\n", index, value)
	}
	
	// 只要值，忽略索引
	fmt.Printf("     只要值，忽略索引:\n")
	for _, fruit := range fruits {
		fmt.Printf("       水果: %s\n", fruit)
	}
	
	// 只要索引，忽略值
	fmt.Printf("     只要索引，忽略值:\n")
	for index := range fruits {
		fmt.Printf("       索引: %d\n", index)
	}
	
	// 数组修改
	fmt.Printf("   数组修改:\n")
	numbers := [5]int{1, 2, 3, 4, 5}
	fmt.Printf("     原始数组: %v\n", numbers)
	
	// 修改单个元素
	numbers[2] = 99
	fmt.Printf("     修改索引2: %v\n", numbers)
	
	// 批量修改
	for i := range numbers {
		numbers[i] *= 2
	}
	fmt.Printf("     全部乘以2: %v\n", numbers)
	
	// 数组查找
	fmt.Printf("   数组查找:\n")
	target := "cherry"
	found := false
	foundIndex := -1
	
	for i, fruit := range fruits {
		if fruit == target {
			found = true
			foundIndex = i
			break
		}
	}
	
	if found {
		fmt.Printf("     找到 '%s' 在索引 %d\n", target, foundIndex)
	} else {
		fmt.Printf("     未找到 '%s'\n", target)
	}
	
	fmt.Println()
}