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。