当前位置：首页 > news >正文

GO_复合类型---切片

news 2026/7/11 21:37:46

一、切片核心概念

本质：对底层数组的引用，不是值类型，是引用类型
作用：弥补数组长度固定的缺陷，实现动态变长数组
定义：声明时不指定长度，格式[]T（T 为元素类型）

二、切片的创建方式（4 种常用）

1. 从数组 / 切片截取（最基础）

语法：切片名 := 源数组/切片[low:high:max]

low：起始下标（包含），默认 0
high：结束下标（不包含，左闭右开），默认末尾
max：容量上限，默认等于底层数组容量
长度公式：len = high - low
容量公式：cap = max - low

// 示例 array := [...]int{10, 20, 30, 0, 0} // 固定长度数组 slice := array[0:3:5] // len=3-0=3，cap=5-0=5，元素：[10,20,30]

2. 自动推导类型创建

// 直接初始化切片，长度=元素个数，容量=长度 s1 := []int{1, 2, 3, 4, 5}

3. make 函数创建（开发最常用）

语法：make([]T, len, cap)

不指定容量：cap = len
必须指定长度，容量≥长度

s2 := make([]int, 5, 10) // len=5，cap=10 s3 := make([]int, 5) // 无容量，len=cap=5 s4 := []int{} // 空切片，len=0，cap=0

三、切片的长度 (len) 和容量 (cap)

长度 (len)：切片中实际存储的元素个数
容量 (cap)：底层数组从起始位置到末尾的最大可存储元素个数（决定扩容时机）

func main() { a := []int{1, 2, 3, 0, 0} s := a[0:3:5] fmt.Println("len(s) =", len(s)) // 3 fmt.Println("cap(s) =", cap(s)) // 5 s2 := a[1:4:5] fmt.Println("len(s2) =", len(s2)) // 3 (4-1) fmt.Println("cap(s2) =", cap(s2)) // 4 (5-1) }

四、切片截取操作（常用简写）

array := []int{0,1,2,3,4,5,6} s1 := array[:] // 全量截取：low=0,high=len,cap=cap s2 := array[3:6] // 不写max：cap=底层数组容量 s3 := array[:6] // 从0开始到下标6，最常用 s4 := array[3:] // 从下标3开始到末尾

五、切片与底层数组的关系（核心重点）

切片共享底层数组，修改切片元素会直接修改原数组 / 其他切片，属于引用传递。

func main() { a := []int{0,1,2,3,4,5,6,7,8,9} s1 := a[2:5] // [2,3,4]，引用a数组 // 修改切片元素 → 原数组同步修改 s1[1] = 666 fmt.Println("s1 =", s1) // [2,666,4] fmt.Println("a =", a) // 原数组下标3变为666 // 切片再截取 → 仍共享底层数组 s2 := s1[2:7] // [4,5,6,7,8] s2[2] = 777 fmt.Println("a =", a) // 原数组下标6变为777 }

六、append () 追加元素（动态扩容）

append是切片动态扩容的核心函数，超出容量时自动扩容。

1. 基础用法

s1 := []int{} // 空切片 s1 = append(s1, 1) // 追加单个元素 s1 = append(s1, 2, 3) // 追加多个元素

2. 扩容规则

容量不足时，默认以 2 倍容量扩容（小切片）
扩容后会新建底层数组，不再与原数组共享

// 验证扩容机制 func main() { s := make([]int, 0, 1) oldCap := cap(s) for i := 0; i < 8; i++ { s = append(s, i) if newCap := cap(s); oldCap < newCap { fmt.Printf("cap: %d ===> %d\n", oldCap, newCap) oldCap = newCap } } } /* 输出： cap: 1 ===> 2 cap: 2 ===> 4 cap: 4 ===> 8 */

七、copy () 切片复制

解决切片共享底层数组的问题，深拷贝，两个切片完全独立。

func main() { srcSlice := []int{1, 2} // 源切片 dstSlice := []int{6,6,6,6} // 目标切片 copy(dstSlice, srcSlice) // 复制：将源切片元素拷贝到目标切片 fmt.Println("dst =", dstSlice) // [1,2,6,6] }

八、切片作为函数参数

切片是引用类型，函数内修改切片，外部原切片同步修改（无需指针）。

实战：切片初始化 + 冒泡排序

import ( "math/rand" "time" ) // 初始化切片：随机数赋值 func InitData(s []int) { rand.Seed(time.Now().UnixNano()) for i := 0; i < len(s); i++ { s[i] = rand.Intn(100) // 0-99随机数 } } // 冒泡排序：切片做参数，直接修改原切片 func BubbleSort(s []int) { n := len(s) for i := 0; i < n-1; i++ { for j := 0; j < n-i-1; j++ { if s[j] > s[j+1] { s[j], s[j+1] = s[j+1], s[j] // 交换元素 } } } } func main() { // 创建切片 s := make([]int, 10) InitData(s) fmt.Println("排序前：", s) BubbleSort(s) fmt.Println("排序后：", s) }