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\n", s55, s55) //[0 0 0],0xc04200e2a0
    s55 = append(s55, 1, 2, 3)
    fmt.Printf("%v,%p\n", s55, s55) //[0 0 0 1 2 3],0xc04200e2a0,没有超过容量不重新分配内存地址
    s55 = append(s55, 1, 2, 3)
    fmt.Printf("%v,%p\n", 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个元素逇拷贝

}
复制代码

 


本文转自农夫山泉别墅博客园博客,原文链接:http://www.cnblogs.com/yaowen/p/8072353.html,如需转载请自行联系原作者

相关文章
|
4月前
|
Go
Go 中使用切片来实现动态数组的功能
Go 中使用切片来实现动态数组的功能
|
4月前
|
存储 监控 Go
【Go语言精进之路】构建高效Go程序:了解切片实现原理并高效使用
【Go语言精进之路】构建高效Go程序:了解切片实现原理并高效使用
60 3
|
4月前
|
Go
go语言数组与切片
go语言数组与切片
|
11天前
|
Go 索引
Go to Learn Go之切片
Go to Learn Go之切片
21 1
|
13天前
|
编译器 Go 索引
Go数组、多维数组和切片(动态数组),及常用函数len(),cap(),copy(),append()在切片中的使用
本文介绍了Go语言中数组、多维数组和切片(动态数组)的基本概念和操作,包括数组的定义、初始化、访问,多维数组的定义和访问,以及切片的创建、使用和扩容。同时,还讲解了切片中常用的函数len()、cap()、copy()和append()的使用方法。
|
2月前
|
Go
Go 1.21的新特性: 切片和映射
Go 1.21的新特性: 切片和映射
|
2月前
|
存储 Go
go 切片长度与容量的区别
go 切片长度与容量的区别
|
2月前
|
存储 缓存 Go
在 Go 中如何复制切片和映射?
【8月更文挑战第31天】
44 0
|
2月前
|
存储 Go 数据处理
C 数组和 Go 切片的区别详解
【8月更文挑战第31天】
30 0
|
2月前
|
人工智能 编译器 Go
Go从入门到放弃之数组、切片
Go从入门到放弃之数组、切片