前言
Go中的數組數據類型的長度在聲明之后就無法修改了，切片是基於數組實現的，切片是動態數組，切片是1種可變長度的序列。它支持擴容。
切片不保存值，只保存（len、cap、底層數組的指針），在底層引用數組的值也就是引用數據類型，
接觸了Go中arry、slice，會感覺到Python里面的list數據類型是如此的便捷，感謝Python的作者吧。
Go相對於Python來說是比較偏向底層的語言，為什么只能在arry、slice中只能存相同數據類型的值，是因為Go僅僅選中1塊連續的內存地址。
而Python的list可以存不同的數據類型，是因為Python解釋器會幫我們通過算法查找散列在 不連續內存上的不同內存地址來獲取值。
所以Go執行效率高，但是Python開發效率高。
切片和數組不同的是：
每個切片底層都對應1個數組，為這個切片存值， 所以slice類型變量 在沒有初始化前沒有分配內存、所以就根本沒有默認值 =nil，因為你沒有初始化指定長度和元素的數據類型，怎么給你分配這個底層數組呢？
//聲明1個數組變量 var a1 [3]int fmt.Println(a1)//聲明完了就有默認值 //聲明1個切片類型的變量 var s1 []int fmt.Println(s1 == nil)
引子
為什么在Go中有了數組，還需要1個可變長度的切片呢？因為數組需要支持擴容！
package main
import "fmt"
func arraySum(x [3]int) int {
sum := 0
for _, v := range x {
sum = sum + v
}
return sum
}
func main() {
a1 := [3]int{1, 2, 3}
//如果函數的參數定義了參數的長度，只能傳長度為3的數組，所以數組有一定的局限性
total := arraySum(a1)
fmt.Println(total)
}
//.\main.go:14:24: array index 3 out of bounds [0:3]
切片的定義和初始化
切片類型和數組類型一樣，想要使用，就必須要定義和初始化，不同之處已經提到，切片不需要指定切片的長度。
自定義切片
package main
import (
"fmt"
)
func main() {
//切片的定義
var s1 []int //存放元素不限定，僅限定數據類型
var s2 []string
fmt.Println(s1 == nil) //在初始化之前切片的值=nil
fmt.Println(s2 == nil)
//切片的初始化
s1 = []int{1, 2, 3}
s2 = []string{"劉德華", "郭富城", "黎明", "梁朝偉"}
//切片的長度和容量
fmt.Printf("長度：%d 容量：%d", len(s1), cap(s1))
}
由數組得到切片 slice := arry [ : ]
package main
import "fmt"
var a1 [3]string
func main() {
a1 = [3]string{"a", "b", "c"}
// fmt.Printf("%T\n", a1)
s1:=a1[:]//數組變成了1個切片,但是使用a1數組存儲數據！
// fmt.Printf("%T\n", a1)
s1[0]="1"
s1[1]="2"
s1[2]="3"
// s1[3]="4"
// s1[5]="5"
fmt.Println(s1)
}
package main
import (
"fmt"
)
func main() {
a1 := [...]int{1, 2, 3, 4, 5, 6, 69}
s1 := a1[0:2]
s2 := a1[:4]
s3 := a1[2:]
s4 := a1[:]
fmt.Println(s1, s2, s3, s4)
//切片的容量:是指底層數組的從切邊的第1個元素-----》最后1個元素的數量
fmt.Printf("切片的長度：%d 切片的容量：%d\n", len(s1), cap(s1))
fmt.Printf("切片的長度：%d 切片的容量：%d\n", len(s2), cap(s2))
fmt.Printf("切片的長度：%d 切片的容量：%d\n", len(s3), cap(s3))
}
切片的內存管理機制
如果我對切片A再進行切片([區間])或者變量賦值就會拿到1個新的切片B，如果給切片B追加元素那么會影響會怎樣呢？
如果我們對切片B進行了appen，那么B的lengh就會不同於A。
如果沒有超出容量，切片A、B會同用1個底層數組。
如果超出了原來容量則創建新的底層數組以支撐這個新的切片。
v1 := make([]int, 3, 5) fmt.Println(v1,len(v1),cap(v1)) //v1=[0 0 0] v2 := append(v1, 8) fmt.Println(v2,len(v2),cap(v2)) //v2=[0 0 0 8] fmt.Println(v1,len(v1),cap(v1)) //v2切片的長度經過append之后len=4,切片v1(不同於v2)的長度還是3,他的len決定了v1不會看到8 //[0 0 0] //[0 0 0 8] //[0 0 0]
在Python里面對列表進行切片會開辟1塊內存地址存儲產生的新列表肯定不會影響。
在golang中如果對切片的切片進行apend操作，append的值會直接覆蓋底層數組中值。
Go會.........因為你對1個切片，切幾次產生的 “新”切片，只是指針、長度不同，本質都引用了同1個底層數組。
//6.刪除元素：go語言沒有直接刪除切片元素的API var numberList= []string{"a","b","c","c","d","e"} deleteIndex:=2 //刪除c：切片numberList的切片["a","b"]追加了["c","d","e"]相當於操作了底層數組把原來的c、c、d覆蓋成了c、d、e numberList=append(numberList[0:deleteIndex],numberList[deleteIndex+1:]...) //本質原因還是切片numberList和切片numberList的切片["a","b"]共同引用了同1個底層數組 fmt.Println(numberList)
切片自動擴容的內存管理機制
1.每1個切片底層都對應了1個數組來保存值，而切片保存這個底層數組的長度（len）、容量（ cap）、底層數組的位置 （point）。
v1:=make([]int,1,3) fmt.Println(len(v1),cap(v1))
2.切片append元素（不產生擴容的情況）
切片追加元素時，在不會產生擴容的情況下，append之后產生的新切片和原切片引用同1個底層數組。
所以對切片進行再次切片時產生的新切片們，本質上就是引用的還是1個底層數組，只不過它們的長度不同，從這塊內存上獲取數據的起始位置不一樣。
v1:=make([]int,1,3) v2:=append(v1,66) //返回新的切片v2 fmt.Println(v1) //[0] fmt.Println(v2) //[0,66] v1[0]=99 fmt.Println(v1) //[99] fmt.Println(v2) //[99 66] fmt.Printf("v1的內存地址：%p,v2的內存地址:%p。",v1,v2)
3.切片在追加（append）元素時，出現了擴容。
一旦出現了擴容就會產生1個新的底層數組來保存原來的數據和新的數據。
所以新、舊切片使用了2個不同的底層數組。它們之間的修改操作不再彼此影響！
v1 :=[]int{11,22,33} //創建1個切片長度為3，容量為3 fmt.Printf("%v 的長度為：%d,容量為%d.\n",v1,len(v1),cap(v1))
--------------------------------------------------------------- v2:=append(v1,44) //apend時產生了擴容，長度為4，容量為6 fmt.Printf("%p\n",v2) v1[0]=101 v2[0]=222 fmt.Printf("%v的長度為：%d,容量為%d.\n",v1,len(v1),cap(v1)) fmt.Printf("%v的長度為：%d,容量為%d.\n",v2,len(v2),cap(v2))
切片為引用類型論證
Go中的切片底層都有1個數組支撐， 切引用這個底層數組的值，所以底層數組改變，切片的值也改變；
// package main
// import (
// "fmt"
// )
// func main() {
// //切片的定義
// var s1 []int //存放元素不限定，僅限定數據類型
// var s2 []string
// fmt.Println(s1 == nil) //在初始化之前切片的值=nil
// fmt.Println(s2 == nil)
// //切片的初始化
// s1 = []int{1, 2, 3}
// s2 = []string{"劉德華", "郭富城", "黎明", "梁朝偉"}
// //切片的長度和容量
// fmt.Printf("長度：%d 容量：%d", len(s1), cap(s1))
// }
// package main
// import (
// "fmt"
// )
// func main() {
// a1 := [...]int{1, 2, 3, 4, 5, 6, 69}
// s1 := a1[0:2]
// s2 := a1[:4]
// s3 := a1[2:]
// s4 := a1[:]
// fmt.Println(s1, s2, s3, s4)
// //切片的容量:是指底層數組的從切邊的第1個元素-----》最后1個元素的數量
// fmt.Printf("切片的長度：%d 切片的容量：%d\n", len(s1), cap(s1))
// fmt.Printf("切片的長度：%d 切片的容量：%d\n", len(s2), cap(s2))
// fmt.Printf("切片的長度：%d 切片的容量：%d\n", len(s3), cap(s3))
// }
package main
import (
"fmt"
)
func main() {
a1 := [...]int{1, 2, 3, 4}
s1 := a1[:3]
fmt.Println(s1)
a1[0] = 666 //修改了a1數組，但是s1引用着a1
s2 := a1[:3]
fmt.Println(s2)
}
切片常見操作
package main import "fmt" func main() { //1.獲取切片的長度和容量 var userList = []string{"alex", "eric", "潤洪濤"} fmt.Println(len(userList), cap(userList)) //2.s索引獲取和修改值 fmt.Println(userList[0]) userList[0] = "李傑" fmt.Println(userList) //3.切片再切片:本質上引用同1個底層數組，但起始位置不一致 v1 := userList[0:2] v2 := userList[1:] v3 := userList[:3] fmt.Println(v1, v2, v3) //4.切片追加元素 v4:=append(userList,"小明","二狗","小剛子") fmt.Printf("%p---%p\n",userList,v4) //5.切片合並 var extendList=[]string{"小何","小黑"} v5:=append(userList,extendList ...) fmt.Printf("%p----%p\n",userList,v5) fmt.Println(v5) //6.切片刪除元素：go語言沒有直接刪除切片元素的API var numberList= []string{"a","b","c","c","d","e"} deleteIndex:=2 //刪除c：切片numberList的切片["a","b"]追加了["c","d","e"]相當於操作了底層數組把原來的c、c、d覆蓋成了c、d、e numberList=append(numberList[0:deleteIndex],numberList[deleteIndex+1:]...) //本質原因還是切片numberList和切片numberList的切片["a","b"]共同引用了同1個底層數組 fmt.Println(numberList) //7.切片插入元素 var userList1= []string{"a","b","d","e"} insertIndex:=2 newUserList:=make([]string,0,len(userList1)+1) //長度=0，數組中沒數據，就是不初始化值=[] newUserList=append(newUserList,userList1[:insertIndex]...) newUserList=append(newUserList,"c") newUserList=append(newUserList,userList1[insertIndex:]...) fmt.Println(numberList) //錯誤的想法 result:=append(userList1[:insertIndex],"c") result=append(result,userList1[insertIndex:]...) fmt.Println(result) //8.循環切片 for i:=0;i<len(newUserList);i++{ fmt.Println(newUserList[i]) } //8.for range collection for i, v := range newUserList { fmt.Println(i,v) } }
使用make函數構造切片
特點：可以指定切片的長度和容量
package main
import "fmt"
func main() {
//使用make函數創建切片
s1 := make([]string, 10, 20) //string數據類型，指定長度為10，容量為20
fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d\n", s1, len(s1), cap(s1))
//s1=[ ] len(s1)=10 cap(s1)=20
s2 := make([]int, 0, 10)
fmt.Printf("s2=%v len(s2)=%d cap(s2)=%d\n", s2, len(s2), cap(s2))
//s2=[] len(s2)=0 cap(s2)=10
}
如何判斷1個空的slice
package main
import "fmt"
func main() {
var s1 []int
fmt.Println(s1 == nil) //true
//切片在賦值階段才會 創建1個底層數組 來存儲該切片的值，所以在沒有真正賦值前切片沒有對應的底層數組，所以此時的切片值為nil
s1 = []int{}
//如果創建了1個空的切片，它的底層就綁定了1個數組（該數組為空）,所以此時的切片不為nil
fmt.Println(s1 == nil)//false
//那么我們判斷1個切片是否為空時應該 判斷slice的長度是否為0
fmt.Println(len(s1))
}
切片擴容策略
As I mentioned 每個切片都會指向一個底層數組（固定長度），當切片擴容時它所指向的 定長數組就不能容納新的元素，所以當底層數組不能容納新增的元素時，切片就會自動按照一定的策略進行“擴容”，此時該切片指向的底層數組就會更換。“擴容”操作往往發生在append()函數調用時，所以我們通常都需要用原變量接收append函數的返回值。
//切片的擴容策略
package main
import (
"fmt"
)
var numSlice []int
func main() {
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:0xc000012098
[0 1] len:2 cap:2 ptr:0xc0000120f0
[0 1 2] len:3 cap:4 ptr:0xc00000a3e0
[0 1 2 3] len:4 cap:4 ptr:0xc00000a3e0
[0 1 2 3 4] len:5 cap:8 ptr:0xc000010200
[0 1 2 3 4 5] len:6 cap:8 ptr:0xc000010200
[0 1 2 3 4 5 6] len:7 cap:8 ptr:0xc000010200
[0 1 2 3 4 5 6 7] len:8 cap:8 ptr:0xc000010200
[0 1 2 3 4 5 6 7 8] len:9 cap:16 ptr:0xc000068080
[0 1 2 3 4 5 6 7 8 9] len:10 cap:16 ptr:0xc000068080
*/
首先判斷，如果新申請容量（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類型的擴容策略就不一樣。
可以通過查看$GOROOT/src/runtime/slice.go源碼，其中擴容相關代碼如下：
ewcap := 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
}
}
}
切片嵌套
package main import "fmt" func main() { v1 := []int{11, 22, 33, 44, 55, 66} fmt.Println(v1) //切片套切片 v2 := [][]int{[]int{1, 2}, []int{3, 4}} fmt.Println(v2) //切片套數組 v3 := [][2]int{[2]int{1, 2}, [2]int{3, 4}} fmt.Println(v3) }
slice數據copy（深度拷貝）
既然slice是引用的數據類型，那么我們如何進行深度拷貝？
Go語言內建的copy()函數可以迅速地將一個切片的數據復制到另外一個切片空間中，copy()函數的使用格式如下：
package main
import "fmt"
func main() {
s1 := []int{1, 3, 5}
s2 := s1
var s3 = make([]int, 3, 5) //[0 0 0] 注意make創建的切片是有默認值的不是空的
fmt.Println(s1, s2, s3)
//Go語言內建的copy()函數可以迅速地將一個切片的數據復制到另外一個切片空間中，copy()函數的使用格式如下：
copy(s3, s1) //參數1:目標序列 參數2：源序列
s1[0]=100
fmt.Println(s1, s2, s3)
/*
s1為[100 3 5]
s2為[100 3 5]
s3為[1 3 5]
s1和s2指向的還是同1個底層數組
copy的操作僅僅是將s1里面的元素，copy到s3里面，但引用了s3引用了1個新的底層數組
*/
}
切片數據刪除元素
Go中沒有內置的方法，對切片中的元素進行刪除操作；
package main
import "fmt"
func main() {
//從切片中刪除元素
s1 := []string{"齊國", "楚國", "美國", "日本", "燕國", "韓國", "趙國", "魏國", "秦國"}
//美國和日本不屬於戰國七雄，怎么把它刪除掉？
fmt.Println(s1)
s1 = append(s1[:2], s1[4:]...)
fmt.Println(s1)
}
切片==比較
slice中的數據真正存儲在底層數組中，slice是引用數據類型不支持==比較，那我們如何對slice進行相等的比較呢？
需要借助reflect包中的deepEqual方法。
package main
import (
"fmt"
"reflect"
)
func main() {
//在go中數組是支持比較的，因為它是值類型
a1 := [3]int{1, 2, 3}
a2 := [3]int{1, 2, 3}
s1 := []int{1, 2, 3}
s2 := []int{1, 2, 3}
fmt.Println(a1 == a2)
//在go中對2個slice進行比較需要借助refelect
fmt.Println(reflect.DeepEqual(s1, s2))
}
切片排序和元素索引
我們可以借助go語言內置的sort包對切片進行排序。
在查找切片某1元素的index位置時，需要提前對切片進行排序這一點和Python/JS有很大不同。
JavaScript
arry1=[3,19,88]
console.log(arry1.indexOf(88))
Python
l1=[1,12,2] print(l1.index(2))
Golang
在Golang中我們需要自己進行循環遍歷然后seek到某個在slice中的index位置，
或者借助sort包中的search功能，但是該功能的實現為二分法查找法，所以我們需要對since提前進行排序。
package main
import (
"fmt"
"sort"
)
func main() {
//切片排序
numberList := []int{
1993, 1955, 1988, 1990, 1958,
}
sort.Ints(numberList)
fmt.Println(numberList)
//切片倒序
sort.Sort(sort.Reverse(sort.IntSlice(numberList)))
fmt.Println(numberList)
//字符串排序
nameList := []string{"aa", "bbx", "xx"}
sort.Strings(nameList)
fmt.Println(nameList)
//在切片中查詢元素
fmt.Println(numberList)
books := []string{"Hello", "World", "Ni", "Hao", "Mei", "Nv"}
//必須先排序之后才能獲取索引，因為SearchStrings使用二分法查找，有序是前提。
sort.Strings(books)
fmt.Println("現在你看到的是排序后的books", books)
fmt.Println(sort.SearchStrings(books, "Ni"))
}
Go切片面試題
練習
package main import "fmt" func main() { /* 1.簡述切片和數組的區別？ 區別1.切片變量賦值之后產生的新，在新切片在不擴容的前提下，如果修改了元素，底層數組和共同引用這一數組的切片會受影響 區別2.數組變量賦值之后產生的新數組，不會和原數組使用1塊內存。 區別3：切片支持自動擴容，數組不可以。 2.簡述new和make的區別？ new返回的是一個對象的指針類型，make返回的是一個對象 make初始比new多了2個參數，make可以幫助我們設置數據類型的默認長度、默認容量 3.看代碼寫結果 v1:=make([]int,2,5) fmt.Println(v1[0],len(v1),cap(v1)) 結果---0 2 5 4.看代碼寫結果 v1 := make([]int, 2, 5) v2 := append(v1, 123) //[0 0 123] fmt.Println(v2) //2 5 fmt.Println(len(v1), cap(v1)) //3 5 fmt.Println(len(v2), cap(v2) 5.看代碼寫結果:切片擴容了 v1 := make([]int, 2, 2) v2 := append(v1, 123) v1[0]=99 fmt.Println(v1) fmt.Println(v2) 6.看代碼寫結果：切片沒有擴容 var v1=make([]int,2,2) v2:=v1[0:2] v1[0]=11 fmt.Println(v1) fmt.Println(v2) //[11 0] //[11 0] 7.看代碼猜結果 v1:=[][]int{[]int{11,22,33,44},[]int{44,55}} v1[0][2]=333 fmt.Println(v1) //[[11 22 333 44] [44 55]] 8.看代碼寫結果 v1:=[][]int{[]int{11,22,33,44},[]int{44,55}} v2:=v1[0] v2[1]=222 fmt.Println(v1) fmt.Println(v2) [[11 222 33 44] [44 55]] [11 222 33 44] 10.看代碼寫結果 v1:=[][]int{[]int{11,22,33,44},[]int{44,55}} v2:=append(v1[0],99) //擴容了產生了新的底層數組 [11 22 33 44 99] v2[2]=444 fmt.Println(v1) //[[11 22 33 44] [444 55]] 11.看代碼寫結果 v1 := [][]int{make([]int, 2, 5), make([]int, 2, 3)} //[[0 0] [0 0]] v2 := append(v1[0], 99) //v2=[0 0 99]沒有擴容 v2[0] = 66 //v2=[66 0 99] fmt.Println(v2) fmt.Println(v1) //由於v1的len沒有改變，所以它看到的是 [[66 0] [0 0]] */ v1 := [][]int{make([]int, 2, 5), make([]int, 2, 3)} //[[0 0] [0 0]] v2 := append(v1[0], 99) //v2=[0 0 99]沒有擴容 v2[0] = 66 //v2=[66 0 99] fmt.Println(v2) fmt.Println(v1) //由於v1的len沒有改變，所以它看到的是 [[66 0] [0 0]] }
基於slice實現隊列和棧
package main
import "fmt"
func main() {
//基於切片實現一個隊列
queue := []string{}
queue = append(queue, "a", "b", "c")
fmt.Println(queue[0])
queue = queue[1:]
fmt.Println(queue[0])
queue = queue[1:]
fmt.Println(queue[0])
//基於切片實現一個棧
stack := []string{}
stack = append(stack, "a", "b", "c")
fmt.Println(stack[len(stack)-1])
stack = stack[:len(stack)-1]
fmt.Println(stack[len(stack)-1])
stack = stack[:len(stack)-1]
fmt.Println(stack[len(stack)-1])
}
面試題1
package main
import "fmt"
func main() {
a1 := [...]int{1, 3, 5} //數組
s1 := a1[:] //切片
fmt.Println(s1, len(s1), cap(s1))
s1 = append(s1[:1], s1[2:]...)
fmt.Println(s1, len(s1), cap(s1))
fmt.Println(a1) //底層數組：[1 5 5]
}
/*
每1個切片都會指向1個底層數組來幫這個切片存儲數據（就就像 前端和數據庫的關系），切片本身不保存數據值
底層數組就是占用了1塊連續的內存
程序員在引用某底層數組的任意1個切片（前端）修改了底層數組（數據庫）數據都會發生變化
】
*/
面試題2
package main
import "fmt"
func main() {
s1 := make([]int, 5, 10)
//坑就在make()make創造的切片已經開辟內存了，所以此時s1=[0 0 0 0 0 0 ]
for i := 0; i < 10; i++ {
s1 = append(s1, i)
}
fmt.Println(s1) //[0 0 0 0 0 0 1 2 3 4 5 6 7 8 9]
}
初始化1個6行7列的數組
var bigArry [6][]int func main() { for i := 0;i<6;i++ { bigArry[i] = make([]int,7) } fmt.Println(bigArry) bigArry=[6][]int{ []int{0,0,0,0,0,0,0}, []int{0,0,0,0,0,0,0}, []int{0,0,0,0,0,0,0}, []int{0,0,0,0,0,0,0}, []int{0,0,0,0,0,0,0}, []int{0,0,0,0,0,0,0}, } fmt.Println(bigArry) }