9.Golang中的数组与动态数组
目录
- 概述
- 数组
-
- 固定长度
-
- 声明方式
- 数组传参
- 动态数组
-
- 声明方式
- slice传参
- 切片容量及追加
- 截取
- 结束
概述
数组
完整代码如下：
package main
import "fmt"
// 固定长度的数组在传参的时候，是严格匹配数组类型的
// 且是值拷贝
func printArray(myArray [4]int) {
for index, v := range myArray {
fmt.Println("index =", index, ",value = ", v)
}
myArray[0] = 111
}
func main() {
// 固定长度的数组
var myArray1 [10]int
for i := 0; i < len(myArray1); i++ {
fmt.Println(myArray1[i])
}
myArray2 := [10]int{1, 2, 3, 4}
myArray3 := [4]int{11, 22, 33, 44}
fmt.Printf("myArray2 types =%T\n", myArray2)
fmt.Printf("myArray3 types =%T\n", myArray3)
for _, v := range myArray2 {
fmt.Println(v)
}
printArray([4]int(myArray3))
for _, v := range myArray3 {
fmt.Println(v)
}
}
固定长度
数组的长度是固定的。
声明方式
// 固定长度的数组
var myArray1 [10]int
myArray2 := [10]int{1, 2, 3, 4}
myArray3 := [4]int{11, 22, 33, 44}
数组传参
固定长度的数组在传参的时候，是严格匹配数组类型的。
// 固定长度的数组在传参的时候，是严格匹配数组类型的
// 且是值拷贝
func printArray(myArray [4]int) {
for index, v := range myArray {
fmt.Println("index =", index, ",value = ", v)
}
myArray[0] = 111
}
执行结果：
动态数组
声明方式
// 声明slice1是一个切片，并且初始化，默认值1,2,3.长度len是3
slice1 :=[]int{1,2,3}
// 声明slice2是一个切片，但是没有给slice分配空间
var slice2 []int
// 开辟3个空间，默认值是0
slice2 = make([]int, 3)
// 声明 slice3 是一个切片，同时给 slice3分配空间，3个空间，初始化值是0
var slice3 []int=make([]int, 3)
slice传参
动态数组在传参上是引用传递，而且不同元素长度的动态数组都不影响。
package main
import "fmt"
func printSlice(slice []int) {
for _, v := range slice {
fmt.Println(v)
}
slice[0] = 111
}
func main() {
// 声明slice1是一个切片，并且初始化，默认值1,2,3.长度len是3
slice1 := []int{1, 2, 3}
// 声明slice2是一个切片，但是没有给slice分配空间
var slice2 []int
// 开辟3个空间，默认值是0
slice2 = make([]int, 3)
// 声明 slice3 是一个切片，同时给 slice3分配空间，3个空间，初始化值是0
var slice3 []int = make([]int, 3)
// slice4 := make([]int, 3)
var slice5 []int
fmt.Println(slice1)
fmt.Println(slice2)
for _, v := range slice3 {
fmt.Println(v)
}
printSlice(slice3)
fmt.Println("----")
for _, v := range slice3 {
fmt.Println(v)
}
// %v 打印所有的相关信息
fmt.Printf("len = %d, slice = %v\n", len(slice3), slice3)
if slice5 == nil {
fmt.Println("空切片")
} else {
fmt.Println("有空间切片")
}
}
结果如下：
切片容量及追加
package main
import (
"fmt"
)
func main() {
var numbers = make([]int, 3, 5)
fmt.Printf("len = %d , cap = %d , slice = %v \n", len(numbers), cap(numbers), numbers)
// 向 numbers 添加一个元素
numbers = append(numbers, 4)
fmt.Printf("len = %d , cap = %d , slice = %v \n", len(numbers), cap(numbers), numbers)
numbers = append(numbers, 5)
numbers = append(numbers, 6)
fmt.Printf("len = %d , cap = %d , slice = %v \n", len(numbers), cap(numbers), numbers)
}
结果如下：
截取
package main
import (
"fmt"
)
func main() {
fmt.Println("--- 下面截取 ---")
// 截取
s := []int{1, 2, 3}
//[0,2) 左闭右开
s1 := s[0:2]
// s1 := s[:2] 左边不写从0开始，右边不写，至最后一个元素
fmt.Printf("s1 = %v\n", s1)
// s1与s指向同一个切片
// copy 可以将底层数组的slice一起拷贝
s3 := make([]int, 3)
copy(s3, s)
fmt.Printf("s3 = %v\n", s3)
}
结果如下：
结束
Golang中的数组与动态数组 至此结束，如有疑问，欢迎评论区留言。