第2章_Go容器和设计思想

授课语音

Go语言 Slice（切片）相关操作

一、切片概述

1.1 什么是切片（Slice）

切片（Slice）是 Go 语言中的一个重要数据类型，它是对数组的一个抽象，并且提供了更灵活的操作。与数组不同，切片的大小是动态的，可以随时增长或缩小。

切片并不是数组，而是对数组的一段连续内存的引用。
切片比数组更灵活，支持动态长度，且不需要事先定义长度。

1.2 切片的定义

切片是通过数组来创建的，可以通过以下方式定义：

var slice []Type

slice 是切片的名称。
Type 是切片元素的类型。

1.3 切片的组成部分

一个切片由三个部分组成：

指向底层数组的指针（元素数据存储位置）
切片的长度（元素的个数）
切片的容量（从切片的起始位置到底层数组末尾的距离）

1.4 切片的特点

切片的长度是可以动态变化的。
切片不需要指定大小，可以根据需要扩展。

二、切片的创建与初始化

2.1 创建切片

2.1.1 使用 `make()` 函数创建切片

slice := make([]int, 5)  // 创建一个长度为 5，元素类型为 int 的切片

make([]int, 5) 创建一个元素类型为 int 的切片，长度为 5，初始元素值为 0。
make([]int, 5, 10) 创建一个切片，长度为 5，容量为 10。

2.1.2 从数组或切片创建

通过切片操作符 [] 从已有数组或切片中创建切片。

arr := [5]int{1, 2, 3, 4, 5}
slice := arr[1:4]  // 创建一个切片，包含 arr 数组的第 2 到第 4 个元素（索引 1 到 3）

2.2 切片的默认值

未初始化的切片是 nil，并且其长度和容量为 0。

var slice []int  // 默认值是 nil，长度和容量均为 0

三、切片的常用操作

3.1 访问切片元素

切片中的元素通过索引进行访问，索引从 0 开始。

slice := []int{10, 20, 30, 40}
fmt.Println(slice[1])  // 访问索引 1 位置的元素，输出：20

3.2 修改切片元素

可以通过索引直接修改切片中的元素。

slice[1] = 50  // 将切片中索引为 1 的元素修改为 50

3.3 切片的长度与容量

切片的长度是指切片中元素的个数。
切片的容量是指切片能够容纳的最大元素个数。

slice := []int{1, 2, 3}
fmt.Println(len(slice))  // 输出：3（切片的长度）
fmt.Println(cap(slice))  // 输出：3（切片的容量）

3.4 切片的追加（`append()`）

append() 函数用于向切片中添加元素。它会自动增加切片的长度，且当切片的容量不足时，Go 会自动为切片分配更多内存。

slice := []int{1, 2, 3}
slice = append(slice, 4)  // 向切片添加元素 4
fmt.Println(slice)  // 输出：[1 2 3 4]

append() 还可以用于追加多个元素：

slice = append(slice, 5, 6, 7)  // 向切片添加多个元素
fmt.Println(slice)  // 输出：[1 2 3 4 5 6 7]

3.5 切片的截取（Slicing）

切片的截取操作是指通过指定一个起始索引和一个结束索引，从一个切片中获取一部分元素。

slice := []int{10, 20, 30, 40, 50}
subSlice := slice[1:4]  // 截取切片中的一部分，从索引 1 到 3（不包含 4）
fmt.Println(subSlice)  // 输出：[20 30 40]

3.6 切片的复制（`copy()`）

copy() 函数可以将一个切片的元素复制到另一个切片中。

slice1 := []int{1, 2, 3}
slice2 := make([]int, len(slice1))  // 创建一个与 slice1 长度相同的切片
copy(slice2, slice1)  // 将 slice1 中的元素复制到 slice2
fmt.Println(slice2)  // 输出：[1 2 3]

四、切片的例子与代码实现

4.1 例子：切片的创建和操作

package main

import "fmt"

func main() {
	// 1. 创建一个切片
	slice := []int{10, 20, 30, 40, 50}
	fmt.Println("原始切片:", slice)

	// 2. 访问和修改切片元素
	fmt.Println("访问索引 2 的元素:", slice[2])
	slice[2] = 35
	fmt.Println("修改后的切片:", slice)

	// 3. 获取切片的长度和容量
	fmt.Println("切片的长度:", len(slice))
	fmt.Println("切片的容量:", cap(slice))

	// 4. 追加元素
	slice = append(slice, 60, 70, 80)
	fmt.Println("追加元素后的切片:", slice)

	// 5. 截取切片
	subSlice := slice[2:5]
	fmt.Println("截取后的切片:", subSlice)

	// 6. 复制切片
	newSlice := make([]int, len(slice))
	copy(newSlice, slice)
	fmt.Println("复制后的切片:", newSlice)
}

输出：

原始切片: [10 20 30 40 50]
访问索引 2 的元素: 30
修改后的切片: [10 20 35 40 50]
切片的长度: 5
切片的容量: 5
追加元素后的切片: [10 20 35 40 50 60 70 80]
截取后的切片: [35 40 50]
复制后的切片: [10 20 35 40 50 60 70 80]

4.2 例子：动态增长切片

package main

import "fmt"

func main() {
	var slice []int

	// 动态添加元素
	for i := 1; i <= 10; i++ {
		slice = append(slice, i)
	}
	fmt.Println("动态增长的切片:", slice)

	// 输出切片的长度和容量
	fmt.Println("切片的长度:", len(slice))
	fmt.Println("切片的容量:", cap(slice))
}