ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 其他分享> 文章详细

Go语言学习12-切片扩容

2022-02-20 18:00:48  阅读：323  来源： 互联网

标签：12 s1 cap len 切片 Go fmt append


思考

先思考一个问题：如何给切片添加元素？下面这串代码行不行？是错误的，不能直接用s1[3]来添加元素，否则会造成索引越界。

package main

import "fmt"

func main() {
	/*append：给切片添加元素*/
	s1 := []string{"beijing", "shanghai", "guangzhou"}
	s1[3] = "shenzhen" //错误！索引越界！
	fmt.Println(s1)
}

append()方法为切片添加元素

概述

Go语言的内建函数append()可以为切片动态添加元素。 可以一次添加一个元素，可以添加多个元素，也可以添加另一个切片中的元素（后面加…）。

func main() {
	/*append：给切片添加元素*/
	s1 := []string{"beijing", "shanghai", "guangzhou"}
	// s1[3] = "shenzhen" //错误！索引越界！
	// fmt.Println(s1)
	fmt.Printf("len(s1): %d, cap(s1): %d", len(s1), cap(s1))
	fmt.Printf("\n")
    //调用append函数必须用原来的切片变量接收返回值
	s1 = append(s1, "shenzhen")		//append追加元素，原来的底层数组放不下的时候，Go底层就会把底层数组换一个。
	fmt.Printf("len(s1):%d, cap(s1): %d", len(s1), cap(s1))
}

你会发现一个问题，为什么变化后的s1容量变成了6呢？

因为原先的切片底层的数组为3个元素，再加一个不行了，盛不下，只能再新建一块内存，让新加入的搬进来。相当于公司搬家一样，刚开始公司就2个人，一个老板一个前台，后来来了第三个人后公司盛不下了，只能再新建一块内存了。

image-20220212210010936

所以，按照这个道理来说，我再加一个，只要不超过3，容量就一直是6。这也就是为什么调用append函数必须用原来的切片变量接收返回值。

image-20220212210342148

注意

通过var声明的零值切片可以在append()函数直接使用，无需初始化。

var s []int
s = append(s, 1, 2, 3)

没有必要像下面的代码一样初始化一个切片再传入append()函数使用，

s := []int{}  // 没有必要初始化
s = append(s, 1, 2, 3)

var s = make([]int)  // 没有必要初始化
s = append(s, 1, 2, 3)

append函数添加整个切片的元素

这么写是错的，不过大概思路是没什么问题的。

ss := []string{"chengdu","chongqing","suzhou"}
s1 = append(s1,ss)

只需要改一个位置即可，千万不要笑哈，很真实，就是下面这样子：在想要添加的切片后，添加三个省略号即可！表示拆开切片，分裂元素加入

ss := []string{"chengdu","chongqing","suzhou"}
s1 = append(s1,ss...)

贴一下代码：

package main

import "fmt"

func main() {
	/*append：给切片添加元素*/
	s1 := []string{"beijing", "shanghai", "guangzhou"}
	// s1[3] = "shenzhen" //错误！索引越界！
	// fmt.Println(s1)
	fmt.Printf("len(s1): %d, cap(s1): %d", len(s1), cap(s1))

	fmt.Printf("\n")

	s1 = append(s1, "shenzhen", "hangzhou")
	fmt.Printf("len(s1):%d, cap(s1): %d", len(s1), cap(s1))

	fmt.Printf("\n")

	ss := []string{"chengdu", "chongqing", "suzhou"}
	s1 = append(s1, ss...)
	fmt.Printf("len(s1):%d, cap(s1): %d", len(s1), cap(s1))
}

image-20220212212911274

总结

1、append函数必须要用一个变量来接收返回值，这个变量必须要是之前的那个切片变量！

2、append函数允许添加一个或者多个元素来接收返回值

3、如果底层的数组不够添加元素，就会新创建一个数组，新创建一个内存区域。

4、导入新的切片元素时，使用...来分割

详细说明切片扩容策略

每个切片会指向一个底层数组，这个数组的容量够用就添加新增元素。当底层数组不能容纳新增的元素时，切片就会自动按照一定的策略进行“扩容”，此时该切片指向的底层数组就会更换。“扩容”操作往往发生在append()函数调用时，所以我们通常都需要用原变量接收append函数的返回值。

举个例子：

func main() {
	//append()添加元素和切片扩容
	var numSlice []int
	for i := 0; i < 10; i++ {
		numSlice = append(numSlice, i)
		fmt.Printf("%v  len:%d  cap:%d  ptr:%p\n", numSlice, len(numSlice), cap(numSlice), numSlice)
	}
}

输出：

