Golang動態(tài)數(shù)組的實(shí)現(xiàn)示例

更新時間：2024年10月16日 10:52:40 作者：勇者無畏404

動態(tài)數(shù)組能自動調(diào)整大小,與靜態(tài)數(shù)組不同,其大小不固定,可根據(jù)需求變化,實(shí)現(xiàn)通常依賴于數(shù)據(jù)結(jié)構(gòu)如鏈表或數(shù)組加額外信息,本文就來介紹一下Golang動態(tài)數(shù)組的實(shí)現(xiàn)示例,感興趣的可以了解一下

什么是動態(tài)數(shù)組

動態(tài)數(shù)組（Dynamic Array）是一種在需要時能夠自動改變其大小的數(shù)組。與靜態(tài)數(shù)組（Static Array）不同，靜態(tài)數(shù)組的大小在聲明時就已確定，且之后不能更改，而動態(tài)數(shù)組的大小則是根據(jù)需要動態(tài)變化的。動態(tài)數(shù)組通常通過某種數(shù)據(jù)結(jié)構(gòu)（如鏈表、數(shù)組加額外信息等）來實(shí)現(xiàn)，以便在需要時能夠擴(kuò)展或縮小其容量。（關(guān)鍵字：動態(tài)擴(kuò)縮容，基于鏈表或數(shù)組實(shí)現(xiàn)）

在大多數(shù)現(xiàn)代編程語言中，如C++的std::vector、Java的ArrayList、Python的列表（list）等，都提供了動態(tài)數(shù)組的功能。這些實(shí)現(xiàn)通常會在內(nèi)部使用一個靜態(tài)數(shù)組來存儲元素，并跟蹤當(dāng)前數(shù)組的大小和已分配的容量。當(dāng)向動態(tài)數(shù)組添加元素而當(dāng)前容量不足時，它們會自動分配一個新的、更大的數(shù)組，并將舊數(shù)組的元素復(fù)制到新數(shù)組中，然后再添加新元素。這個過程對用戶是透明的，用戶無需關(guān)心底層的內(nèi)存管理細(xì)節(jié)。

Go語言中的動態(tài)數(shù)組——切片（slice）

Go語言（Golang）中的切片（slice）是一種引用類型，它提供了對數(shù)組的抽象。切片是對數(shù)組一個連續(xù)片段的引用，但它比數(shù)組更靈活、更強(qiáng)大。以下是Go語言切片的一些主要特點(diǎn)：

動態(tài)數(shù)組：切片的大小不是固定的，它們可以根據(jù)需要增長和縮小。當(dāng)向切片中添加更多元素，且切片容量不足時，Go會自動分配更大的內(nèi)存空間并復(fù)制原有元素到新空間中，從而允許切片繼續(xù)增長。
引用類型：切片是引用類型，這意味著切片變量存儲的是對底層數(shù)組的引用（即內(nèi)存地址），而不是數(shù)組的拷貝。因此，通過不同的切片變量操作同一個底層數(shù)組的元素時，這些操作會相互影響。
長度和容量：切片有兩個重要的屬性：長度（length）和容量（capacity）。長度是切片中元素的數(shù)量；容量是從切片的第一個元素開始到底層數(shù)組末尾的元素數(shù)量。切片的長度可以改變，但容量在切片創(chuàng)建時由底層數(shù)組的大小決定，且一般只能通過重新切片或使切片指向一個新的數(shù)組來改變。
基于數(shù)組：切片是對數(shù)組的一個連續(xù)片段的引用，但切片的使用比數(shù)組更加靈活和方便。切片可以動態(tài)地增長和縮小，而數(shù)組的大小在定義時就確定了，不能改變。
零值：切片的零值是nil，表示切片不引用任何數(shù)組。一個nil切片的長度和容量都是0，并且沒有底層數(shù)組。
切片操作：Go支持對切片進(jìn)行切片操作，即可以從一個已存在的切片中再“切”出一個新的切片。這種操作基于原切片的底層數(shù)組，但可以有不同的長度和容量。
內(nèi)存連續(xù)：切片的底層數(shù)組在內(nèi)存中是連續(xù)的，這使得對切片中的元素進(jìn)行迭代訪問時效率很高。
內(nèi)置函數(shù)支持：Go的標(biāo)準(zhǔn)庫提供了許多內(nèi)置函數(shù)來操作切片，如append用于向切片追加元素，copy用于切片間的元素復(fù)制，以及len和cap用于獲取切片的長度和容量等。

