go中的切片

demo1:切片定义的几种方式

package main

import "fmt"

/*
切片定义的几种方式

数组和切片区别:
使用数组传参是值传递,而使用切片传参是引用传递
数组定义好长度之后不可修改,而切片可以理解为动态数组,长度可修改

*/

func main() {
    //方法1:直接创建
    s1 := []string{"1", "2", "3"}
    fmt.Printf("%T\n", s1)
    fmt.Println(len(s1))
    fmt.Println(s1)

    fmt.Println("--------------------------------------")
    //方法2:使用make定义,但是需要加上长度,cap可加可不加
    s2 := make([]string, 3)     //s2:=make([]string, 3,5)   加cap写法
    fmt.Printf("%T\n", s2)
    fmt.Println(len(s2))
    fmt.Println(s2)

    fmt.Println("--------------------------------------")
    //方法3:数组变切片
    arr := [3]string{"1", "2", "3"}
    s3 := arr[1:2]
    fmt.Printf("%T\n", s3)
    fmt.Printf("%T\n", arr)
    fmt.Println(len(s3))
    fmt.Println(s3)

    fmt.Println("--------------------------------------")
    //方法4:new
    s4 := new([]string)
    fmt.Printf("%T\n", s4)
    //fmt.Println(len(s4)) //没有长度
    fmt.Println(s4) //&[]

}

demo2: 切片的基本操作

package main

import "fmt"

/*
切片的基本操作:添加、复制、合并、删除
*/

func main() {
    s1 := []string{"1", "2", "3"}

    //添加
    s1 = append(s1, "4", "5")
    fmt.Println(s1)

    //复制
    s2 := []string{}
    copy(s2, s1)
    fmt.Println(s2) //这里s2为空,因为没定义长度
    //拷贝时,目标对象长度为多少就只能复制多少
    s3 := make([]string, len(s1))
    copy(s3, s1)
    fmt.Println(s3)

    //把两个切片合并
    s2 = append(s1, s3...) //省略号是规定的参数
    fmt.Println(s2)

    //数组中删除元素:先把数组变成切片,再把两个切片合并
    s4 := s2[:]
    s4 = append(s2[0:2], s2[4:]...)
    fmt.Println(s4)
}

demo3: 切片的cap和len

package main

import "fmt"

/*
切片的容量(cap)和长度(len)

slice的底层是使用数组实现的,同一个数组的切片会共享内存,但如果切片扩容超过切片的原有容量cap会触发扩容机制,该切片就会自己独立开辟全新内存空间。

slice的append扩容问题:扩容阶段因为需要整体开辟全新的内存空间,因此扩容阶段会影响速度。python的list中底层实际上也是数组,也会面临扩容影响速度的问题。

python的同一list中可以存不同的数据类型。
*/

func main() {
    //不设置cap时,len和cap大小一致
    s1 := []string{"1", "2", "3"}
    fmt.Println(len(s1))    //3
    fmt.Println(cap(s1))    //3

    s2 := make([]int, 5)    
    fmt.Println(len(s2))    //3
    fmt.Println(cap(s2))    //3

    s3 := make([]int, 5, 8) //设置了容量cap
    fmt.Println(len(s3))    //5
    fmt.Println(cap(s3))    //8

    //通过数组取切片:cap为切片起始位置之后的数组长度
    s4 := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    s5 := s4[2:5]        
    fmt.Println(len(s5)) //3
    fmt.Println(cap(s5)) //8

    //append函数遇到make问题:如果用make创建切片时定义了长度,append操作会在原有元素之后进行插入。如果没有定义长度,append操作则是对默认元素0进行替换
    s6 := make([]int, 3)
    s6 = append(s6, 1)
    fmt.Println(s6) //[0 0 0 1]

    s7 := make([]int, 0)
    s7 = append(s7, 1)
    fmt.Println(s7) //  [1]

}

demo4:切片扩容

案例1:

package main

import (
    "fmt"
)