[0]  len:1  cap:1  ptr:0xc0000a8000
[0 1]  len:2  cap:2  ptr:0xc0000a8040
[0 1 2]  len:3  cap:4  ptr:0xc0000b2020
[0 1 2 3]  len:4  cap:4  ptr:0xc0000b2020
[0 1 2 3 4]  len:5  cap:8  ptr:0xc0000b6000
[0 1 2 3 4 5]  len:6  cap:8  ptr:0xc0000b6000
[0 1 2 3 4 5 6]  len:7  cap:8  ptr:0xc0000b6000
[0 1 2 3 4 5 6 7]  len:8  cap:8  ptr:0xc0000b6000
[0 1 2 3 4 5 6 7 8]  len:9  cap:16  ptr:0xc0000b8000
[0 1 2 3 4 5 6 7 8 9]  len:10  cap:16  ptr:0xc0000b8000

从上面的结果可以看出：

  1. append()函数将元素追加到切片的最后并返回该切片。
  2. 切片numSlice的容量按照1，2，4，8，16这样的规则自动进行扩容，每次扩容后都是扩容前的2倍。

有什么规律呢？

切片的扩容策略规律（了解，用到的时候再看）

可以通过查看$GOROOT/src/runtime/slice.go源码，其中扩容相关代码如下：

newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
	newcap = cap
} else {
	if old.len < 1024 {
		newcap = doublecap
	} else {
		// Check 0 < newcap to detect overflow
		// and prevent an infinite loop.
		for 0 < newcap && newcap < cap {
			newcap += newcap / 4
		}
		// Set newcap to the requested cap when
		// the newcap calculation overflowed.
		if newcap <= 0 {
			newcap = cap
		}
	}
}

从上面的代码可以看出以下内容：

  • 首先判断，如果新申请容量（cap）大于2倍的旧容量（old.cap），最终容量（newcap）就是新申请的容量（cap）。
  • 否则判断，如果旧切片的长度小于1024，则最终容量(newcap)就是旧容量(old.cap)的两倍，即（newcap=doublecap），
  • 否则判断，如果旧切片长度大于等于1024，则最终容量（newcap）从旧容量（old.cap）开始循环增加原来的1/4，即（newcap=old.cap,for {newcap += newcap/4}）直到最终容量（newcap）大于等于新申请的容量(cap)，即（newcap >= cap）
  • 如果最终容量（cap）计算值溢出，则最终容量（cap）就是新申请容量（cap）。

需要注意的是，切片扩容还会根据切片中元素的类型不同而做不同的处理，比如int和string类型的处理方式就不一样。

使用copy()函数复制切片

首先我们来看一个问题：

func main() {
	a := []int{1, 2, 3, 4, 5}
	b := a
	fmt.Println(a) //[1 2 3 4 5]
	fmt.Println(b) //[1 2 3 4 5]
	b[0] = 1000
	fmt.Println(a) //[1000 2 3 4 5]
	fmt.Println(b) //[1000 2 3 4 5]
}

由于切片是引用类型，所以a和b其实都指向了同一块内存地址。修改b的同时a的值也会发生变化。

Go语言内建的copy()函数可以迅速地将一个切片的数据复制到另外一个切片空间中，copy()函数的使用格式如下：

copy(destSlice, srcSlice []T)

其中：

  • srcSlice: 数据来源切片
  • destSlice: 目标切片

举个例子：

package main

import "fmt"

func main() {
	a1 := []int{1, 3, 5}
	a2 := a1
	//var a3 []int //这么写相当于切片a3 == nil为空，肯定是将a1拷贝不进去
	var a3 = make([]int, 3) //这样子写就正确了，其实make函数不用写后面的容量都是可以的
	copy(a3, a1)
	fmt.Println(a1, a2, a3)

	a1[0] = 2000 //更改a1，那么a2也会发生变化，因为他们两个用的同一块内存
	fmt.Println(a1, a2, a3)
}

从切片中删除元素

Go语言中并没有删除切片元素的专用方法，我们可以使用切片本身的特性以及append函数来删除元素。 代码如下：

func main() {
	// 从切片中删除元素
	a := []int{30, 31, 32, 33, 34, 35, 36, 37}
	// 要删除索引为2的元素
	a = append(a[:2], a[3:]...)
	fmt.Println(a) //[30 31 33 34 35 36 37]
}

总结一下就是：要从切片a中删除索引为index的元素，操作方法是a = append(a[:index], a[index+1:]...)

练习题

1.请写出下面代码的输出结果。

func main() {
	var a = make([]string, 5, 10)
	for i := 0; i < 10; i++ {
		a = append(a, fmt.Sprintf("%v", i))
	}
	fmt.Println(a)
}

2.请使用内置的sort包对数组var a = [...]int{3, 7, 8, 9, 1}进行排序（附加题，自行查资料解答）。

标签：12,s1,cap,len,切片,Go,fmt,append
来源： https://www.cnblogs.com/sukusec301/p/15916008.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有