go中切片的基础用法

最新推荐文章于 2023-12-22 14:55:06 发布

千里。。

最新推荐文章于 2023-12-22 14:55:06 发布

阅读量258

点赞数

文章标签： go

本文链接：https://blog.csdn.net/qq_16745795/article/details/127745709

版权

title: golang 切片基础用法
author: qianli
tags:

go
slice
categories:
go
abbrlink: 2986
date: 2022-02-15 15:03:00

切片

切片是围绕动态数据来构建的
数组一旦创建就不能更改长度，但是切片可以按需求自动增长和缩小
增长是使用内置的append函数来实现的
缩小通过对切片的再次切片来实现

切片内部实现

切片分为 data len cap

直接声明和初始化

package  main

import "fmt"

func	 main(){
	var s1 []int			//声明切片
	fmt.Println(s1 )
	

	s1 =append(s1,1)		//切片追加 相当于增长切片
	s1 =append(s1,2)
	fmt.Println(s1)

	var s2 = []int{1,2,3}  //声明并初始化
	fmt.Println(s2)

}


-------------------   //输出结果
[]
[1 2]
[1 2 3]

使用make初始化

make([]int,长度，容量)
以类型0值+长度的个数填充slice
容量不填默认=长度，如果填了不能小于长度,可大于长度

package main

import "fmt"

func main() {

	// 使用make初始化一个长度为0的slice
	s1 := make([]int, 0)     // 不写容量默认跟长度一致
	s1 = append(s1, 1)
	s1 = append(s1, 2)
	s1 = append(s1, 3)
	fmt.Println(s1)
    fmt.Println(cap(s1))   //4

	// 使用make 初始化一个长度为5 容量为5的slice
	s2 := make([]int, 5, 5) 
	s2 = append(s2, 1)
	s2 = append(s2, 2)
	s2 = append(s2, 3)
	fmt.Println(s2) // [0 0 0 0 0 1 2 3]
}

new和make对比

简单说 new只分配内存，make用于slice，map，和channel的初始化。
对比表格

函数名	适用范围	返回值	填充值
new	new可以对所有类型进行内存分配	new 返回指针	new 填充零值
make	make 只能创建类型(slice map channel)	make 返回引用	make 填充非零值

通过切片创建新的切片

语法如下

slice[start:end:cap]

其中 start 表示从 slice 的第几个元素开始切
end 控制切片的长度(end-start)
cap 控制切片的容量 ,如果没有给定 cap ，slice的长度值，则表示切到底层数组的最尾部
新切片的长度 = end-start
新切片的容量 = cap-start
cap不能大于原切片的cap

package main

import "fmt"

func main() {

	s1 := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
	fmt.Printf("[s1][值:%v][新切片的长度=%d 容量=%d]\n", s1, len(s1), cap(s1))
	s2 := s1[2:6]
	fmt.Printf("[s2][从索引为2 就是3号往后切4个元素][值:%v][新切片的长度=%d 容量=%d]\n", s2, len(s2), cap(s2))
	s3 := s1[5:]
	fmt.Printf("[s3][从索引为5 就是6号 切到最后][值:%v][新切片的长度=%d 容量=%d]\n", s3, len(s3), cap(s3))
	s4 := s1[:4]
	fmt.Printf("[s4][从开头切4个元素][值:%v][新切片的长度=%d 容量=%d]\n", s4, len(s4), cap(s4))
	s5 := s1[:]
	fmt.Printf("[s5][复制整个切片][值:%v][新切片的长度=%d 容量=%d]\n", s5, len(s5), cap(s5))

	s6 := s1[2:6:8]
	fmt.Printf("[s6][从索引为2 就是3号往后切4个元素][值:%v][新切片的长度=%d 容量=%d]\n", s6, len(s6), cap(s6))

	s7 := s1[2:6:9]
	fmt.Printf("[s7][从索引为2 就是3号往后切4个元素][值:%v][新切片的长度=%d 容量=%d]\n", s7, len(s7), cap(s7))

}

改变某一个切片的元素

说明所有切片的值都变了

	fmt.Printf("[改变某一个切片的元素。看看其他切片会受影响吗]\n")
	s6[1] = 80
	fmt.Println(s1)
	fmt.Println(s2)
	fmt.Println(s3)
	fmt.Println(s4)
	fmt.Println(s5)
	fmt.Println(s6)
	fmt.Println(s7)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pmHm1b2F-1667874231493)(slice2.png)]

