zoukankan      html  css  js  c++  java
  • go6---slice切片

    package main
    
    /*
    切片Slice
    其本身并不是数组,它指向底层的数组
    作为变长数组的替代方案,可以关联底层数组的局部或全部
    为引用类型
    可以直接创建或从底层数组获取生成
    使用len()获取元素个数,cap()获取容量
    一般使用make()创建
    如果多个slice指向相同底层数组,其中一个的值改变会影响全部
    make([]T, len, cap)
    其中cap可以省略,则和len的值相同
    len表示存数的元素个数,cap表示容量
    
    用new创建数组的时候是一个指向数组的指针。
    */
    
    import (
        "fmt"
    )
    
    func main() {
        var slice1 []int //中括号里面是数字或者3个点就表示数组,
        //中括号里面既不是数字也不是3个点就表示是slice不是数组
        fmt.Println(slice1) //[],slice的底层也是数组保存的,打印也是数组的格式,
    
        a := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
        fmt.Println(a) //[1 2 3 4 5 6 7 8 9 0]
    
        s1 := a[2]      //一个slice
        fmt.Println(s1) //3
    
        s2 := a[5:10]   //数组的索引从5到9,包头不包尾,//一个slice
        fmt.Println(s2) //[6 7 8 9 0]
    
        s3 := a[5:len(a)] //数组的索引从5到长度减一,包头不包尾,//一个slice
        fmt.Println(s3)   //[6 7 8 9 0]
    
        s4 := a[5:]     //数组的索引从5到尾部,//一个slice
        fmt.Println(s4) //[6 7 8 9 0]
    
        s5 := a[:5]     //数组的索引从开头到索引为4,//一个slice
        fmt.Println(s5) //[1 2 3 4 5]
    
        s11 := make([]int, 3) //初始化3个元素,并放在slice所指向的数组中,
        fmt.Println(s11)      //    [0 0 0]
    
        s22 := make([]int, 3, 10) //初始化3个元素,slice指向的是一个数组,数组是一块连续的内存,
        //数组不能动态修改长度, 10第三个参数是数组的容量,现在是3个,但是总共可以有10个,当超出10个后
        //会重新分配连续的内存块(内存地址改变了)(重新分配内存的效率低),并且容量扩大一倍成20,
        fmt.Println(s22)                //    [0 0 0]
        fmt.Println(len(s22), cap(s22)) //    3,10
    
        //slice是引用类型的并且可以扩容的数组
    
        a1 := []byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'}
        s33 := a1[2:5]           //一个slice
        fmt.Println(s33)         //    [99 100 101]
        fmt.Println(string(s33)) //    cde
    
        /*
            Reslice
            Reslice时索引以被slice的切片为准
            索引不可以超过被slice的切片的容量cap()值
            索引越界不会导致底层数组的重新分配而是引发错误
        */
        //从slice中获取slice
        s44 := s33[1:3]          //一个slice
        fmt.Println(s44)         //[100 101]
        fmt.Println(string(s44)) //de
    
        /*
            Append
            可以在slice尾部追加元素
            可以将一个slice追加在另一个slice尾部
            如果最终长度未超过追加到slice的容量则返回原始slice
            如果超过追加到的slice的容量则将重新分配数组并拷贝原始数据
        */
    
        s55 := make([]int, 3, 6)        //3个元素容量为6的slice
        fmt.Printf("%v,%p
    ", s55, s55) //[0 0 0],0xc04200e2a0
        s55 = append(s55, 1, 2, 3)
        fmt.Printf("%v,%p
    ", s55, s55) //[0 0 0 1 2 3],0xc04200e2a0,没有超过容量不重新分配内存地址
        s55 = append(s55, 1, 2, 3)
        fmt.Printf("%v,%p
    ", s55, s55) //[0 0 0 1 2 3 1 2 3],0xc04203a120,超过容量重新分配内存地址
    
        a2 := [...]int{1, 2, 3, 4, 5}
        s66 := a2[2:5] //[3 4 5],不显示的加容量,则容量就是此时slice中元素的个数3,
        s77 := a2[1:3] // [2 3]
        fmt.Println(s66, s77)
        s66[0] = 9
        fmt.Println(s66, s77) //[9 4 5] [2 9],slice指向一个底层的数组,其中一个改变另外一个也改变,
        //如果超过slice的容量会重新分配内存,此时改变这个slice其他的slice就不会改变了
        s66 = append(s66, 1, 2, 3, 2, 3, 2, 3, 4, 3, 4)
        s66[0] = 99
        fmt.Println(s66, s77) //[99 4 5 1 2 3 2 3 2 3 4 3 4] [2 9]
    
        //slice的copy函数
        s88 := []int{1, 2, 3, 4, 5, 6}
        s99 := []int{7, 8, 9}
        copy(s88, s99)        //左边是拷贝到的元素,后面是被拷贝的元素,吧前三个元素拷贝到s88的前三个
        fmt.Println(s88, s99) //[7 8 9 4 5 6] [7 8 9]
    
        ss11 := []int{1, 2, 3, 4, 5, 6}
        ss22 := []int{7, 8, 9}
        copy(ss22, ss11)
        fmt.Println(ss11, ss22) //[1 2 3 4 5 6] [1 2 3],ss22只有3个元素,则只接收3个元素逇拷贝
    
        ss33 := []int{1, 2, 3, 4, 5, 6}
        ss44 := []int{7, 8, 9}
        copy(ss33, ss44[1:2])      //部分拷贝
        copy(ss33[2:4], ss44[1:2]) //指定拷贝到哪里
        fmt.Println(ss33, ss44)    //[1 2 3 4 5 6] [1 2 3],ss22只有3个元素,则只接收3个元素逇拷贝
    
    }

     

  • 相关阅读:
    同步 异步 阻塞 非阻塞深入理解
    TCP的三次握手四次挥手
    dom事件
    Vue 无痕 刷新页面
    事件冒泡 捕获 事件流
    gulp
    懒加载
    Object.prototype.toString.call() 判断某个对象属于哪种内置类型 type instanceof Object.prototype.toString.call 区别
    css sass less
    node module.exports exports
  • 原文地址:https://www.cnblogs.com/yaowen/p/8072353.html
Copyright © 2011-2022 走看看