Golang开发-数组和列表

数组

在 Go 语言中，数组（array）是一种固定长度、具有相同类型的数据序列。数组的长度是在创建数组时指定的，并且在整个数组的生命周期中保持不变。下面是关于 Go 语言数组的详细解释：

声明数组

Go 语言中声明数组的语法如下：

var arrayName [length]elementType

其中，arrayName 是数组的名称，length 是数组的长度，elementType 是数组元素的类型。例如，var numbers [5]int 声明了一个包含 5 个整数的数组。

初始化数组

可以通过以下方式对数组进行初始化：

使用数组字面量初始化数组：

arrayName := [length]elementType{element1, element2, ..., elementN}

例如，numbers := [5]int{1, 2, 3, 4, 5} 初始化了一个包含 1 到 5 的整数数组。
省略长度的数组初始化：

arrayName := [...]elementType{element1, element2, ..., elementN}

在省略长度的情况下，Go 语言会根据提供的初始化值自动推断出数组的长度。例如，numbers := […]int{1, 2, 3, 4, 5} 初始化了一个包含 5 个整数的数组。
按索引初始化数组：

var arrayName [length]elementType
arrayName[index] = value

可以通过指定索引来初始化数组的特定位置。例如，var numbers [5]int; numbers[0] = 1 初始化了一个包含 5 个整数的数组，并将第一个元素设置为 1。
访问数组元素：
可以使用索引操作符 [] 来访问数组中的元素。索引从 0 开始，最大索引为数组长度减 1。例如，numbers[2] 表示数组 numbers 的第三个元素。

数组长度

可以使用 len 函数获取数组的长度。例如，length := len(numbers) 返回数组 numbers 的长度。

数组是值类型：
在 Go 语言中，数组是值类型，当将一个数组赋值给另一个数组或将数组作为函数参数传递时，会进行数组的复制，而不是引用。这意味着对一个数组的修改不会影响到其他数组。

数组的遍历

可以使用 for 循环结构来遍历数组。例如：

for index, value := range arrayName {
    // 使用 index 和 value
}

在每次迭代中，index 是当前元素的索引，value 是当前元素的值。

多维数组：
Go 语言支持多维数组，可以通过在数组类型后面添加多个维度来声明多维数组。例如，var matrix [3][3]int 声明了一个 3x3 的整数矩阵。

需要注意的是，数组在 Go 语言中是固定长度的，一旦声明后，其长度不能更改。如果需要动态长度的序列，可以使用切片（slice）类型。

	var m = 3
	var n = 4
	var matrix [m][n]int

如上就会报错：Invalid array bound,must be a constant expression
数组的长度必须是一个常量表达式，而不能是变量。在这个例子中，m和n都是变量，因此无法用它们来定义数组的长度。如果要定义一个多维数组，可以使用常量来定义数组的长度

//初始化
arr := [2][3] int{
	{1,2,3},
	{4,5,6},
}

或者通过make来定义

	var m = 3
	var n = 4
	#会生成一个初始化的多维数组
	var matrix = make([][]int, m, n)
	#生成一个全0的多维数组
	for i := 0; i < m; i++ {
		matrix[i] = make([]int, n)
	}

数组作为参数传递给函数

1.形参设定数组大小

func mytest(arr_name [arr_size]data_type)

2.形参不设定数组大小

func mytest(arr_name []data_type)

package main
import  "fmt"
func main(){
	a:= [5] int {1,4,7,9,34}
	fmt.Println("The max number is:",mymax(a))
}

func mymax(arr [5] int) int{
	var i,res int
	for i=0;i<len(arr);i++{
		if (res>arr[i]){
			res=res
		}else{
			res=arr[i]
		}
	}
	return res
}
//The max number is: 34

注意：数组作为函数参数和传递给函数的数组要对应一致！比如：
mymax(arr [] int) int则会报错：

cannot use a (type [5]int) as type []int in argument to mymax

列表

在 Go 语言中，列表（List）通常是指使用切片（Slice）来实现的动态数据结构。切片是一种灵活且方便的数据结构，可以根据需要动态地增加或减少元素数量。

Go 语言的切片可以看作是对底层数组的封装，提供了更多的功能和便利性。切片具有以下特点：

动态大小：切片的大小可以根据需要动态调整，可以随时增加或减少元素数量。

引用语义：切片是对底层数组的引用，即修改切片会直接影响底层数组的内容。

自动扩容：当切片容量不足以容纳新的元素时，切片会自动扩容，分配一个更大的底层数组，并将原有元素复制到新数组中。

切片长度和容量：切片的长度表示当前切片中的元素数量，容量表示底层数组的大小。

Go 语言的切片操作非常方便，可以使用内建函数 make 来创建切片，使用索引访问和修改切片的元素，使用 append 函数追加元素，使用切片表达式进行切片切割等。

下面是一些常见的切片操作示例：

func main() {
	// 创建切片
	slice := make([]int, 0) // 创建一个空切片
	slice2 := []int{1, 2, 3} // 创建并初始化切片

	// 访问和修改元素
	fmt.Println(slice2[0]) // 输出: 1
	slice2[1] = 99
	fmt.Println(slice2) // 输出: [1 99 3]

	// 追加元素
	slice = append(slice, 1)
	slice = append(slice, 2, 3, 4)
	fmt.Println(slice) // 输出: [1 2 3 4]

	// 切片切割
	subSlice := slice2[1:3] // 从索引 1 开始到索引 3（不包含）
	fmt.Println(subSlice) // 输出: [99 3]

	// 获取切片长度和容量
	fmt.Println(len(slice2)) // 输出: 3
	fmt.Println(cap(slice2)) // 输出: 底层数组的容量
}

在上述示例中，我们展示了创建切片、访问和修改元素、追加元素、切片切割以及获取切片的长度和容量等常见操作。