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。