9.Golang中的数组与动态数组

概述

数组

完整代码如下：

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中的数组与动态数组 至此结束，如有疑问，欢迎评论区留言。