- Go语言的容器分为值类型和引用数据类型
一、数组
1.数组的声明和初始化
(1) 数组声明的语法
-
var 数组变量名 [数组大小]数组类型
-
举例：
package main import "fmt" func main(){ //数组的声明 var arr[10]int //打印数组长度 fmt.Println("arr的长度为", len(arr)) //数组的赋值 for i, _ := range arr{ arr[i] = i+1 } fmt.Println("打印数组") //打印数组 for j, w := range arr{ fmt.Println(j, arr[j], w) } }结果：
-
在数组的定义中，若在数组长度的位置出现了"…"省略号，即var 数组变量名[…]数组类型，则表示数组的长度是根据初始化值的个数来决定的。
package main import ( "fmt" ) func main(){ arr1 := [...]int{} arr2 := [...]int{1,2,3,4,5,6,7,8,9} fmt.Println("打印arr1：") for i, _ := range arr1{ fmt.Println(arr1[i]) } fmt.Println("打印arr2：") for i, _ := range arr2{ fmt.Println(arr2[i]) } fmt.Printf("arr1的类型为%T：\n",arr1) fmt.Printf("arr2的类型为%T：\n",arr2) }结果：
(2) 比较两个数组是否相等
package main
import "fmt"
func main(){
arr1 := [5]int{1,2,3,4,5}
arr2 := [...]int{1,2,3,4,5}
arr3 := [5]int{0,1,2,3,4}
fmt.Printf("arr1==arr2?的结果%v\n",arr1 == arr2)
fmt.Printf("arr1==arr3?的结果%v\n",arr1 == arr3)
}
结果：
2.多维数组
- 多维数组的语法：var 数组变量名[size1][size2]…[sizen]数组类型
(1) 声明二维数组
package main
import "fmt"
func main(){
var arr1[4][3]int//声明一个多维数组，大小为4，3
arr2 := [4][3]int{{0,1,2},{1,2,3},{2,3,4},{3,4,5}}//声明数组并初始化所有元素
arr3 := [4][3]int{1:{0,1,2},2:{1,2,3}}//声明并初始化数组中指定索引的元素
arr4 := [4][3]int{1:{0:20},2:{2:30}}//声明并初始化数组中指定元素
for i,v := range arr1{
fmt.Printf("arr1的结果：")
fmt.Println(v)
fmt.Printf("arr2的结果：")
fmt.Println(arr2[i])
fmt.Printf("arr3的结果：")
fmt.Println(arr3[i])
fmt.Printf("arr4的结果：")
fmt.Println(arr4[i])
}
}
结果：
(2) 数组赋值
package main
import "fmt"
func main(){
var arr1[2][2]int
var arr2[2][2]int
for i,_ := range arr2{
for j, _ := range arr2[i]{
arr2[i][j] = i + 1
}
}
arr1 = arr2
arr2[0][1] = 10
arr2[1][1] = 20
for i,v := range arr1{
fmt.Printf("arr1的值为：")
fmt.Println(v)
fmt.Printf("arr2的值为：")
fmt.Println(arr2[i])
}
}
结果：
二、切片
1.切片概述
- slice切片就是数组中一段连续的片段的引用。故切片是个引用类型
- 从数组或者切片生成新的切片：slice[开始位置 : 结束位置]
- 从数组或者切片中生成新的切片拥有如下特征：
（1）取出的元素数量为：结束位置 - 开始位置
（2）取出的元素不包含结束位置对应的索引（左闭右开）。切片最后一个元素是slice[len(slice)]
（3）当缺省开始位置时，表示从连续区域开头位置到切片结束位置
（4）当缺省结束位置时，表示从切片开始位置到连续区域末尾位置
（5）当开始位置和结束位置都缺省时，表示从连续区域开头位置到连续区域末尾位置，即整个连续区域。即表示原有的切片
（6）当开始位置和结束位置两者都为0时，即空切片。一般用于切片复位 - 切片举例：
结果：通过结果可以看见，是左闭右开的。package main import "fmt" func main(){ arr := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} fmt.Println("数组arr的值为",arr) fmt.Println("切片arr[0:1]的值为", arr[0:1]) fmt.Println("切片arr[2:8]的值为", arr[2:8]) fmt.Println("切片arr[4:9]的值为", arr[4:9]) fmt.Println("切片arr[5:10]的值为", arr[5:10]) fmt.Println("切片arr[5:10]中元素个数为", len(arr[5:10])) fmt.Println("切片最后一个元素arr[len(arr)]的值为",arr[len(arr[4:9])]) fmt.Println("切片arr[2:]的值为",arr[2:]) fmt.Println("切片arr[:8]的值为",arr[:8]) fmt.Println("切片arr[:]的值为",arr[:]) }
- 声明新切片的语法：var 切片名[]切片类型
结果：package main import "fmt" func main() { var strSlice []string //声明字符串切片 var intSlice []int //声明整型切片 var emptySlice []int { } //声明一个空切片 fmt.Println(strSlice, intSlice, emptySlice) fmt.Println("len(strSlice)=", len(strSlice)) fmt.Println("len(intSlice)=", len(intSlice)) fmt.Println("len(emptySlice)=", len(emptySlice)) fmt.Println("strSlice == nil ? =", strSlice == nil) fmt.Println("intSlice == nil ? =", intSlice == nil) fmt.Println("emptySlice == nil ? =", emptySlice == nil) }
2.make动态构造切片
- 若需要动态创建一个切片，则可以使用make()内建函数：make([]切片类型,切片大小,切片容量)
- 注意：使用make()函数生成的切片一定发生了内存分配操作，但给定开始与结束位置（包括切片复位）的切片结果指向已经分配好的区域。设定开始与结束位置不会发生内存分配操作。
结果：package main import "fmt" func main() { slice1 := make([]int, 2, 20)//slice1切片的大小为2，容量为20 slice2 := make([]int, 2)//slice2切片的大小为2 //slice1和slice2都是预分配了2个元素的切片，只是slice1内部存储空间已经分配了20个，但实际只用了2个 fmt.Println("slice1:",slice1) fmt.Println("slice2:",slice2) fmt.Println("len(slice1):",len(slice1)) fmt.Println("len(slice2):",len(slice2)) }
3.在切片中添加元素
- 切片的len元素个数并不等于切片的cap容量大小，cap容量扩容是2倍进行扩容的
结果：package main import "fmt" func main() { var slice1 []int for i:=0; i<20; i++{ slice1 = append(slice1, i) fmt.Printf("len:%d, cap:%d, pointer:%p\n", len(slice1), cap(slice1), slice1) } }
4.切片复制copy
- copy(目标切片, 原切片)
结果：package main import "fmt" func main() { arr := [10]int{0,1,2,3,4,5,6,7,8,9} slice1 := arr[2:9] slice2 := []int{10,11,12,13} fmt.Println("复制前：") fmt.Println("slice1=",slice1) fmt.Println("slice2=",slice2) cp1 := copy(slice1,slice2)//将slice2的所有元素复制到slice1 cp2 := copy(slice2,slice1)//将slice1中前几个元素复制到slice2中 fmt.Println("复制后：") fmt.Println("slice1=",slice1) fmt.Println("slice2=",slice2) fmt.Println("cp1复制的总数为:", cp1) fmt.Println("cp2复制的总数为:", cp2) }
5.range关键字循环切片
package main
import "fmt"
func main() {
arr := [10]int{0,1,2,3,4,5,6,7,8,9}
slice1 := arr[2:9]
for i,v:=range slice1{
fmt.Printf("index:%d, value:%d\n", i, v)
}
}
结果：
6.多维切片
- 声明方法：var 切片名 [][]…[]切片类型
package main
import "fmt"
func main() {
var slice1 [][]int
slice1 = [][]int{{0,1},{10,11},{20}}
fmt.Println("添加元素前：")
for i,v:=range slice1{
fmt.Printf("index:%d, value:%d\n", i, v)
}
slice1[2] = append(slice1[2], 100)//为第三个切片添加值为100的元素
fmt.Println("添加元素后：")
for i,v:=range slice1{
fmt.Printf("index:%d, value:%d\n", i, v)
}
}
结果：
三、数组和切片的区别
- 数组是数值类型，切片是引用类型
- 数组的长度是固定的，切片的长度不固定，切片是动态的数组
- 数组只有长度的概念，切片还有容量（cap）的概念
- 切片的底层是数组
- 数组之间可以通过"=="比较，判断两个数组是否有相同元素，但是切片不行，只能和nil进行相等判断
- 一个零值的切片等于nil，一个nil值的切片并没有底层数组
- 数组传递给函数的时候，是需要先拷贝再传递；而切片是引用传递，函数内可以直接修改切片的内容
![[Java·算法·中等]LeetCode39. 组合总和](https://img-blog.csdnimg.cn/e3c77e460b434bf4a3c58fbc64c18495.png)
