【Go-补充】实现动态数组：深入理解 slice 与自定义实现

于 2025-06-12 13:59:50 发布
阅读量1k 收藏 18
点赞数 7
CC 4.0 BY-SA版权
分类专栏： Go 文章标签： golang java 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2202_75331338/article/details/148608870

Go 语言实现动态数组：深入理解 slice 与自定义实现

在 Go 语言中，我们经常使用内置的 slice (切片) 来处理可变长度的序列数据。slice 是 Go 语言中一个强大且灵活的数据结构，它在底层是对数组的抽象，提供了动态增长的能力。本文将通过一个实际的例子，带你深入理解 slice 的工作原理，并展示如何基于 slice 自行实现一个具有动态扩容能力的数组结构。

一、理解 Go 语言内置 slice 的核心机制

Go 语言的 slice 并非一个简单的数组，它是一个包含三个字段的结构体：指向底层数组的指针、长度 (len) 和容量 (cap)。

  • 长度 (len)：slice 中当前实际存储的元素数量。
  • 容量 (cap)：slice 底层数组从 slice 的起始位置开始，到其底层数组的结束位置的元素数量。

让我们通过 main1 函数的例子来观察 slice 的行为：

func main1() {
    // 初始创建一个 len 为 0, cap 为 2 的切片
    array := make([]int, 0, 2)
    fmt.Println("cap", cap(array), "len", len(array), "array", array) // cap 2 len 0 array []

    // 第一次 append，但没有将结果赋值回 array
    // append 函数会返回一个新的切片，如果原切片容量不足会进行扩容，并返回扩容后的新切片
    // 但这里没有赋值，所以 array 仍然是原来的 array
    _ = append(array, 1)
    fmt.Println("cap", cap(array), "len", len(array), "array:", array) // cap 2 len 0 array: []
    _ = append(array, 1)
    fmt.Println("cap", cap(array), "len", len(array), "array:", array) // cap 2 len 0 array: []
    _ = append(array, 1)
    fmt.Println("cap", cap(array), "len", len(array), "array:", array) // cap 2 len 0 array: []

    fmt.Println("-------")

    // 将 append 的结果赋值回 array
    array = append(array, 1)
    fmt.Println("cap", cap(array), "len", len(array), "array:", array) // cap 2 len 1 array: [1]
    array = append(array, 1)
    fmt.Println("cap", cap(array), "len", len(array), "array:", array) // cap 2 len 2 array: [1 1]
    // 此时 len == cap，再次 append 会触发扩容
    array = append(array, 1)
    // 扩容后，通常容量会翻倍（或根据一定策略增长），这里从 2 变为 4
    fmt.Println("cap", cap(array), "len", len(array), "array:", array) // cap 4 len 3 array: [1 1 1]
    array = append(array, 1, 1, 1, 1)
    fmt.Println("cap", cap(array), "len", len(array), "array:", array) // cap 8 len 7 array: [1 1 1 1 1 1 1]
    array = append(array, 1, 1, 1, 1, 1, 1, 1, 1, 1)
    fmt.Println("cap", cap(array), "len", len(array), "array:", array) // cap 16 len 16 array: [1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]
}

在这里插入图片描述

从 main1 函数的输出中我们可以清楚地看到：

  1. append 函数不会修改原切片，而是返回一个新的切片。如果忘记将 append 的结果重新赋值给原切片变量，那么原切片将不会发生任何改变。
  2. 当 slice 的长度达到其容量时，再次 append 会触发扩容。Go 运行时会分配一个更大的底层数组，将原有数据复制过去，然后返回一个指向新底层数组的新 slice。扩容策略通常是容量翻倍，但具体策略可能因 Go 版本和实际情况而异。

二、自定义实现一个可变长数组

虽然 Go 语言的 slice 已经足够强大，但在某些场景下，例如为了更好地理解 slice 的工作机制，或者需要添加一些特定的并发控制或业务逻辑时，我们可能需要自行实现一个类似可变长数组的数据结构。

这里我们实现了一个 Array 结构体，它包含以下字段：

  • array []int：底层的 slice，用于存储实际数据。
  • len int：当前数组中实际存储的元素数量。
  • cap int：底层 slice 的容量。
  • lock sync.Mutex：用于并发安全的互斥锁，确保在多 goroutine 环境下对数组的操作是线程安全的。
1. Make 函数：初始化数组

Make 函数用于初始化一个 Array 实例。

// 初始化数组
func Make(len, cap int) *Array {
    s := new(Array)
    if len > cap {
       panic("len large than cap") // 长度不能大于容量
    }
    // 把切片当数组用，初始时 len 和 cap 都设置为 cap
    // 这样做的目的是为了预先分配好底层数组的空间
    array := make([]int, cap, cap)

    s.array = array
    s.cap = cap
    s.len = 0 // 实际有效元素数量初始化为 0
    return s
}

注意：这里 make([]int, cap, cap) 的 len 和 cap 都设置为 cap，这意味着我们预先分配了一个指定容量的底层数组。我们自定义 Array 的 len 字段（s.len）则初始化为 0，表示当前没有有效数据。

2. Append 方法：添加单个元素

Append 方法负责向数组中添加一个元素，并处理扩容逻辑。

// 添加元素
func (a *Array) Append(element int) {
    a.lock.Lock() // 加锁，保证并发安全
    defer a.lock.Unlock() // 函数结束时解锁

    if a.len == a.cap {
       // 扩容
       newCap := 2 * a.len // 新容量通常是旧容量的两倍
       // 如果之前容量为0，那么新容量为1（避免 0 * 2 还是 0）
       if a.cap == 0 {
          newCap = 1
       }

       newArray := make([]int, newCap, newCap) // 创建新的底层数组

       // 把老数组的数据移动到新数组
       for k, v := range a.array {
          newArray[k] = v
       }
       a.array = newArray // 更新底层数组
       a.cap = newCap     // 更新容量
    }
    // 把元素放在数组里
    a.array[a.len] = element // 将新元素放到当前有效长度的下一个位置
    a.len = a.len + 1        // 实际有效长度加 1
}

Append 方法的核心在于扩容机制。当 a.len == a.cap 时，表示当前底层数组已满，需要创建一个更大的新数组。这里我们采取了经典的容量翻倍策略。此外，为了防止从容量为 0 的数组开始扩容时依然是 0，我们做了特殊处理，将其扩容到 1。

3. 其他辅助方法
  • AppendMany：一次性添加多个元素，通过循环调用 Append 实现。
  • Get：根据索引获取元素，包含越界检查。
  • Len 和 Cap：分别返回当前数组的实际长度和容量。
  • Print：辅助打印数组内容，方便调试。
// 增加多个元素
func (a *Array) AppendMany(element ...int) {
    for _, v := range element {
       a.Append(v)
    }
}

// 获取指定下标元素
func (a *Array) Get(index int) int {
    // 越界检查
    if a.len == 0 || index >= a.len {
       panic("index over len")
    }
    return a.array[index]
}

// 获取真实长度和容量
func (a *Array) Len() int {
    return a.len
}
func (a *Array) Cap() int {
    return a.cap
}

// 辅助打印
func Print(array *Array) (result string) {
    result = "["
    for i := 0; i < array.Len(); i++ {
       if i == 0 {
          result = fmt.Sprintf("%s%d", result, array.Get(i))
          continue
       }
       result = fmt.Sprintf("%s %d", result, array.Get(i))
    }
    result = result + "]"
    return
}

三、运行示例

最后，让我们在 main 函数中测试我们自定义的 Array。

