Go語言學習筆記-07數組與

數組

Go語言中的數組是一個長度固定，由相同類型的元素組成

聲明

隻聲明，不初始化，預設為資料類型的零值

var arr [個數]資料類型           

聲明并初始化

var arr [5]int = [5]int{} // [0,0,0,0,0]
var arr [5]int = [5]{1,2,3,4,5} // [1,2,3,4,5]           

為某些位置設定值，其餘保持為0

var arr [5]int = [5]int{3:9} // [0,1,3,9,0] 為第4個元素設定值，其餘保持為0           

使用...自動設定元素個數

var arr = [...]{1,2,3,4,5}           

使用...設定稀疏數組

var arr = [...]{49:50} // 設定第50個元素值為50，其餘的為0           

多元數組聲明

var arr [2][3]int // 聲明了一個2行3列的數組           

可以拆開來看，看作2個[3]int

多為數組初始化

// 第2維以後的類型申明可寫可不寫
var arr = [2][3]int{[3]int{1,2,3},[3]int{4,5,6}}
var arr = [2][3]int{{1,2,3},{4,5,6}}           

ch07/main.go

package main

import "fmt"

func main() {
 // 聲明不初始化，預設為資料類型的零值
 var arr1 [5]int
 fmt.Println("arr1", arr1)

 // 聲明并初始化
 var arr2 [5]int = [5]int{1, 2, 3, 4, 5}
 fmt.Println("arr2", arr2)

 // 為某些位置設定值，其餘保持為0
 var arr3 [5]int = [5]int{3: 9}
 fmt.Println("arr4", arr3)

 // 使用...自動設定元素個數
 var arr4 = [...]int{4: 5}
 fmt.Println("arr4", arr4)

 // 多元數組
 var arr5 = [2][3]int{[3]int{1, 2, 3}, {4, 5, 6}}
 fmt.Println("arr5", arr5)
}           

輸出

arr1 [0 0 0 0 0]
arr2 [1 2 3 4 5]      
arr4 [0 0 0 9 0]      
arr4 [0 0 0 0 5]      
arr5 [[1 2 3] [4 5 6]]           

擷取數組的長度

使用内置函數len擷取

package main

import "fmt"

func main() {
 var arr = [5]int{}
 fmt.Printf("arr的長度為%d", len(arr))
}           

輸出

arr的長度為5           

讀取數組的值

使用下标擷取數組的值，下标從0開始，不支援負數擷取

package main

import "fmt"

func main() {
 var arr = [5]int{1, 2, 3, 4, 5}

 fmt.Printf("arr[1]=%d", arr[1])
}           

切片

切片與數組很相像，隻是它的長度不是固定的，随着元素的增多動态地變化

切片在go中的底層實作，是由一個指向底層數組的指針，切片的長度（切片元素的個位）以及底層數組的長度（切片的最大容量）三部分組成

可以通過内置函數len擷取切片長度，通過内置函數cap擷取切片容量

ch07/lenandcap/main.go

package main

import "fmt"

func main() {
 var slice = []int{1, 2, 3, 4, 5}
 fmt.Printf("slice 的長度為：%d,容量為：%d", len(slice), cap(slice))
}           

輸出

slice 的長度為：5,容量為：5           

聲明

var slice []資料類型           

聲明并初始化，長度和容量相等

var slice = []int{1,2,3,4,5} // [1,2,3,4,5] len=5 cap=5           

隻聲明不初始化，長度和容量都為0，切片的預設值為nil

var slice []int // []int(nil) len=0 cap=0           

ch07/sliceinit/main.go

package main

import "fmt"

func main() {
 var slice1 = []int{1, 2, 3, 4, 5}
 var slice2 []int
 fmt.Printf("slice1 %v 長度為：%d，容量為：%d\n", slice1, len(slice1), cap(slice1))
 fmt.Printf("slice2 %#v 長度為：%d，容量為：%d\n", slice2, len(slice2), cap(slice2))
}           

輸出

slice1 [1 2 3 4 5] 長度為：5，容量為：5
slice2 []int(nil) 長度為：0，容量為：0           

通過make函數建立切片

var slice = make([]資料類型，長度，容量)           

ch07/makeslice/main.go

package main

import "fmt"

func main() {
 slice := make([]int, 5)
 slice2 := make([]int, 5, 10)

 fmt.Printf("slice %v 長度：%d，容量：%d\n", slice, len(slice), cap(slice))
 fmt.Printf("slice2 %v 長度：%d，容量：%d\n", slice2, len(slice2), cap(slice2))
}           

輸出

slice [0 0 0 0 0] 長度：5，容量：5
slice2 [0 0 0 0 0] 長度：5，容量：10           

通過數組建立切片

可以通過array[low:high:max]形式從一個數組中擷取到一個切片，此時切片起始元素是數組下标為low的元素，切片的長度為high-low，切片的容量為max-low，切片的底層數組就是就是array，換言之，修改切片的值，array同樣也會受到影響

array[low:high]，max省略時，max的預設值為數組的長度

array[:]可以得到一個和arr元素一樣的切片

ch07/arraytoslice/main.go

package main

import "fmt"

func main() {
 arr := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
 slice1 := arr[2:7:8] // [2,3,4,5,6]
 slice2 := arr[:]     // [1,2,3,4,5,6,7,8,9,10]
 slice3 := arr[3:4]   // [4]

 fmt.Printf("slice1 %v，長度：%d，容量：%d\n", slice1, len(slice1), cap(slice1))
 fmt.Printf("slice2 %v，長度：%d，容量：%d\n", slice2, len(slice2), cap(slice2))
 fmt.Printf("slice3 %v，長度：%d，容量：%d\n", slice3, len(slice3), cap(slice3))

 // 修改切片的第4個元素，及把6改為12
 slice1[3] = 12

 // 原數組arr發生改變
 fmt.Printf("修改後slice1 %v，長度：%d，容量：%d\n", slice1, len(slice1), cap(slice1))
 fmt.Printf("修改後slice2 %v，長度：%d，容量：%d\n", slice2, len(slice2), cap(slice2))
 fmt.Printf("修改後arr %v\n", arr)
}           

輸出

slice1 [3 4 5 6 7]，長度：5，容量：6
slice2 [1 2 3 4 5 6 7 8 9 10]，長度：10，容量：10       
slice3 [4]，長度：1，容量：7                            
修改後slice1 [3 4 5 12 7]，長度：5，容量：6             
修改後slice2 [1 2 3 4 5 12 7 8 9 10]，長度：10，容量：10
修改後arr [1 2 3 4 5 12 7 8 9 10]                  

筆記位址

github：https://github.com/xianyuyixia/gotrip