在 Go 语言中,数组和切片是两个常用的数据结构。它们都可以用于存储一组相同类型的元素,但在底层实现和使用方式上存在一些重要的区别。本文将深入探讨 Go 语言数组和切片的区别,包括它们的定义、内存布局、长度和容量、初始化和操作等方面。通过全面了解这两种数据结构的特性,能够更好地在实际开发中选择和使用合适的数据结构,提高代码的效率和可维护性。

1. 数组的定义和特性

1.1 数组的定义

数组是一种固定长度的数据结构,用于存储具有相同类型的元素。在 Go 语言中,数组的定义形式为:

 var arrayName [length]elementType

其中,arrayName 是数组的名称,length 是数组的长度,elementType 是数组元素的类型。例如,下面是一个包含 5 个整数的数组的定义:

 var numbers [5]int

1.2 数组的特性

  • 数组的长度在定义后是不可更改的,因此它是一个固定大小的容器。
  • 数组的内存布局是连续的,元素按照其定义的顺序依次存储。
  • 可以通过索引访问和修改数组中的元素。

2. 切片的定义和特性

2.1 切片的定义

切片是一个可变长度的序列,它是基于数组的抽象。在 Go 语言中,切片的定义形式为:

 var sliceName []elementType

其中,sliceName 是切片的名称,elementType 是切片元素的类型。切片没有固定的长度,可以根据需要动态增加或减少。切片底层依赖数组,但与数组相比,切片提供了更灵活和方便的操作方法。

2.2 切片的特性

  • 切片的长度表示切片当前包含的元素个数。
  • 切片的容量表示切片底层数组的大小,即切片可以访问的元素个数。
  • 切片的内存布局包含了一个指向底层数组的指针、长度和容量信息。
  • 可以通过索引访问和修改切片中的元素。
  • 切片提供了方便的添加和删除元素的方法。

3. 数组和切片的内存布局

3.1 数组的内存布局

数组是一段连续的内存块,元素依次排列在内存中。例如,对于一个包含 5 个整数的数组,它们在内存中的布局是这样的:

在内存中,数组的元素按照其定义的顺序依次存储,每个元素占据相同大小的内存空间。数组是一个由固定长度的特定类型元素组成的序列,一个数组可以由零个或多个元素组成。数组的长度是数组类型的组成部分。因为数组的长度是数组类型的组成部分,不同长度或不同类型的数据组成的数组都是不同的类型。例如:[5]int 和 [6]int 是不同类型的数组,[5]string 和 [5]int 也是不同类型的数组。

3.2 切片的内存布局

简单地说,切片(slice)就是一种简化版的动态数组。因为动态数组的长度不固定,所以切片的长度自然也就不能是类型的组成部分了。数组虽然有适用的地方,但是数组的类型和操作都不够灵活,因此在 Go 代码中数组使用的并不是很多,而切片则使用的相当广泛。

我们看看切片的结构定义,即 reflect.SliceHeader:

 type SliceHeader struce {
     Data uintptr
     Len int
     Cap int
 }

切片是一种引用类型,它有三个属性:

  • 指针(Pointer):指向底层数组的起始位置的指针。
  • 长度(Length):切片当前包含的元素个数。
  • 容量(Capacity):切片底层数组的大小,即切片可以访问的元素个数。

通过这些信息,切片可以动态调整自己的长度,并访问底层数组中的元素。需要注意的是,切片的容量可以大于长度,表示切片中剩余的可用空间。

下图展示了对于一个包含 5 个整数的切片,它们在内存中的布局是这样的:

4. 数组和切片的长度和容量

4.1 数组的长度和容量

数组的长度在定义时就确定了,无法更改。我们可以使用内置的 len 函数获取数组的长度。例如:

 var numbers [5]int
 length := len(numbers)
 fmt.Println(length) // 输出:5

由于数组的长度是固定的,所以它没有容量的概念。每个数组都有确切的大小,无法在运行时动态改变。

4.2 切片的长度和容量

切片具有动态调整长度的能力。在创建切片时,可以指定切片的长度和容量,也可以根据已有的数组或切片创建切片。

切片的长度表示切片当前包含的元素个数,可以通过内置的 len 函数获取。切片的容量表示切片底层数组的大小,可以通过内置的 cap 函数获取。

 array := [5]int{1, 2, 3, 4, 5}
 slice := array[1:3] // 创建一个切片,包含数组中索引为1和2的元素
 length := len(slice)
 capacity := cap(slice)
 fmt.Println(length)   // 输出:2
 fmt.Println(capacity) // 输出:4

