数组
数组是同一种数据类型元素得集合。在Go语言中， 数组从声明时就确定，使用时可以修改数组成员，但是数组大小不可变化。
数组声明
func main() {
var age [3]int // 声明并初始化为默认零值
var age1 = [4]int{1,2,3,4} // 声明同时初始化
var age2 = [...]int{1,2,3,4,5} // ...可以表示后面初始化值得长度
fmt.Println(age)
fmt.Println(age1)
fmt.Println(age2)
}
运行结果：
[0 0 0]
[1 2 3 4]
[1 2 3 4 5]
数组遍历
方法一
func main() {
var age2 = [...]int{1,2,3,4,5}
for i :=0; i<len(age2);i++ {
fmt.Println(age2[i])
}
}
运行结果：
1
2
3
4
5
方法二
func main() {
var age2 = [...]int{1,2,3,4,5}
for index, e := range age2{
fmt.Println(index,e)
}
}
运行结果：
0 1
1 2
2 3
3 4
4 5
可以通过range关键字实现，index表示索引，e表示当前索引值
数组截取
func main() {
var age2 = [...]int{1,2,3,4,5}
fmt.Println(age2[1:3]) // 读取索引1到3得值
fmt.Println(age2[3:]) // 读取索引3到最后得值
fmt.Println(age2[:3]) // 读取索引3以前得值
fmt.Println(age2[:len(age2)]) // 读取所有值
}
运行结果：
[2 3]
[4 5]
[1 2 3]
[1 2 3 4 5]
切片
切片（Slice）是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。它非常灵活，支持自动扩容。
切片是一个引用类型，它的内部结构包含地址、长度和容量。切片一般用于快速地操作一块数据集合。
func main() {
var s []int // 声明切片
fmt.Println(len(s), cap(s))
s = append(s, 1) // 初始化
fmt.Println(len(s), cap(s))
s1 := []int{1,2,3,4} // 声明并初始化
fmt.Println(len(s1),cap(s1))
s3 := make([]int,3,5) // 使用make()函数构造切片
fmt.Println(len(s3),cap(s3))
}
运行结果：
0 0
1 1
4 4
3 5
可变长得切片
func main() {
s := []int{} // 声明切片
for i := 0; i<10; i++ {
s = append(s,i)
fmt.Println(len(s),cap(s))
}
}
运行结果：
1 1
2 2
3 4
4 4
5 8
6 8
7 8
8 8
9 16
10 16
切片的本质
切片的本质就是对底层数据的封装， 它包含了三个信息：底层数组的指针、切片的长度（len）和切片的容量（cap）。
package main
import "fmt"
func main() {
var s = []int{1,2,3,4,5,6,6,8}
fmt.Println(len(s),cap(s))
s1 := s[3:5]
fmt.Println(s1, len(s1),cap(s1))
s2 := s[:5]
fmt.Println(s2, len(s2),cap(s2))
}
运行结果：
8 8
[4 5] 2 5
[1 2 3 4 5] 5 8
通过试图表达更清晰哟
s1 := s[3:5] 示意图
s2 := s[:5] 示意图
数组与切片的区别
- 数组是具有固定长度且拥有零个或者多个相同数据类型元素的序列。 数组的长度是数组类型的一部分， 所以[3]int 和 [4]int 是两种不同的数组类型。数组需要指定大小，不指定也会根据初始化的自动推算出大小，不可改变 ; 数组是值传递;
- 切片 切片表示一个拥有相同类型元素的可变长度的序列。 切片是一种轻量级的数据结构， 它有三个属性：指针、长度和容量。 切片不需要指定大小; 切片是地址传递;
评论区