func main() {
    // 创建一个容量为3的动态数组
    a := Make(0, 3)
    fmt.Println("cap", a.Cap(), "len", a.Len(), "array:", Print(a)) // cap 3 len 0 array: []

    // 增加一个元素
    a.Append(10)
    fmt.Println("cap", a.Cap(), "len", a.Len(), "array:", Print(a)) // cap 3 len 1 array: [10]

    // 增加一个元素
    a.Append(9)
    fmt.Println("cap", a.Cap(), "len", a.Len(), "array:", Print(a)) // cap 3 len 2 array: [10 9]

    // 增加多个元素 (此时 len 达到 3，下次 Append 将触发扩容)
    a.AppendMany(8, 7)
    // 第一次 Append(8): len=3, cap=3，触发扩容，cap 变为 6，len 变为 4
    // 第二次 Append(7): len=4, cap=6，不触发扩容，len 变为 5
    fmt.Println("cap", a.Cap(), "len", a.Len(), "array:", Print(a)) // cap 6 len 4 array: [10 9 8 7]
}

在这里插入图片描述

从输出可以看出，我们自定义的 Array 结构体成功实现了动态扩容的功能，并且 len 和 cap 的变化也符合预期。

四、总结

通过本文的讲解和示例，我们不仅回顾了 Go 语言内置 slice 的核心特性，包括其 len 和 cap 的概念以及 append 时的扩容机制，还亲手实现了一个具有类似功能的动态数组。这个自定义实现加深了我们对 Go 语言底层数据结构和内存管理的理解，也展示了如何在 Go 中构建并发安全的可变长数据结构。希望这篇文章能帮助你更好地掌握 Go 语言中 slice 的精髓！

五、代码

package main

import (
	"fmt"
	"sync"
)

// 切片的使用
func main1() {
	// cap :2
	array := make([]int, 0, 2)
	fmt.Println("cap", cap(array), "len", len(array), "array", array)

	// 虽然 append 但是没有赋予原来的变量 array
	_ = append(array, 1)
	fmt.Println("cap", cap(array), "len", len(array), "array:", array)
	_ = append(array, 1)
	fmt.Println("cap", cap(array), "len", len(array), "array:", array)
	_ = append(array, 1)
	fmt.Println("cap", cap(array), "len", len(array), "array:", array)

	fmt.Println("-------")

	// 赋予回原来的变量
	array = append(array, 1)
	fmt.Println("cap", cap(array), "len", len(array), "array:", array)
	array = append(array, 1)
	fmt.Println("cap", cap(array), "len", len(array), "array:", array)
	array = append(array, 1)
	fmt.Println("cap", cap(array), "len", len(array), "array:", array)
	array = append(array, 1, 1, 1, 1)
	fmt.Println("cap", cap(array), "len", len(array), "array:", array)
	array = append(array, 1, 1, 1, 1, 1, 1, 1, 1, 1)
	fmt.Println("cap", cap(array), "len", len(array), "array:", array)
}

// 实现可变长数组
type Array struct {
	array []int
	len   int
	cap   int
	lock  sync.Mutex
}

// 初始化数组
func Make(len, cap int) *Array {
	s := new(Array)
	if len > cap {
		panic("len large than cap")
	}
	// 把切片当数组用
	array := make([]int, cap, cap)

	s.array = array
	s.cap = cap
	s.len = 0
	return s
}

// 添加元素
func (a *Array) Append(element int) {
	a.lock.Lock()
	defer a.lock.Unlock()

	if a.len == a.cap {
		// 扩容
		newCap := 2 * a.len
		// 如果之前容量为0，那么新容量为1
		if a.cap == 0 {
			newCap = 1
		}

		newArray := make([]int, newCap, newCap)

		// 把老数组的数据移动到新数组
		for k, v := range a.array {
			newArray[k] = v
		}
		a.array = newArray
		a.cap = newCap
	}
	// 把元素放在数组里
	a.array[a.len] = element
	a.len = a.len + 1
}

// 增加多个元素
func (a *Array) AppendMany(element ...int) {
	for _, v := range element {
		a.Append(v)
	}
}