在上面的例子中,切片 slice 的长度为2,因为它包含了数组中索引为1和2的两个元素。切片的容量为4,因为它底层数组的大小为5,从索引1开始的剩余空间为4。

当切片的长度超过容量时,切片会自动扩容以适应新的元素。这是由 Go 语言的运行时系统自动处理的,开发者无需手动管理内存。当切片扩容时,系统会创建一个新的更大的底层数组,并将旧数组中的元素复制到新数组中。

5. 数组和切片的初始化

5.1 数组的初始化

数组的初始化可以通过以下几种方式进行:

使用数组字面量(Array Literal)初始化数组的每个元素。

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

根据索引初始化数组的特定元素。

 var numbers [5]int
 numbers[0] = 1
 numbers[1] = 2

5.2 切片的初始化

切片的初始化可以通过以下几种方式进行:

使用切片字面量(Slice Literal)初始化切片。

 slice := []int{1, 2, 3, 4, 5}

基于已有的数组或切片创建切片。

 array := [5]int{1, 2, 3, 4, 5}
 slice := array[1:3] // 创建一个切片,包含数组中索引为1和2的元素

使用内置的 make 函数创建指定长度和容量的切片。

 slice := make([]int, 5)       // 创建一个长度为5的切片,初始值为0
 slice := make([]int, 5, 10)   // 创建一个长度为5、容量为10的切片

6. 数组和切片的操作

6.1 访问元素

数组和切片都可以通过索引来访问其中的元素。索引从0开始,范围是0到长度减1。以下是访问数组和切片元素的示例:

 numbers := [5]int{1, 2, 3, 4, 5}
 fmt.Println(numbers[0]) // 输出:1
 ​
 slice := numbers[1:3]
 fmt.Println(slice[1]) // 输出:3

6.2 修改元素

数组和切片的元素都可以被修改。通过索引将新值赋给相应的元素即可。以下是修改数组和切片元素的示例:

 numbers := [5]int{1, 2, 3, 4, 5}
 numbers[2] = 10 // 修改数组中索引为2的元素为10
 fmt.Println(numbers) // 输出:[1 2 10 4 5]
 ​
 slice := numbers[1:3]
 slice[0] = 20 // 修改切片中索引为0的元素为20
 fmt.Println(numbers) // 输出:[1 20 10 4 5]

6.3 添加元素

由于数组的长度是固定的,无法直接添加新元素。但可以通过创建一个新的更大的数组,并将旧数组中的元素复制到新数组来实现类似添加元素的效果。

切片则提供了更便捷的方法来添加元素。使用内置的 append 函数可以向切片末尾添加一个或多个元素。append 函数会自动处理切片的扩容和元素的复制。以下是向切片添加元素的示例:

 slice := []int{1, 2, 3}
 slice = append(slice, 4) // 向切片末尾添加元素4
 fmt.Println(slice) // 输出:[1 2 3 4]
 ​
 slice = append(slice, 5, 6, 7) // 向切片末尾添加多个元素
 fmt.Println(slice) // 输出:[1 2 3 4 5 6 7]

6.4 删除元素

数组无法直接删除元素,但可以通过重新赋值的方式间接删除元素。切片则提供了更方便的方法来删除元素。

使用切片的切片操作可以删除指定位置的元素。以下是删除切片中指定元素的示例:

 slice := []int{1, 2, 3, 4, 5}
 slice = append(slice[:2], slice[3:]...) // 删除切片中索引为2的元素
 fmt.Println(slice) // 输出:[1 2 4 5]

通过将索引为2之前的元素和索引为2之后的元素重新拼接在一起,即可删除索引为2的元素。

7. 总结

通过本文的讲解,我们深入理解了 Go 语言数组和切片的区别。数组是固定长度的数据结构,长度不可更改,而切片是可变长度的序列,基于数组的抽象。数组的内存布局是连续的,而切片包含了指向底层数组的指针、长度和容量信息。数组的操作受限,无法直接添加或删除元素,而切片提供了方便的添加和删除元素的方法。切片的扩容由运行时系统自动处理,无需手动管理内存。

通过深入理解数组和切片的区别,我们能够更好地选择和使用合适的数据结构,提高代码的效率和可维护性。同时,我们也掌握了数组和切片的初始化、访问、修改、添加和删除等基本操作。

您可能感兴趣的文章: