Golang中的Slice与数组

1.Golang中的数组

数组是一种具有固定长度的基本数据结构,在golang中与C语言一样数组一旦创建了它的长度就不允许改变,数组的空余位置用0填补,不允许数组越界。

数组的一些基本操作:

1.创建数组:

func main() {
	var arr1 = [...]int{1,2,3,4}  //[...]默认为元素的数量即为数组的长度
	fmt.Println(len(arr1)) //4
	arr1[4] = 5    //panic 数组越界
	fmt.Println(arr1)
	var arr2 = [10]int{1,2,3,4}
	fmt.Println(arr2)  //[1 2 3 4 0 0 0 0 0 0]
}

  2.数组是值拷贝传递:

func main() {
	var arr = [10]int{4,5,7,11,8,9}
	fmt.Println(arr) //[4,5,7,11,8,9,0,0,0,0]
	//验证数组是值拷贝传递
	AddOne(arr)
	fmt.Println(arr)  //[4,5,7,11,8,9,0,0,0,0]
}

func AddOne(arr [10]int){
	arr[9] = 999999
	fmt.Println(arr)  //[4,5,7,11,8,9,0,0,0,999999]
}

2.Golang中的切片(slice) 

1.首先看看slice的源码结构:

type slice struct {
	array unsafe.Pointer
	len   int
	cap   int
}

  slice是一个特殊的引用类型,但是它自身也是个结构体

属性len表示可用元素数量,读写操作不能超过这个限制,不然就会panic

属性cap表示最大扩张容量,当然这个扩张容量也不是无限的扩张,它是受到了底层数组array的长度限制,超出了底层array的长度就会panic

2.slice的创建:

func main() {
     var arr = [...]int{0,1,2,3,4,5,6}
     slice1 := arr[1:4:5]   //{low:high:max}  最多再扩张一个元素
     //max超出 len(arr)
     //slice2 := arr[1:4:7]  //panic
     fmt.Println(slice1)  //[1,2,3]
     slice3 := slice1[1:3:4] //[2,3]  大于4会panic
     fmt.Println(slice3)
}

 上面代码中创建了一个长度为7的数组arr,同时创建一个基于数组arr的切片slice1,切片引用了数组的index=1到index=3之间的元素,同时也允许切片最大扩张1个元素大小的空间。如果这个扩张空间大于7那么程序就会panic。最后创建了一个基于slice1延申的一个切片slice2,它引用了切片的index=1到index=3之间的元素,由于slice1最大扩容1个元素,因此slice2也最多扩容一个元素,超过了会panic。

创建基于底层数组的slice,其cap取值在: len<=cap<=len(arr)之间

创建基于一个切片的slice,其cap取值在: len(slice1)<=cap<=cap(slice1)之间

3.slice使用make创建

func main() {
     var slice = make([]int,3,5)  //len=3,cap=5
     fmt.Println(slice)     //[0,0,0]
     slice2:=slice[:5]      //slice实现了对slice的扩容,切片长度变为5
     fmt.Println(slice2)   //[0,0,0,0,0]
}

4.切片作为参数传递

func main() {
     var slice = make([]int,3,5)  //len=3,cap=5
     fmt.Println(slice)     //[0,0,0]
     slice2:=slice[:5]      //slice实现了对slice的扩容,切片长度变为5
     fmt.Println(slice2)   //[0,0,0,0,0]

     slice[0] = 999        //这里slice和slice的index=0位置都是999  因为他们引用的底层数组的index=0位置都是999
     fmt.Println(slice)
     fmt.Println(slice2)

     AddOne(slice)    //[8888,0,0]
     fmt.Println(slice)  //[8888,0,0]
     fmt.Println(slice2)  //[8888,0,0,0]
}

func AddOne(s []int){
	s[0] = 8888
	fmt.Println(s)
}

  因为切片是个引用类型,所以它作为参数传递给函数,函数操作的实质是底层数组

3.Golang中的切片追加append()

func main() {
     var arr = [...]int{1,2,3,4}
     fmt.Println(arr)  //[1,2,3,4]
     slice := arr[:]
     fmt.Println(slice) //[1,2,3,4]
     slice = append(slice,[]int{5,6,7}...)  //此时slice的引用地址已经发生改变了,它引用的底层数组再也不是arr了,而是一个新的数组newarr[1,2,3,4,5,6,7]
     fmt.Println(slice)  //[1,2,3,4,5,6,7]
     //验证slice引用的地址已经发生改变
     slice[0] = 666
     fmt.Println(arr)  //[1,2,3,4]
     fmt.Println(slice) //[666,2,3,4,5,6,7]
}

  这里由于slice进行追加的元素超出了原来数组的大小,因此go内部会帮我们创建一个新的底层数组,而slice的引用地址不再是arr了,变成了新创建的数组。

还有一种情况就是当slice进行追加的时候没有超出原来数组的大小的时候,其引用地址没有发生改变

func main() {
     var arr = [6]int{1,2,3,4}
     fmt.Println(arr)  //[1,2,3,4,0,0]
     slice := arr[:4]
     fmt.Println(slice) //[1,2,3,4]
     slice = append(slice,5)
     fmt.Println(arr) //[1,2,3,4,5,0]
     fmt.Println(slice)  //[1,2,3,4,5]
}

