數組可以存放多個同一類型數據。數組也是一種數據類型，在golang中，數組是值類型。
一、數組
1、數組的定義
var 數組名 [數組大小]數據類型
var arr [5]int
2、數組的內存布局
package main
import "fmt"
func main() {
var intArr [3]int
//當定義完數組后，數組的各個元素有默認值0
fmt.Println(intArr)
intArr[0] = 10
intArr[1] = 20
intArr[2] = 30
fmt.Println(intArr)
fmt.Printf("intArr的地址 = %p intArr[0] 地址 = %p intArr[1] 地址 = %p intArr[2] 地址 = %p", &intArr, &intArr[0], &intArr[1], &intArr[2])
}
數組的地址可以通過數組名來獲取 &intArr
數組的第一個元素的地址，就是數組的首地址
數組的各個元素的地址間隔是依據數組的類型決定
3、數組的使用
訪問數組元素：數組名[下標]
package main
import "fmt"
func main() {
var score [5]float64
for i := 0; i < len(score); i++ {
fmt.Printf("請輸入第%d個元素的值\n", i+1)
fmt.Scanln(&score[i])
}
for i := 0; i < len(score); i++ {
fmt.Printf("score[%d] = %v\n", i, score[i])
}
}
4、四種初始化數組的方式
package main
import "fmt"
func main() {
var numInt [3]int = [3]int{1, 2, 3}
fmt.Println("numInt = ", numInt)
var numFloat = [3]float64{1.0, 9.4, 8.0}
fmt.Println("numFloat = ", numFloat)
var numInt32 = [...]int32{8, 9, 4}
fmt.Println("numInt32 = ", numInt32)
var numInt64 = [...]int64{1: 800, 0: 9000, 2: 899}
fmt.Println("numInt64 = ", numInt64)
strArr := [...]string{2: "mary", 0: "jack", 1: "tom"}
fmt.Println("strArr = ", strArr)
}
5、數組的遍歷
(1)、傳統方式
package main
import "fmt"
func main() {
var numInt [3]int = [3]int{1, 2, 3}
for i := 0; i < len(numInt); i++ {
fmt.Printf("arr[%v] = %v\t", i+1, numInt[i])
}
}
(2)、for - range
package main
import "fmt"
func main() {
var numInt [3]int = [3]int{1, 2, 3}
for index, value := range numInt {
fmt.Printf("arr[%v] = %v\t", index, value)
}
heroes := [...]string{"宋江", "吳用", "盧俊義"}
for i, v := range heroes {
fmt.Printf("i = %v v = %v\n", i, v)
fmt.Printf("heroes[%d] = %v\n", i, heroes[i])
}
for _, v := range heroes {
fmt.Printf("元素的值 = %v\n", v)
}
}
第一個返回值index是數組的下標
第二個返回值value是下標位置的值
index和value都是僅在for循環內部可見的局部變量
遍歷數組的時候，如果不想使用下標index，可以直接把下標index標為下划線
index和value的名稱不是固定的，可以自行定義
6、數組使用的注意事項
(1)、數組是多個相同類型數據的組合,一個數組一旦聲明/定義了,其長度是固定的, 不能動態變化。
(2)、數組中的元素可以是任何數據類型，包括值類型和引用類型，但是不能混用。
(3)、數組創建后，如果沒有賦值，有默認值。數值類型數組:默認值為0 字符串數組: 默認值為"" bool數組: 默認值為false。
(4)、數組下標必須在指定范圍內使用，否則報panic:數組越界。
(5)、go的數組屬值類型，在默認情況下是值傳遞，因此會進行值拷貝。數組間不會相互影響。
(6)、如想在其它函數中，去修改原來的數組，可以使用引用傳遞(指針方式)。
(7)、長度是數組類型的一部分，在傳遞函數參數時 需要考慮數組的長度。
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
//1、創建一個 byte 類型的 26 個元素的數組，分別 放置'A'-'Z‘。使用 for 循環訪問所有元素並打印出來。提示:字符數據運算 'A'+1 -> 'B'
var myChars [26]byte
for i := 0; i < 26; i++ {
myChars[i] = 'A' + byte(i)
}
for i := 0; i < 26; i++ {
fmt.Printf("%c", myChars[i])
}
fmt.Println()
//2、請求出一個數組的最大值，並得到對應的下標。
var intArr [6]int = [...]int{1, -1, 9, 90, 11, 9000}
maxVal := intArr[0]
maxValIndex := 0
for i := 1; i < len(intArr); i++ {
if maxVal < intArr[i] {
maxVal = intArr[i]
maxValIndex = i
}
}
fmt.Printf("maxVal = %v maxValIndex = %v", maxVal, maxValIndex)
//3、請求出一個數組的和和平均值。for-range
var arr [5]int = [...]int{1, -1, 9, 90, 12}
sum := 0
for _, val := range arr {
sum += val
}
fmt.Printf("sum = %v avg = %v\n", sum, float64(sum)/float64(len(arr)))
//4、隨機生成五個數，並將其反轉打印
var randArr [5]int
len := len(randArr)
rand.Seed(time.Now().UnixNano())
for i := 0; i < len; i++ {
randArr[i] = rand.Intn(100)
}
fmt.Println("交換前~=", randArr)
tmp := 0
for i := 0; i < len/2; i++ {
tmp = randArr[len-1-i]
randArr[len-1-i] = randArr[i]
randArr[i] = tmp
}
fmt.Println("交換后~=", randArr)
}
二、切片
切片是數組的一個引用，因此切片是引用類型，在進行傳遞時，遵守引用傳遞的機制。
切片的使用和數組類似，遍歷切片、訪問切片的元素和求切片長度len(slice)都一樣。
切片的長度是可以變化的，因此切片是一個可以動態變化數組。
切片定義的基本語法:var 切片名 []類型 比如:var a [] int
package main
import "fmt"
func main() {
var intArr [5]int = [...]int{1, 22, 33, 66, 99}
slice := intArr[1:3]
fmt.Println("intArr=", intArr)
fmt.Println("slice 的元素是", slice)
fmt.Println("slice 的元素個數", len(slice))
fmt.Println("slice 的容量", cap(slice))
}
slice從底層來說，其實就是一個數據結構(struct結構體)
type slice struct{
ptr *[2]int
len int
cap int
}
1、切片的使用
(1)、定義一個切片，然后讓切片去引用一個已經創建好的數組。
package main
import "fmt"
func main() {
var arr [5]int = [...]int{1, 2, 3, 4, 5}
var slice = arr[1:3]
fmt.Println("arr=", arr)
fmt.Println("slice 的元素是", slice)
fmt.Println("slice 的元素個數", len(slice))
fmt.Println("slice 的容量", cap(slice))
}
(2)、通過make創建切片
var 切片名 []type=make([]type,len,[cap])
type就是數據類型；len就是大小；cap指定切片容量，可選，如果分配了cap,則要求cap>=len。
package main
import "fmt"
func main() {
var slice []float64 = make([]float64, 5, 10)
slice[1] = 10
slice[3] = 20
fmt.Println(slice)
fmt.Println("slice size is ", len(slice))
fmt.Println("slice capacity is ", cap(slice))
}
通過make方式創建切片可以指定切片的大小和容量
如果沒有給切片的各個元素賦值，那么就會使用默認值
通過make方式創建的切片對應的數組是由make底層維護，對外不可見，即只能通過slice去訪問各個元素
(3)、定義一個切片直接就指定具體數組，使用原理類似make的方式
package main
import "fmt"
func main() {
var strSlice []string = []string{"tom", "jack", "mary"}
fmt.Println(strSlice)
fmt.Println("strSlice size is ", len(strSlice))
fmt.Println("strSlice capacity is ", cap(strSlice))
}
2、切片的遍歷
package main
import "fmt"
func main() {
//傳統遍歷方式
var arr [5]int = [...]int{10, 20, 30, 40, 50}
slice := arr[1:4]
for i := 0; i < len(slice); i++ {
fmt.Printf("slice[%v] = %v\t", i, slice[i])
}
fmt.Println()
//for - range方式遍歷切片
for i, v := range slice {
fmt.Printf("slice[%v] = %v\n", i, v)
}
}
3、切片使用的注意事項
(1)、切片初始化時 var slice = arr[startIndex:endIndex]
說明:從arr數組下標為startIndex，取到下標為endIndex的元素(不含 arr[endIndex])。
(2)、切片初始化時，仍然不能越界。范圍在 [0-len(arr)] 之間，但是可以動態增長.
var slice = arr[0:end] 可以簡寫 var slice = arr[:end]
var slice = arr[start:len(arr)] 可以簡寫: var slice = arr[start:]
var slice = arr[0:len(arr)] 可以簡寫: var slice = arr[:]
(3)、cap是一個內置函數，用於統計切片的容量，即最大可以存放多少個元素。
(4)、切片定義完后，還不能使用，因為本身是一個空的，需要讓其引用到一個數組，或者make一個空間供切片來使用
(5)、切片可以繼續切片
package main
import "fmt"
func main() {
var arr [5]int = [...]int{10, 20, 30, 40, 50}
slice := arr[1:4]
for i, v := range slice {
fmt.Printf("slice[%v] = %v\n", i, v)
}
slice2 := slice[1:2]
slice2[0] = 100 //slice和slice2指向的數據空間是同一個，因此slice2[0]=100,slice[1]=100
fmt.Println("slice2=", slice2)
fmt.Println("slice=", slice)
fmt.Println("arr=", arr)
}
(6)、用 append 內置函數，可以對切片進行動態追加
package main
import "fmt"
func main() {
//用 append 內置函數，可以對切片進行動態追加
var slice []int = []int{100, 200, 300}
slice = append(slice, 400, 500, 600)
fmt.Println("slice ", slice)
slice = append(slice, slice...)
fmt.Println("slice= ", slice)
}
切片append操作的底層原理分析:
切片append操作的本質就是對數組擴容
go底層會創建一下新的數組newArr(安裝擴容后大小)將slice原來包含的元素拷貝到新的數組newArr
slice重新引用到newArr
注意newArr是在底層來維護的，程序員不可見
(7)、切片的拷貝操作
package main
import "fmt"
func main() {
var slice []int = []int{1, 2, 3, 4, 5}
var slice2 = make([]int, 10)
copy(slice2, slice)
fmt.Println("slice= ", slice)
fmt.Println("slice2= ", slice2)
var a []int = []int{1, 2, 3, 4, 5}
var sli = make([]int, 1)
fmt.Println(sli)
copy(sli, a)
fmt.Println(sli)
}
copy(para1, para2)參數的數據類型是切片
slice和slice2的數據空間是獨立，相互不影響
(8)、切片是引用類型，所以在傳遞時，遵守引用傳遞機制。
package main
import "fmt"
func test(slice []int) {
slice[0] = 1000
}
func main() {
var slice []int
var arr [5]int = [...]int{1, 2, 3, 4, 5}
slice = arr[:]
var slice2 = slice
slice2[0] = 10
fmt.Println("slice2 ", slice2)
fmt.Println("slice ", slice)
fmt.Println("arr", arr)
var sli = []int{1, 2, 3, 4}
fmt.Println("sli= ", sli)
test(sli)
fmt.Println("sli= ", sli)
}
4、string和slice
string底層是一個byte數組，因此string也可以進行切片處理
package main
import "fmt"
func main() {
str := "hello@ddd.com"
slice := str[6:]
fmt.Println("slice= ", slice)
}
string和切片在內存的形式，以"abcd"畫出內存示意圖
string是不可變的，也就說不能通過str[0]='z'方式來修改字符串。如果需要修改字符串，可以先將string -> []byte或者[]rune -> 修改 -> 重寫轉成string
package main
import "fmt"
func main() {
str := "hello@ddd.com"
arr := []byte(str)
arr[0] = 'z'
str = string(arr)
fmt.Println("str= ", str)
arr2 := []rune(str)
arr2[0] = '北'
str = string(arr2)
fmt.Println("str= ", str)
}
編寫一個函數fbn(n int) ,可以接收一個n int,能夠將斐波那契的數列放到切片中。
package main
import "fmt"
func fbn(n int) ([]uint64) {
fbnSlice := make([]uint64, n)
fbnSlice[0] = 1
fbnSlice[1] = 1
for i := 2; i < n; i++ {
fbnSlice[i] = fbnSlice[i-1] + fbnSlice[i-2]
}
return fbnSlice
}
func main() {
fbnSlice := fbn(20)
fmt.Println("fbnSlice= ", fbnSlice)
}