切片是引用类型，浅拷贝

package main

import "fmt"

func main() {
   a1 := []int{1, 2, 3}
   a2 := a1
   a2[0] = 10
   fmt.Println(a1, a2)
   a1[2] = 30
   fmt.Println(a1, a2)
}

使用copy函数进行深copy

它表示把切片 src 中的元素拷贝到切片 dst 中
返回值为拷贝成功的元素个数
如果 src 比 dst 长，就截断
如果 src 比 dst 短，则只拷贝 src 那部分：

package main

import "fmt"

func main() {
	a1 := []int{1, 2, 3}
	a2 := make([]int, 3)
	a3 := make([]int, 5)
	copy(a2, a1)
	copy(a3, a1)

	a2[0] = 10
	fmt.Println(a1, a2)
	a1[2] = 30
	fmt.Println(a1, a2)
	fmt.Println(a3)
}

切片作为参数传给函数

虽然函数传参是指传递，应该是深拷贝
但是slice属于引用类型，浅拷贝，在函数内部的修改还是会影响外部

package main

import "fmt"

func showSlice(s []int) {
	fmt.Printf("[传入的切片为:%v]\n", s)
	s[2] = 30
}

func main() {
	a1 := []int{1, 2, 3}
	showSlice(a1)
	fmt.Printf("[showSlice处理后的切片为:%v]\n", a1)
}

切片遍历

for range 遍历

返回索引和值
range 创建了每个元素的副本，而不是直接返回对该元素的引用

package main

import "fmt"

func main() {
	a1 := []int{10, 20, 30}
	// 遍历查看值
	for index, num := range a1 {
		fmt.Printf("[index :%d,num:%d]\n", index, num)
	}
	//遍历修改值
	for index := range a1 {
		a1[index] += 100
	}
	for index, num := range a1 {
		fmt.Printf("[index :%d,num:%d]\n", index, num)
	}
}

切片扩容和cap字段作用

假设没有cap只有len，怎么扩容
1. slice长度为10，len=10，元素已经满了，现在要插入第11个元素
2. slice长度扩为20，len=20，此时有用的元素为11个，还有9个空位。
3. slice对外界暴露的接口只有ptr和len=20，如果此时再需要插入元素
4. slice到底应该扩容还是在原有的基础上直接插入呢，如果直接插入从哪个索引插入
cap字段的作用就是为了方便扩容

package main

import "fmt"

func main() {

	a1 := []int{10, 11, 12, 13}
	fmt.Printf("len：%d cap：%d\n", len(a1), cap(a1))
	a1 = append(a1, 22)
	fmt.Printf("len：%d cap：%d\n", len(a1), cap(a1))
}

当这个 append 操作完成后，newSlice 拥有一个全新的底层数组，这个数组的容量是原来的两倍
append() 会智能地处理底层数组的容量增长。在切片的容量小于 1000 个元素时，总是会成倍地增加容量。一旦元素个数超过 1000，容量的增长因子会设为 1.25，也就是会每次增加 25%的容量(随着语言的演化，这种增长算法可能会有所改变)。

package main

import "fmt"

func main() {

	a1 := []int{10, 11, 12, 13}
	fmt.Printf("len：%d cap：%d\n", len(a1), cap(a1))
	a1 = append(a1, 22)
	fmt.Printf("len：%d cap：%d\n", len(a1), cap(a1))
	a2 := make([]int, 1000)
	a1 = append(a1, a2...)
	fmt.Printf("len：%d cap：%d\n", len(a1), cap(a1))
	a3 := make([]int, 1000)
	a1 = append(a1, a3...)
	fmt.Printf("len：%d cap：%d\n", len(a1), cap(a1))

}

n(a1), cap(a1))
a1 = append(a1, 22)
fmt.Printf(“len：%d cap：%d\n”, len(a1), cap(a1))
a2 := make([]int, 1000)
a1 = append(a1, a2…)
fmt.Printf(“len：%d cap：%d\n”, len(a1), cap(a1))
a3 := make([]int, 1000)
a1 = append(a1, a3…)
fmt.Printf(“len：%d cap：%d\n”, len(a1), cap(a1))

}