4.总结

    (1)go是有数组的,只是平时用切片比较多。数组大小一旦创建就不能改变,数组长度大于元素个数的时候会用0补位,这跟其他语言是相通的。

(2)切片slice可以看作是对数组的一切操作,它是一个引用数据类型,其数据结构包括底层数组的地址,以及元素可操作长度len或可扩容长度cap。

(3)要想突破slice的扩容cap限制进行无限扩容就需要使用append()函数进行操作。如果append追加的元素后slice的总长度不超过底层数组的总长度,那么slice引用的地址不会发生改变,反之引用地址会           变成新的数组的地址。

(4)slice是一个抽象的概念,它存在的意义在于方便对一个顺序结构进行一些方便操作,例如查找,排序,追加等等,这个类似于python的list。

原文地址:https://www.cnblogs.com/alienwu/p/12364390.html

时间: 2024-10-20 00:01:11

Golang中的Slice与数组的相关文章

golang中,slice的几个易混淆点

slice在golang中是最常用的类型,一般可以把它作为数组使用,但是比数组要高效呀.不过,我感觉这个东西用的不好坑太多了.还是需要了解下他底层的实现 slice的结构定义 type slice struct { array unsafe.Pointer len int cap int } 看结构定义,就三个字段,那个指针指向的就是底层数组,所以说slice的底层结构就是数组. slice的声明 第一种方式 var s []int #和数组差不多,[]中间不要数字 第二种方式 s :=[]in

golang中的slice翻转存在以及map中的key判断

//slice翻转 func stringReverse(src []string){ if src == nil { panic(fmt.Errorf("the src can't be empty!")) } count := len(src) mid := count/2 for i := 0;i < mid; i++{ tmp := src[i] src[i] = src[count-1] src[count-1] = tmp count-- } } //判断是否包含 f

golang中不定参数与数组切片的区别

package main import "fmt" func main() { myfunc1(88, 42, 12, 56) //传递不定数量的参数 myfunc2([]int{88, 42, 12, 56}) //传递一个数组切片 } func myfunc1(args ...int) { //接受不定数量的参数,这些参数的类型全部是int for _, arg := range args { fmt.Println(arg) } } func myfunc2(args []int

golang中Array与Slice

在golang中有数组和Slice两种数据结构,Slice是基于数组的实现,是长度动态不固定的数据结构,本质上是一个对数组字序列的引用,提供了对数组的轻量级访问.那么在go的函数中以数组或Slice为形参的时候就存在一些差别. ? 首先,golang中是值传递,并且如果传递的参数是数组的时候并不会隐式将数组作为引用或者指针传入,而是传入副本,而如果想轻量级传递数据,这个时候就需要使用slice了. 可以通过一个简单的例子来验证这个机制: package main import "fmt"

golang中判断两个slice是否相等

在golang中我们可以轻松地通过==来判断两个数组(array)是否相等,但遗憾的是slice并没有相关的运算符,当需要判断两个slice是否相等时我们只能另寻捷径了. slice相等的定义 我们选择最常见的需求,也就是当两个slice的类型和长度相同,且相等下标的值也是相等的,比如: a := []int{1, 2, 3} b := []int{1, 2, 3} c := []int{1, 2} d := []int{1, 3, 2} 上述代码中a和b是相等的,c因为长度和a不同所以不相等,

golang中的数组

概念:指同一系列同一类型数据的集合. 声明方法如下: [32]byte                          //长度为32的数组 [2*N] struct { x, y int32}  //复杂类型的数组 [1000]*float64                //指针数组 [3][5]int                          //二维数组 [2][2][2]float64              //等同于[2]([2]([2]float64)) 获取数组长

golang中省略返回值造成内存泄漏

我已经两次因为不恰当的省略go中的函数返回值,一次造成MySql的too many connection错误,一次造成严重的内存泄漏.所以在这里大家分享一下这个问题和解决办法,也提醒自己以后不要再犯类似的错了. 众所周知,go中的函数可以返回多个值.但很多时候我们并不需要所有的值,而且go中定义了一个变量必须使用才可以,不然会报错.所以对于不需要的返回值,一般的操作方法就是省略: for _,value := range slice{ //.... } 一个典型就是上面的range.range可

Golang 入门 : 切片(slice)

切片(slice)是 Golang 中一种比较特殊的数据结构,这种数据结构更便于使用和管理数据集合.切片是围绕动态数组的概念构建的,可以按需自动增长和缩小.切片的动态增长是通过内置函数 append() 来实现的,这个函数可以快速且高效地增长切片,也可以通过对切片再次切割,缩小一个切片的大小.因为切片的底层也是在连续的内存块中分配的,所以切片还能获得索引.迭代以及为垃圾回收优化的好处.本文将介绍 Golang 切片的基本概念和用法,演示环境为 ubuntu 18.04 & go1.10.1. 切

golang中interface接口的深度解析

什么是interface,简单的说,interface是一组method的组合,下面这篇文章主要给大家深度解析了关于golang中的interface接口,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧. 一 接口介绍 如果说gorountine和channel是支撑起Go语言的并发模型的基石,让Go语言在如今集群化与多核化的时代成为一道亮丽的风景,那么接口是Go语言整个类型系列的基石,让Go语言在基础编程哲学的探索上达到前所