func main() {

    data := [...]int{0, 1, 2, 3, 4, 10: 0} //数组
    s := data[:2:3]
    fmt.Println(s)
    fmt.Println(len(s), cap(s))

    s = append(s, 100, 200, 300) // 一次 append 三个值,超出 s.cap 限制。

    fmt.Println(s, data)         // 重新分配底层数组,与原数组无关。
    fmt.Println(&s[0], &data[0]) // 比对底层数组起始指针。

}

从输出结果可以看出:append 后的 s 被重新分配了底层数组(也就是说 s 的底层数组不再是 data,那么修改 s 的值不会再影响 data,它们不再有关联),并把原数组中的值拷贝到新数组中。这是因为超出了原切片的容量。在上例中,如果只追加一个值,则不会超过 s.cap 限制,也就不会重新分配。

切片的自动扩容策略是这样的:(文章:简单说说go语言Slice的底层实现_Liuzhiwang29的博客-CSDN博客 简单说说go语言Slice的底层实现 通过分析源码对这一点提出了质疑)通常 以 2 倍容量 进行扩容,并重新分配底层数组(新底层数组的容量也变大)。如果切片的容量小于 1024 个元素,扩容的时候就翻倍增加容量。一旦元素个数超过 1024 个元素,那么增长因子就变成 1.25 ,即每次增加原来容量的四分之一。注意:扩容扩大的容量都是针对原来的容量而言的,而不是针对原来数组的长度而言的。

所以,在大批量添加数据时,建议 一次性分配足够大的空间 ,以减少内存分配和数据复制开销。或 初始化足够长的 len 属性,改用索引号进行操作。及时释放不再使用的 slice 对象,避免持有过期数组,造成 GC 无法回收。

slice中 cap 重新分配规律:

package main

import (
    "fmt"
)

func main() {

    s := make([]int, 0, 1)
    fmt.Println(s)
    
    c := cap(s)                        //计算容量
    fmt.Println(c)

    for i := 0; i < 50; i++ {
        s = append(s, i)               //按理说 append 第2个元素时就超出了cap,这时会重新分配底层数组来扩大cap
        if n := cap(s); n > c {
            fmt.Printf("cap: %d -> %d\n", c, n)
            c = n
        }
    }

}

输出结果:

[]
1
cap: 1 -> 2
cap: 2 -> 4
cap: 4 -> 8
cap: 8 -> 16
cap: 16 -> 32
cap: 32 -> 64

我们可以发现,通常以 2 倍的 cap 重新分配。

提一嘴哈,如果给切片 append 元素时,不超切片容量就没事,操作的还是原数组:

package main

import (
    "fmt"
)

func main() {

    data := [...]int{0, 1, 2, 3, 4, 10: 0} //数组
    s := data[:2:5]                        //将切片容量扩大到5
    fmt.Println(s)
    fmt.Println(len(s), cap(s))

    s = append(s, 100, 200, 300) // 一次 append 三个值,这次没超出 s.cap 限制。

    fmt.Println(s, data)         
    fmt.Println(&s[0], &data[0]) // 比对底层数组起始指针

}

输出结果:

[0 1]
2 5
[0 1 100 200 300] [0 1 100 200 300 0 0 0 0 0 0]
0xc00004a060 0xc00004a060

案例2:

package main

import "fmt"

//slice的扩容

func main() {
    arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
    s1 := arr[2:6]      
    s2 := s1[3:5]
    fmt.Printf("s1=%v,len(s1)=%d,cap(s1)=%d\n", s1, len(s1), cap(s1)) //2,3,4,5
    fmt.Printf("s2=%v,len(s2)=%d,cap(s2)=%d\n", s2, len(s2), cap(s2)) //5,6,为什么s2中取到6,是因为slice支持向后扩容

    //slice的操作:向slice中添加元素
    s3 := append(s2, 10)
    s4 := append(s3, 11)
    s5 := append(s4, 12)
    fmt.Println("s3,s4,s5:", s3, s4, s5)
    fmt.Println("arr:", arr)    //为什么没有11,12?   是因为不能超过cap,如果超过cap则会重新分配一个数组进行存储

}

你可能感兴趣的:(go,golang,开发语言,后端)