【Go系列】 array、slice 和 map

承上启下

我们上一篇文章中介绍了if和for，这不得练习下，让我们一起来实践一下如何使用 continue 语句来计算100以内的偶数之和。在我们编写代码的过程中，continue 语句将会帮助我们跳过某些不需要的迭代，比如在这个例子中，我们会跳过所有的奇数。

sum := 0
for i := 1; i < 100; i++{
   if i & 1 == 0 {
      continue
   }
   sum += i
}

fmt.Println("the sum is",sum)

开始学习

在编程中，我们经常需要处理一组相同类型的元素，这些元素集合在 Go 语言中有特定的数据结构来表示。今天，我将为大家详细介绍 Go 中的几种集合类型：数组（array）、切片（slice）和映射（map）。

数组

首先，让我们从数组开始。数组是 Go 中最基础的数据结构，它是一组具有相同类型元素的固定长度的序列。数组一旦声明，其长度就不可改变。数组的声明和初始化非常简单，

声明数组

声明数组时，你需要指定数组类型和数组长度。以下是数组的声明方式：

var arrayName [arrayLength]elementType

例如，声明一个长度为 5 的整型数组：

var numbers [5]int

初始化数组

你可以通过多种方式初始化数组：

使用字面量初始化：

var numbers = [5]int{1, 2, 3, 4, 5}
使用 := 简短声明：

numbers := [5]int{1, 2, 3, 4, 5}
自动推断数组长度：

numbers := [...]int{1, 2, 3, 4, 5}
指定索引初始化：

numbers := [5]int{0: 1, 4: 5}

数组的特点

固定长度：数组的长度在声明时确定，之后不能更改。
相同类型元素：数组只能包含相同类型的元素。
内存连续分配：数组元素在内存中是连续分配的，这使得访问数组元素非常高效。

访问数组元素

你可以通过索引来访问数组中的元素，索引从 0 开始：

value := numbers[2] // 获取索引为 2 的元素

遍历数组

你可以使用 for 循环来遍历数组中的所有元素：

for i, value := range numbers {
    fmt.Printf("Index: %d, Value: %d\n", i, value)
}

数组的长度

你可以使用内置的 len 函数来获取数组的长度：

length := len(numbers)

数组的零值

如果数组没有显式初始化，它的元素将被自动设置为其类型的零值。例如，整型数组的零值是 0：

var numbers [5]int // 所有元素都是 0

多维数组

Go 语言也支持多维数组。以下是声明和初始化一个 2x3 的整型数组的示例：

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

数组的局限性

由于数组的长度是固定的，这在某些情况下可能不太灵活。如果需要一个可变长度的集合，可以使用切片（slice）。

切片

接下来是切片，它是一种更为灵活的内置类型，可以看作是动态数组。切片的长度是可变的，它基于数组创建，提供了更多的便利性。下面是如何声明和初始化一个切片：

s := make([]int, 3)      // 创建一个长度为3的整型切片
s[0] = 1                // 切片元素赋值
s[1] = 2
s[2] = 3
s = append(s, 4)        // 向切片追加元素

在 Go 语言中，数组和切片虽然都用于存储一系列相同类型的元素，但它们在内存分配、大小可变性、以及使用方式上存在显著的不同。以下是数组和切片的主要区别：

大小可变性

数组：数组的大小在声明时确定，并且之后不可更改。数组的大小是其类型的一部分，因此 [3]int 和 [4]int 是不同的类型。
切片：切片是动态的，可以在运行时增长或缩小。切片的大小不是其类型的一部分，因此 []int 是所有整型切片的共同类型。

内存分配

数组：数组是值类型，当数组作为函数参数传递时，会传递其值的副本。这意味着对函数内部数组的修改不会影响原始数组。
切片：切片是引用类型，它内部包含一个指向底层数组的指针、切片的长度以及容量。当切片作为函数参数传递时，传递的是指针的副本，因此函数内部对切片的修改会影响原始切片。

初始化

数组：初始化数组时，必须指定其大小，并且可以立即赋予元素值。
切片：切片可以通过字面量、make 函数或从数组中切片来初始化，不需要指定大小。

