这么简单的问题都不会，那还面试什么！？

最近群里的讨论太猛了，硝烟味很重，有的群友直接开怼：这么简单的问题都不会，那你还面试什么呀？我一看这不就是很简单的数组和切片的区别嘛。

本文来自专栏：Go入门进阶实战专栏：其实学Go很简单。，欢迎订阅。

在 Go 语言的丰富数据类型中，数组和切片是处理有序数据集合的强大工具。它们允许开发者以连续的内存块来存储和管理相同类型的多个元素。无论是在处理大量数据时的性能优化，还是在实现算法时对数据结构的需求，数组和切片都扮演着至关重要的角色。

Go 语言中的数组

数组是存放元素的容器，Go 语言中数组的长度是数组类型的一部分，定义数组时必须指定存放元素的类型和容量（长度）

定义

var a1 [3]bool
var a2 [4]int

fmt.Printf("a1:%T\na2:%T\n", a1, a2)

打印结果：

数组初始化

默认值

定义数组时不进行初始化，默认元素都是零值：bool 类型的 false、整型和浮点类型的 0、字符串的空串" "

var a1 [3]bool 
var a2 [4]int

// 如果不初始化：默认元素都是零值（布尔值：false 整型和浮点类型：0 字符串：""）
fmt.Println(a1, a2)

打印结果：

初始化方式 1

最简单的初始化方式，在大括号中定义好和长度一致的值。

var a1 [3]bool 
a1 = [3]bool{true,false,false}
fmt.Println(a1)

打印结果：

初始化方式 2：根据初始值自动判断数组的长度

在中括号中写明长度，当定义的数值个数比长度小时，会用默认值补齐，比如：0、false、""

a8 := [10]int{0, 1, 2, 3, 4, 5, 6, 7}  //7后面会用0补齐
fmt.Println(a8)

打印结果： [0 1 2 3 4 5 6 7 0 0]

[...]的用法

[...]设置数组长度时，会根据初始值自动判断数组的长度

aa := [...]int{0, 1, 2, 3, 4, 5, 6, 7} //[...]根据初始值自动判断数组的长度
fmt.Println(aa)

打印结果：[0 1 2 3 4 5 6 7]

初始化方式 3：根据索引初始化

指定索引对应的值，未指定索引的值会用默认值填充，比如：0、false、""

a3 := [5]int{0: 1, 4: 2} //根据索引初始化
fmt.Println(a3)

打印结果：[1 0 0 0 2]

取值

遍历数组

for i 循环遍历数组

citys := [...]string{"北京", "上海", "深圳"} //索引从0到2
// 根据索引遍历
for i := 0; i < len(citys); i++ {
   fmt.Println(citys[i])
}

打印结果：

for range 遍历

for range 遍历更简单

citys := [...]string{"北京", "上海", "深圳"} //索引从0到2
for i, city := range citys {
   fmt.Printf("key值：%d 城市为：%v\n", i, city)
}

打印结果：

多维数组

定义

我们以二维数组举例，比如我们需要定义[[1 2 3][4 5 6]]这样的二维数组，需要怎么定义呢？

示例如下：

1. 下面代码中的第一个长度单位[2]表示二维数组的有几个元素
2. 第二个长度单位[3]表示子集数组中有几个元素
3. 初始化的时候：变量 = 数组类型{}

//定义多维数组
var a11 [2][3]int

//初始化多维数组
a11 = [2][3]int{
   [3]int{1, 2, 3},
   [3]int{4, 5, 6}, //注意：最后这个也要加逗号分隔
}

fmt.Println(a11)

打印结果：

取值

多维数组的遍历

//定义多维数组
var a11 [2][3]int

//初始化多维数组
a11 = [2][3]int{
   [3]int{1, 2, 3},
   [3]int{4, 5, 6}, //注意：最后这个也要加逗号分隔
}

//双重for range遍历取值
for _, v1 := range a11 {
   fmt.Println(v1)
   for _, v2 := range v1 {
      fmt.Println(v2)
   }
}

打印结果：

数组特点：值类型 不是引用类型

我们发现把 b1 赋值给 b2，再修改 b2 的值，b1 的值并没有改变。我认为这是数组和切片最大的区别，建议大家再对比学习一下切片的知识点。

b1 := [3]int{1, 2, 3}
b2 := b1
b2[0] = 100
fmt.Println(b1,b2)

打印结果：

总结：说明 Go 的数组是值类型，不是引用类型：b2:=b1 的操作，给 b2 开辟了新的内存空间，而不是引用 b1 的内存地址。

数组实战

求数组 cArray[1，3，5，7，8]所有元素之和

cArray := [...]int{1, 3, 5, 7, 8}
r := 0
for _, i2 := range cArray {
   r += i2
}
fmt.Printf("相加结果为：%v", r)

打印结果：相加结果为：24

求出 cArray 数组中，和为 8 的下标，比如[0 3]和[1 2]

for i := 0; i < len(cArray); i++ {
   for j := 0; j < i; j++ {
      if cArray[i]+cArray[j] == 8 {
         fmt.Printf("符合的下标为：%v,%v \n", j, i)
      }
   }
}

打印结果：

Go 语言中的切片

切片区别于数组，是引用类型， 不是值类型。数组是固定长度的，而切片长度是可变的，我的理解是：切片是对数组一个片段的引用。

定义

var s1 []int    //定义一个存放int类型元素的切片
var s2 []string //定义一个存放string类型元素的切片
fmt.Println(s1, s2)
fmt.Println(s1 == nil) //true  为空  没有开辟内存空间
fmt.Println(s2 == nil) //true