切片數(shù)據(jù)結(jié)構(gòu)

type slice struct {
    // 底層數(shù)組指針（指向一塊連續(xù)內(nèi)存空間的起點(diǎn)）
    array unsafe.Pointer
    // 切片長度
    len   int
    // 切片容量   
    cap   int
}

cap>=len

切片的創(chuàng)建和初始化

//通過字面量創(chuàng)建

	/**
	創(chuàng)建字符串切片，長度和容量都是3
	 */
	slice1 := []string{"aaa","bbb","ccc"}
	fmt.Println(slice1)  //[aaa bbb ccc]

	/**
	創(chuàng)建整形切片，長度和容量都是4
	 */
	slice2 := []int{10,20,30,40}
	fmt.Println(slice2) //[10 20 30 40]

	//當(dāng)使用切片字面量創(chuàng)建切片時，還可以設(shè)置初始長度和容量。

	/**
	創(chuàng)建一個長度和容量都是100的切片 索引0 = 10，索引99 = 1
	 */
	slice3 := []int{0:10,99:1}
	fmt.Println(slice3) //[10 0 0 ... 1]

	//通過 make() 函數(shù)創(chuàng)建切片


	/**
	創(chuàng)建長度和容量都是5的切片
	 */
	slice4 := make([]int,5)
	fmt.Println(slice4)  //[0 0 0 0 0] 默認(rèn)對應(yīng)類型的零值

	/**
	創(chuàng)建長度=3，容量=5的切片
	 */
	slice5 := make([]string,3,5)
	fmt.Println(slice5)  //[  ]

	/**
	不允許創(chuàng)建容量小于長度的切片
	 */
	slice6 := make([]int,5,3)
	fmt.Println(slice6)  //invalid argument: length and capacity swapped

切片初始化源碼

func makeslice(et *_type, len, cap int) unsafe.Pointer {

    mem, overflow := math.MulUintptr(et.size, uintptr(cap))
    if overflow || mem > maxAlloc || len < 0 || len > cap {

        mem, overflow := math.MulUintptr(et.size, uintptr(len))
        if overflow || mem > maxAlloc || len < 0 {
            panicmakeslicelen()
        }
        panicmakeslicecap()
    }

    return mallocgc(mem, et, true)
}

math.MulUintptr 方法計算出初始化切片需要的內(nèi)存和空間大小
空間超限，直接panic
mallocgc方法，為切片進(jìn)行空間分配

切片在方法之間的傳遞

func main() {
	sl := []int{1,2,3,4,5}
	fmt.Println(sl)  //[1 2 3 4 5]
	change(sl)
	fmt.Println(sl)  //[10 2 3 4 5]
}
func change(sl []int) {
	sl[0] = 10
}

每次在方法之間傳遞切片時，會將切片實(shí)例本身進(jìn)行一次值拷貝（也可以叫淺拷貝），會將array指針，len長度，cap容量進(jìn)行拷貝所以方法中和方法外的切邊array指向同一片內(nèi)存空間，因此在局部方法中執(zhí)行修改操作時，還會根據(jù)這個地址信息影響到原 slice 所屬的內(nèi)存空間，從而對內(nèi)容發(fā)生影響；

但是如果在函數(shù)中的切片發(fā)生了擴(kuò)容，此時內(nèi)外就是兩個獨(dú)立的切片；

截取切片

在Go語言中，可以通過指定起始索引和結(jié)束索引來截取一個新的切片（包前不包后）；

slice[start:end]
//slice要截取的原始切片
//start截取切片的開始位置，不填默認(rèn)為0
//end截取切片的結(jié)束位置，不填默認(rèn)為切片長度

s := []int{1, 2, 3, 4, 5}
	// 截取整個切片
	subS1 := s[:]
	fmt.Println(subS1) // 輸出: [1 2 3 4 5]

	// 截取索引1到4（不包含4）的元素
	subS2 := s[1:4]
	fmt.Println(subS2) // 輸出: [2 3 4]

	// 從索引0開始截取到索引4（不包含4）
	subS3 := s[:4]
	fmt.Println(subS3) // 輸出: [1 2 3 4]

	// 從索引2開始截取到切片末尾
	subS4 := s[2:]
	fmt.Println(subS4) // 輸出: [3 4 5]