示例代码

以下是数组和切片的初始化示例：

// 数组
var arr [3]int = [3]int{1, 2, 3}

// 切片
var slice []int = []int{1, 2, 3}
// 或者使用 make 函数
slice := make([]int, 3)

功能差异

数组：由于大小固定，数组在编译时就知道其大小，这使得数组在栈上分配内存是可能的，并且访问数组元素的时间复杂度是 O(1)。
切片：切片提供了更多灵活性，可以通过 append 函数添加元素，或者通过切片操作来获取子切片。切片的底层数组可能是在堆上分配的，访问切片元素的时间复杂度也是 O(1)，但是 append 可能会导致底层数组的重新分配，这通常是 O(n) 操作。

映射

最后，我们来看看映射。映射是 Go 中的关联数组，它将键映射到值。映射的键可以是任何相等性操作符支持的类型，如整数、浮点数、字符串、指针、接口（只要接口内部包含的值是可比较的）、结构体和数组。映射的值可以是任何类型。

声明和初始化

声明 map

声明一个 map 的语法如下：

var mapName map[keyType]valueType

例如，声明一个键为字符串类型，值为整型类型的 map：

var scores map[string]int

初始化 map

在声明 map 之后，你需要通过 make 函数来初始化它，这样才能使用它：

scores = make(map[string]int)

或者，你可以使用简短声明并初始化：

scores := make(map[string]int)

也可以在声明的同时使用字面量进行初始化：

scores := map[string]int{
    "alice":  90,
    "bob":    85,
    "charlie": 88,
}

map 的特点

键的唯一性：在 map 中，每个键都是唯一的，如果尝试插入一个已经存在的键，它会更新该键对应的值。
无序：map 是无序的，每次迭代 map 时，元素的顺序可能会不同。
动态大小：map 的大小是动态的，你可以根据需要添加或删除键值对。
引用类型：map 是引用类型，当你将 map 传递给函数时，实际上传递的是指向底层数据结构的指针。

操作 map

添加元素

scores["alice"] = 90

获取元素

value := scores["alice"]

如果键不存在，将返回该值类型的零值。

检查键是否存在

可以使用逗号-ok idiom 来检查键是否存在于 map 中：

value, exists := scores["alice"]
if exists {
    // 键存在
} else {
    // 键不存在
}

删除元素

使用 delete 函数可以从 map 中删除一个键值对：

delete(scores, "alice")

如果键不存在，delete 函数什么也不做。

遍历 map

使用 for 循环可以遍历 map 中的所有键值对：

for key, value := range scores {
    fmt.Printf("%s: %d\n", key, value)
}

map 的零值

map 的零值是 nil。一个 nil map 没有底层数据结构，并且不能添加元素。在向 map 添加元素之前，你必须使用 make 初始化它。

map 的长度

可以使用内置的 len 函数来获取 map 中键值对的数量：

length := len(scores)

map 的键类型

map 的键可以是任何可以比较的类型，比如整数、浮点数、字符串、指针、接口（只要接口内部包含的值是可比较的）、结构体、数组等。切片、map 和函数不能用作 map 的键，因为这些类型不支持相等性比较。

易错点

在 Go 语言中，数组、切片和 map 是三种常用的数据结构，它们各自有不同的特点和注意事项。以下是一些在使用它们时需要注意的点：

数组（Array）

避免使用过大的数组，因为它们会占用大量栈空间，可能导致栈溢出。
当需要固定大小的数据集合时使用数组。

切片（Slice）

切片扩容时可能会发生内存重新分配，应尽量预分配足够容量以避免频繁扩容。
避免使用过大的切片，因为它们可能会占用大量堆空间。
注意切片的零值是 nil，在使用之前需要初始化。

map（映射）

map 的零值是 nil，nil map 不能用于存储键值对，使用前必须初始化。
在并发环境中，对 map 的读写操作不是线程安全的，需要使用互斥锁或其他同步机制来保护。
使用 delete 删除不存在的键不会产生错误，但检查键是否存在是安全的做法。