打印结果：

解析: 说明我们已经声明成功了，但是并没有开辟内存空间，因为s1、s2的值为nil

声明并初始化

我们可以在声明的同时初始化

var s1 = []int{1, 2, 3}
var s2 = []string{"北苑", "长阳", "望京"}
fmt.Println(s1, s2)
fmt.Println(s1 == nil) //false
fmt.Println(s2 == nil) //false

打印结果：

解析： 初始化成功，s1 s2的值都不等于nil

长度和容量

分别使用len()、cap()获得切片的长度和容量

fmt.Printf("len(s1):%d cap(s1):%d\n", len(s1), cap(s1))
fmt.Printf("len(s2):%d cap(s2):%d\n", len(s2), cap(s2))

打印结果：

解析： 和我们预期的一致，长度和容量都为3

由数组得到切片

开篇我已经提到数组和切片的关系，这里再进一步讲一下：

1. 切片的本质是操作数组，只是数组是固定长度的，而切片的长度可变的
2. 切片是引用类型，可以理解为引用数组的一个片段；而数组是值类型，把数组A赋值给数组B，会为数组B开辟新的内存空间，修改数组B的值并不会影响数组A。
3. 而切片作为引用类型，指向同一个内存地址，是会互相影响的。

//定义一个数组
a1 := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
s3 := a1[0:4] //基于一个数组切割  [0:4]左包含 右不包含  即为[1,2,3,4]
fmt.Println(s3)

打印结果：

注意：a1[0:4] 基于一个数组切割 [0:4]左包含 右不包含 即为[1,2,3,4]

更多切割方式举例

a1 := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
s4 := a1[2:4] //[3 4]
s5 := a1[:4] //[1 2 3 4]
s6 := a1[2:] //[3 4 5 6 7 8 9]
s7 := a1[:]  //[1 2 3 4 5 6 7 8 9]
fmt.Println(s4)
fmt.Println(s5)
fmt.Println(s6)
fmt.Println(s7)

打印结果：

解析： 都符合上面提到的左包含，右不包含原则 s4从下标2开始截取，截取到下标4 s5省略了第一个参数，表示从下标0开始截取 s6省略了第二个参数，表示截取到最后一个元素 s7省略了两个参数，只填写了中间的冒号:，表示取全部元素

切片的长度和容量

切片的长度很好理解，就是元素的个数。

切片的容量我们重点理解一下：在切片引用的底层数组中从切片的第一个元素到数组最后一个元素的长度就是切片的容量

我来画个图：

再举个栗子

我们看下面这个栗子就很好理解啦：

a1 := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}

s5 := a1[:4] //[1 2 3 4]
s6 := a1[2:] //[3 4 5 6 7 8 9]
s7 := a1[:]  //[1 2 3 4 5 6 7 8 9]

fmt.Printf("len(s5):%d cap(s5):%d\n", len(s5), cap(s5)) //4 9
fmt.Printf("len(s6):%d cap(s6):%d\n", len(s6), cap(s6)) //7 7
fmt.Printf("len(s7):%d cap(s7):%d\n", len(s7), cap(s7)) //9 9

打印结果：

解析： a1是数组长度为9，容量也为9，值是从1~9

s5/s6/s7都是切割数组a1得到的切片。

s5的长度为4，因为只有1 2 3 4这4个元素，容量为9，因为s5切片是从数组起始位置开始切割的：第一个元素是1，而s5底层数组a1最后一个元素是9，1~9共9个元素，所以s5的容量为9。

s6的长度为7，因为s6的元素是39这7个元素；容量也为7，因为s5的底层数组最后一个元素是9，39共7个元素，所以s6的容量为7。

S7更好理解了，长度和容量都是9，小伙伴们自己理解一下。

切片再切片

我们可以对切片进行再切片操作

比如，我们针对上面的数据再次切片进行测试

s8 :=s6[3:]
//s8的值为：6 7 8 9
fmt.Printf("len(s8):%d cap(s8):%d\n", len(s8), cap(s8)) //4 4

打印结果：

解析：我们知道可以对切片进行再次切片就可以，至于长度和容器大家搞明白上面的栗子，这个输出结果就是意料之中的了。

slice是引用类型

我们举个栗子来证明切片是引用类型

//定义数组
a1 := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
//由数组切割成切片s6
s6 := a1[2:] //[3 4 5 6 7 8 9]
//切片再次切片，赋值给s8
s8 :=s6[3:] //[6 7 8 9]
//修改原始数组，把下标为2的值由3改为333
a1[2] = 333
//打印s6，发现s6中的3也变成了333
fmt.Println("s6:", s6) //[333 4 5 6 7 8 9]
//因为s8基于s6切片而成，我们测试一下切片再切片的引用传的
fmt.Println("s8:", s8) //[6 7 8 9]
//我们把原始数组下标为5的值由6改为666
a1[5] = 666
//打印s8切片，得到结果6也变成了666
fmt.Println("s8:", s8) //[666 7 8 9]

打印结果：

解析： 由此我们可以明确的知道切片是引用类型，当底层数组改变时，不管是切片，还是切片再切片，值都会改变。因为他们使用的是一个内存块，引用的一个内存地址。

早日上岸！

我们搞了一个免费的面试真题共享群，互通有无，一起刷题进步。

没准能让你能刷到自己意向公司的最新面试题呢。

感兴趣的朋友们可以加我微信：wangzhongyang1993，备注：面试群。