截取出的切片和原始切片的關(guān)系

在對切片 slice 執(zhí)行截取操作時，本質(zhì)上是一次引用傳遞操作，因?yàn)椴徽撊绾谓厝?，底層?fù)用的都是同一塊內(nèi)存空間中的數(shù)據(jù)，只不過，截取動作會創(chuàng)建出一個新的 slice header 實(shí)例；

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

往切片中新增元素（append）

通過append方法可以實(shí)現(xiàn)在切片的末尾添加元素

func main() {  
    s := []int{1, 2, 3}  
    // 使用 append 函數(shù)在切片末尾添加元素 4  
    s = append(s, 4)  
    fmt.Println(s) // 輸出: [1 2 3 4]  
}

func main() {  
    s := []int{1, 2, 3}  
    // 使用 append 函數(shù)在切片末尾添加多個元素  
    s = append(s, 4, 5, 6)  
    fmt.Println(s) // 輸出: [1 2 3 4 5 6]  
}

func main() {  
    s1 := []int{1, 2, 3}  
    s2 := []int{4, 5, 6}  
    // 使用 append 函數(shù)將 s2 添加到 s1 的末尾  
    s1 = append(s1, s2...) // 注意 s2 后的 ... 用于將 s2 展開為元素序列  
    fmt.Println(s1) // 輸出: [1 2 3 4 5 6]  
}

func main() {  
    s := []int{1, 3, 4, 5}  
    // 在索引 1 的位置插入元素 2  
    // 首先，將索引 1 及其之后的元素向后移動一位  
    s = append(s[:1], append([]int{2}, s[1:]...)...)  
    fmt.Println(s) // 輸出: [1 2 3 4 5]  
}

刪除切片中的元素

在Go語言中，切片（slice）本身并不提供直接的刪除元素的方法，因?yàn)榍衅菍Φ讓訑?shù)組的抽象，而數(shù)組的大小是固定的。但是，通過以下幾種方式來實(shí)現(xiàn)“刪除”切片中的元素；

//使用切片操作刪除元素（適用于刪除末尾元素）
s := []int{1, 2, 3, 4, 5}  
// 刪除切片末尾的元素  
s = s[:len(s)-1]  
fmt.Println(s) // 輸出: [1 2 3 4]


//使用append和切片操作刪除任意位置的元素
s := []int{1, 2, 3, 4, 5}  
// 假設(shè)我們要刪除索引為2的元素（值為3）  
index := 2  
// 將index之后的元素（不包括index）復(fù)制到前面，然后截斷切片  
s = append(s[:index], s[index+1:]...)  
fmt.Println(s) // 輸出: [1 2 4 5]

//使用循環(huán)和條件語句刪除滿足條件的元素
s := []int{1, 2, 3, 4, 5}  
// 刪除所有值為3的元素  
var newS []int  
for _, value := range s {  
    if value != 3 {  
        newS = append(newS, value)  
    }  
}  
s = newS  
fmt.Println(s) // 輸出: [1 2 4 5]

拷貝切片

slice 的拷貝可以分為簡單拷貝和完整拷貝兩種類型；

要實(shí)現(xiàn)簡單拷貝（淺拷貝），我們只需要對切片的字面量進(jìn)行賦值傳遞即可，這樣相當(dāng)于創(chuàng)建出了一個新的 slice header 實(shí)例，但是其中的指針 array、容量 cap 和長度 len 仍和老的 slice header 實(shí)例相同；

slice 的完整復(fù)制（深拷貝），指的是會創(chuàng)建出一個和 slice 容量大小相等的獨(dú)立的內(nèi)存區(qū)域，并將原 slice 中的元素一一拷貝到新空間中，在實(shí)現(xiàn)上，slice 的完整復(fù)制可以調(diào)用系統(tǒng)方法 copy；

s := []int{1, 2, 3}  
// 分配一個新的切片，長度和容量與s相同  
sCopy := make([]int, len(s))  
// 使用copy函數(shù)復(fù)制元素  
copy(sCopy, s)  
  
// 現(xiàn)在sCopy是s的一個獨(dú)立拷貝  
fmt.Println(sCopy) // 輸出: [1 2 3]