Go基础学习-数组与切片

数组

固定长度同一种数据类型元素的集合

//数组声明：
var a [2]int//var 数组名[长度]存放的类型

//数组初始化：
//1,使用初始化列表来设置数组元素的值
var a [3]int                        //数组会初始化为int类型的零值
var b = [3]int{1, 2}                 //使用指定的初始值完成初始化
//2,使用指定索引值的方式来初始化数组
c := [2]int{1: 1, 3: 5}
//3,根据设置的数组元素来自行确定数组长度
var d= [...]int{1, 2}

//数组的遍历
name := [...]string{"Tom", "Dog", "Cat"}
//方式1
for i := 0; i < len(name); i++ {
	fmt.Println(name[i])
}
//方式2
for i, v := range name {
	fmt.Println(i, v)
}
//多维数组
//[[1 2] [3 4] [5 6]]
var a21 [3][2]int
a21 = [3][2]int{
	[2]int{1, 2},
	[2]int{3, 4},
	[2]int{5, 6},
}
fmt.Println(a21)
//多维数组的遍历
for _, v1 := range a21 {
	fmt.Println(v1)
	for _, v2 := range v1 {
		fmt.Println(v2)
	}
}
//数组是值类型（相当于复制黏贴）
a221 := [3]int{1, 2, 3} //[1 2 3]
a222 := a221            //[1 2 3] 相当于复制黏贴
a222[0] = 100
fmt.Println(a221, a222)

• 数组的长度必须是常量，且必须定义；一旦定义，长度不能变
• 长度不同，但是存放数据类型相同；就不是同一类型；例如[5]int和[6]int
• 数组是值类型，赋值和传参会复制整个数组。因此改变副本的值，不会改变本身的值
• 数组支持 “==“、”!=” 操作符，因为内存总是被初始化过的。
• [n]*T表示指针数组，*[n]T表示数组指针
• len()求切边长度；cap()求容量;长度等于容量；cap()可以使用的类型有array、slice、channel;不可以对map使用

切片（slice）

可变长度同一种数据类型元素的集合

//slice声明：make([]T, size, cap)
a := make([]int, 2, 2)

//slice初始化：
var a= []int{} 
var b = []int{1, 2}
//append可以对slice起到初始化的作用;例如：
var s []int
s =append(s,1)
fmt.Println(s)//output:[1]

//切片的底层就是一个数组，可以基于数组通过切片表达式得到切片
a := [5]int{1, 2, 3, 4, 5}
s := a[1:3]  // s := a[low:high] //左闭右开
fmt.Printf("s:%v len(s):%v cap(s):%v\n", s, len(s), cap(s))
//output:s:[2 3] len(s):2 cap(s):4 //长度即hight-low

//支持
s := a[1:]
s := a[:3]
s := a[:]

//append()为切片追加元素   可以自动初始化切片
app := []int{1, 2, 3}
fmt.Printf("(追加前)app=%v;len=%d;cap=%d\n", app, len(app), cap(app))
app = append(app, 6) //调用append函数必须用原来的切片变量接受返回值
//append函数追加元素，原来的底层数组放不下的时候，Go底层就会把底层数组换一个
fmt.Printf("(追加后1.0)app=%v;len=%d;cap=%d\n", app, len(app), cap(app))
app = append(app, 6, 8)
fmt.Printf("(追加后1.1)app=%v;len=%d;cap=%d\n", app, len(app), cap(app))
app2 := []int{66, 77, 88}
app = append(app, app2...) //...表示拆开切片
fmt.Printf("(追加后1.2)app=%v;len=%d;cap=%d\n", app, len(app), cap(app))

//copy()复制切片
//切片是引用类型，但是copy()函数是将切片值赋值到另外一个内存中，所以不受底层数组的改变而改变
cop := []int{1, 2, 3}
cop2 := cop //赋值
cop3 := make([]int, 3, 3)
copy(cop3, cop)
fmt.Println(cop, cop2, cop3)
cop[0] = 100
fmt.Println(cop, cop2, cop3)

//删除切片元素
//删除del切边中的3元素
del := []int{1, 2, 3, 4, 5, 6}
del  = append(del[:2], del1[3:]...) //修改了底层数组
fmt.Println(del)                     //[1,2,4,5,6,6]

• 切片是一个引用类型，所以不支持直接比较，只能和nil比较;一个nil值的切片并没有底层数组，一个nil值的切片的长度和容量都是0；但是不能说一个长度和容量都是0的切片一定是nil；例如：s3 := make([]int, 0) //len(s3)=0;cap(s3)=0;s3!=nil
• 因为切片是引用类型，所以需要通过make()函数来声明申请内存；或者直接声明并初始化申请内存
• len()求切边长度；cap()求容量;cap()可以使用的类型有array、slice、channel;不可以对map使用
• 切片的本质：是对底层数组的封装，它包含了三个信息：底层数组的指针、切片的长度（len）和切片的容量（cap）相当于是一个框，框住了一块连续的内存（数据类型必须一致）；属于引用类型。真正的数据都是保存在底层数组里的
• 切片是否为空，使用len(s) == 0来判断，而不应该使用s == nil来判断。