社区首页 >专栏 >Go语言中数组与切片

Go语言中数组与切片

原创

似水流年o

发布于 2022-01-10 08:55:38

70200

代码可运行

文章被收录于专栏：编程学习收获编程学习收获

运行总次数：0

代码可运行

数组：

1.数组定义：

	//定义arr,不赋值默认为0
	var arr [3]int
	fmt.Printf("%v-%v-%v\n", arr[0], arr[1], arr[2]) //0-0-0
	//显示的指定大小个数并且用1，2，3赋值
	arr1 := [3]int{1, 2, 3}
	fmt.Printf("%v-%v-%v\n", arr1[0], arr1[1], arr1[2]) //1-2-3
	//隐式的不指定大小个数，用赋值1，2，3 (注意有三个.)
	arr2 := [...]int{1, 2, 3}
	fmt.Printf("%v-%v-%v\n", arr2[0], arr2[1], arr2[2]) //1-2-3

2.数组遍历：

	//定义arr
	arr := [3]int{11, 12, 13}
	fmt.Printf("%v-%v-%v\n", arr[0], arr[1], arr[2]) //11-12-13
	//数组遍历1
	for i := 0; i < len(arr); i++ {
		/**
		i=0,v=11
		i=1,v=12
		i=2,v=13
		*/
		fmt.Printf("i=%v,v=%v\n", i, arr[i])
	}
	//数组遍历2
	for i, v := range arr {
		/**
		i=0,v=11
		i=1,v=12
		i=2,v=13
		*/
		fmt.Printf("i=%v,v=%v\n", i, v)
	}

3.数组注意点：

在Go语言中，数组变量代表的是整个数组，而C/C++中数组变量代表的是指向数组的头指针。所以在Go语言中，当数组变量B被赋值数组变量A时，实际上是数组变量B完全复制了一份数组A数据，而不是数组变量A和数组变量B指向同一份数据。

举例：

func main() {
	//定义数组A
	A := [3]int{1, 2, 3}
	//打印数组A
	fmt.Printf("%v\n", A) //[1 2 3]
	//数组变量B被赋值数组变量A
	var B = A
	//打印数组B
	fmt.Printf("%v\n", B) //[1 2 3]
	//数组B index=0替换
	B[0] = 4

	//打印数组A
	fmt.Printf("%v\n", A) //[1 2 3]
	//打印数组B
	fmt.Printf("%v\n", B) //[4 2 3]
}

所以如果原数组数据量大，那么数组的赋值会造成巨大的内存开销。

切片

1.切片的由来：

切片类似于JAVA中的List列表，是一种长度可变的数组, 可以动态增长和收缩，解决原生数组大小不可变的弊端。

2.切片的定义：

	//定义数组A
	arr := [3]int{1, 2, 3}
	//打印数组A
	fmt.Printf("%v\n", arr) //[1 2 3]
	//1.基于数组创建切片,长度是2,容量是2
	slice1 := arr[1:3]
	printSlice(slice1)

	//2.直接声明一个切片,长度是0,容量是0
	var slice2 []int
	printSlice(slice2)

	//3.声明一个切片指定初始值,长度是4,容量是4
	var slice3 = []int{1, 2, 3, 4}
	printSlice(slice3)
	
	//4.make定义切片,长度是4(值为0),容量是10
	var slice4 []int = make([]int, 4, 8)
	printSlice(slice4)

}

func printSlice(x []int) {
	fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}

切片拥有自己的长度和容量，我们可以通过使用内置的 len()函数求长度，使用内置的cap()函数求容量。

3.切片的遍历：

	//定义切片
	var slice = []int{1, 2, 3, 4}

	//遍历1
	/**
	i=0,v=1
	i=1,v=2
	i=2,v=3
	i=3,v=4
	*/
	for i := 0; i < len(slice); i++ {
		fmt.Printf("i=%v,v=%v\n", i, slice[i])
	}

	//遍历2
	/**
	i=0,v=1
	i=1,v=2
	i=2,v=3
	i=3,v=4
	*/
	for i, v := range slice {
		fmt.Printf("i=%v,v=%v\n", i, v)
	}

4.切片的常用方法

append()方法：

func main() {
	//定义切片
	var slice = []int{1, 2, 3, 4}
	printSlice(slice) //len=4 cap=4 slice=[1 2 3 4]
	//注意:append方法需要变量进行返回接收，而不是在原有的slice上直接添加
	slice = append(slice, 10)
	printSlice(slice) //len=5 cap=8 slice=[1 2 3 4 10]
}
func printSlice(x []int) {
	fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}

copy()方法

func main() {
	//定义切片b
	var b = []int{1, 2, 3, 4}
	printSlice(b) //len=4 cap=4 slice=[1 2 3 4]
	a := b
	printSlice(a) //len=4 cap=4 slice=[1 2 3 4]
	//修改index=0的数值
	a[0] = 100
	printSlice(a) //len=4 cap=4 slice=[100 2 3 4]
	printSlice(b) //len=4 cap=4 slice=[100 2 3 4]
}

func printSlice(x []int) {
	fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}

通过上面例子我们可以看到，切片与数组的变量赋值是不一样的。数组变量赋值是进行数据拷贝，而切片变量赋值是进行指针指向。通过copy()方法可以进行数据拷贝：

func main() {
	//定义切片b
	var b = []int{1, 2, 3}
	var a = []int{10, 11, 12, 13}
	copy(a, b)    //目标切片，源切片，对应位置拷贝
	printSlice(a) //len=3 cap=3 slice=[1 2 3]
	printSlice(b) //len=4 cap=4 slice=[1 2 3 4]
}

func printSlice(x []int) {
	fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}

删除方法

func main() {
	//定义切片b
	var a = []int{1, 2, 3, 4}
	// 要删除索引为2的元素
	// 切片a中删除索引为index的元素，通用方法是a = append(a[:index], a[index+1:]...)，左闭右开
	a = append(a[:2], a[3:]...)
	printSlice(a) //len=3 cap=4 slice=[1 2 4]
}

func printSlice(x []int) {
	fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}