// 获取指定下标元素
func (a *Array) Get(index int) int {
	// 越界
	if a.len == 0 || index >= a.len {
		panic("index over len")
	}
	return a.array[index]
}

// 获取真实长度和容量
func (a *Array) Len() int {
	return a.len
}
func (a *Array) Cap() int {
	return a.cap
}

// 辅助打印
func Print(array *Array) (result string) {
	result = "["
	for i := 0; i < array.Len(); i++ {
		// 第一个元素
		if i == 0 {
			result = fmt.Sprintf("%s%d", result, array.Get(i))
			continue
		}

		result = fmt.Sprintf("%s %d", result, array.Get(i))
	}
	result = result + "]"
	return
}

func main() {
	// 创建一个容量为3的动态数组
	a := Make(0, 3)
	fmt.Println("cap", a.Cap(), "len", a.Len(), "array:", Print(a))

	// 增加一个元素
	a.Append(10)
	fmt.Println("cap", a.Cap(), "len", a.Len(), "array:", Print(a))

	// 增加一个元素
	a.Append(9)
	fmt.Println("cap", a.Cap(), "len", a.Len(), "array:", Print(a))

	// 增加多个元素
	a.AppendMany(8, 7)
	fmt.Println("cap", a.Cap(), "len", a.Len(), "array:", Print(a))
}
五、Golang 中的数组Array以及Slice底层实现
阿澈不吃蒜的博客
07-14 1709
数组是指一系列同一类型数据的集合。数组中包含的每个数据被称为数组元素 (element)，这种类型可以是任意的原始类型，比如intstring等，也可以是用户自定义的类型。一个数组包含的元素个数被称为数组的长度。在Golang中数组是一个长度固定的数据类型，
algorithm-go:用Go语言实现的数据结构与算法
03-06
本项目"algorithm-go"专注于使用Go语言来实现各种经典的数据结构和算法，帮助开发者深入理解并熟练运用这些概念。以下是关于这个项目的一些关键知识点： 1. **数据结构**： - **数组**：Go语言中的数组是固定大小...
详解go 动态数组 二维动态数组
09-16
主要介绍了go 动态数组 二维动态数组，本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
Go语言的动态数组
最新发布
2501_91201189的博客
03-22 352
在Go语言中，切片是对数组的一个抽象，它不仅容易使用，还提供了许多强大的功能。一个切片可以比数组更灵活，因为它可以动态增加或减少大小。切片是Go语言中用于实现动态数组的重要数据结构。它不仅解决了传统数组的固定大小问题，还在内存管理和性能上具有明显优势。通过对切片的深入理解和灵活运用，开发者可以更高效地处理动态数据，提升程序的性能和可读性。在实际开发中，熟悉切片的各种操作及其底层实现，将有助于编写出更优雅和高效的代码。希望这篇文章能给读者带来对Go语言切片的全面认识和理解。
go语言实现的动态数组
zhuiyunzhugang的博客
04-11 830
package main import "fmt" func main(){ var a int=1 const b int=2 fmt.Println("hello world!") fmt.Println(a) fmt.Println(b) //var c int c:=1 fmt.Println(c) myArray:=[]int {1,2,3,4} //这里定义个一个动态数组 printArray(myArray) fmt.Println("输出修改后的数组") for.
Go：从源码角度学习Go中的动态数组——切片(Slice)
Liu_y_xin的博客
08-18 998
从源码角度学习Go中的动态数组——切片(Slice)
go 语言切片(slice)-动态数组
qq_38324542的博客
11-01 534
go语言切片（slice)-动态数组
golang-algs-and-data-struts：在Golang中实现的算法和数据结构
02-26
本篇文章将深入探讨在Golang中实现的数据结构和算法，旨在帮助开发者提升对Golang的理解，同时提高编程技能。 首先，我们来看看数据结构。数据结构是组织、管理、存储和检索数据的方式。在Golang中，常见的数据结构...
Go语言深入解析：Array、Slice、Map与Set
"Go语言中的Array、Slice、Map和Set使用详解" 在Go语言中，Array、Slice、Map和Set是四种重要的数据结构，它们各有特点并适用于不同的场景。以下是关于这些概念的详细解释： 1. Array（数组） - 内部机制：数组是...
深入理解golang的基本类型排序与slice排序
09-21
### 深入理解Golang的基本类型排序与Slice排序 #### 前言 在Golang中，排序功能被设计得十分灵活且强大。与其他语言如C或C++相比，Go语言提供了更为广泛的排序能力，它能够处理各种类型的数据结构，而不仅仅局限于...
【GO】Go数组和切片（动态数组）
红尘道，红尘练心
06-18 897
切片在 golang 是一种很重要的数据结构，大家平时工作和面试都会遇到，而且切片需要注意的点比较多，只有深入去理解它，才能避免采坑。下面开始发车。 数组 数组是内置类型，是一组同类型数据的集合，它是值类型，通过从0开始的下标索引访问元素值。 在初始化后长度是固定的，无法修改其长度。当作为方法的参数传入时将复制一份数组而不是引用同一指针。 数组的长度也是其类型的一部分，通过内置函数len(array)获取其长度。 还有几点要注意的： //值传递,传的是副本 func updateArr(b [3]int)
Golang动态数组
weixin_69163469的博客
08-03 1073
golang学习笔记
【golang】实现动态数组
Free_Ya的博客
04-01 2793
前言 在go中，slice可以当作是一种动态数组，但是博主还是想借助slice手动实现一下。 代码 结构体 // array 切片结构体 type array struct { arr []int len int cap int } 创建 func makeArr(len,cap int) *array{ a := new(array) if len > cap { fmt.Println("invalid，len large than cap") return nil } a
深入理解 Go 语言——动态数组Slice
JackWu1024
10-25 692
Slice 又称动态数组，依托底层数组实现。在 Go 语言中，Slice 是一个引用类型，它比数组更加灵活，更适合处理序列数据。它不仅可以动态地改变自己的大小，还可以进行方便的切片操作。Slice 的定义非常简洁，只有三个字段：指针、长度和容量。a
GO语言中的数据结构--切片（动态数组）
White--Night的博客
03-13 249
切片是一种比较特殊的数据结构。它围绕动态数组的概念构建，可以按需自动增长和缩小。总的来说它可理解为动态数组，并根据切片里的元素自动调整切片长度。
golang数据结构初探之动态数组slice
热门推荐
Steven的专栏
08-17 1万+
动态数组slice slice 又称动态数组，依托于数组实现，可以方便的进行扩容和传递，实际使用时比数组更灵活。但正是因为灵活，实际使用时更容易出错，避免出错的最好方法便是了解其实现原理。 特性速览 初始化 声明和初始化切片的方式主要有以下几种方式： 变量声明 字面量 使用内置函数make() 从切片和数组中切取 变量声明 这种声明方式的切片变量与声明其他类型变量一样，变量值都为零值，对于切片来讲零值为nil var s []int 字面量 也可以使用字面量初始化切片，需要了解的是空切片是指长度为空，
Go切片≠动态数组
键盘侠老李
08-17 4126
Go切片设计非常巧妙，它不仅提供真正的动态数组的观感，并且性能优化的不错。但如果不了解切片的内部机制就可能会踩坑。背景：最近我又注意到一些关于切片操作似乎不合逻辑的讨论。我觉得是时候来科普一下切片的内部实现和切片操作的机制，特别是append()和bytes.Split()。Go切片Go语言中切片的概念很精妙：切片代表一个长度灵活的类似于列表的数据类型，但又让它对内存的分配完全可制。 其他的语言中
9.Golang中的数组与动态数组
流月up的博客
01-26 729
Golang中的数组和动态数组
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值