Go学习之 切片

切片 （ slice ）

数组的长度是固定的，并且长度属于数组类型的一部分，这样子，数组就会有很大的局限性
切片就可以完美的解决这个问题
切片是一个拥有相同类型元素的可变性的序列，基于数组的上面的一层封装，引用类型，切片一般用于快速的操作一些数据集合。

切片的定义

	// 定义切片
	var s1 []int
	var s2 []string

• 数组里面不加数字就是切片哦。

切片的长度和容量

	s1 = []int{1, 2, 3}
	s2 = []string{"北京", "上海", "深圳"}
	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))

• 长度可以通过len函数得到
• 容量通过 cap 函数得到

由数组得到区间

	// 由数组得到切片
	a := [...]int{1, 3, 5, 7, 9, 11, 13}
	s3 := a[0:4]
	fmt.Println(s3)

• 切片的容量是指切片元素的第一个元素到底层数组的最后一个元素

例如：

	// 由数组得到切片
	a := [...]int{1, 3, 5, 7, 9, 11, 13}
	s3 := a[0:4]
	fmt.Printf("len(s3) %d, cap(s3) %d \n", len(s3), cap(s3))
	// 答案就是  len(s3) 4, cap(s3) 7 

• 切片属于引用类型，都指向了数组的地址

make函数创建切片

• 这样创建的切片可以自定义长度和容量

	// 使用make构造切片 make([]T,size , cap)  已经看到27 切片的本质
	s1 := make([]int, 5, 10)
	fmt.Printf("len %d, cap %d \n", len(s1), cap(s1))

使用append方法进行添加元素

	s1 := []string{"上海", "深圳", "北京"}
	
	// 调用append方法后，必须使用原来切片变量来接受
	s1 = append(s1, "湖南"，“黄州”)

切片的扩容机制

• 先判断，如果申请的容量大于旧容量的两倍，那么最终容量就是新申请的容量
• 否则再判断，旧切片的长度是否大于1024 小于的话，则最终容量是旧容量的两倍。
• 旧切片长度大于或者等于1024，则每次都增加原来容量的1/4 ， 知道最终容量比新申请的容量大
• 如果在增加的途中，发生了容量溢出，那么最终容量就是新申请的容量。

	s1 := []string{"上海", "深圳", "北京"}

	// 调用append方法后，必须使用原来切片变量来接受
	s1 = append(s1, "湖南")
	fmt.Println(s1)
	ss := []string{"武汉", "西安", "苏州"}
	s1 = append(s1, ss...)
	fmt.Println(s1)
	
	//[上海 深圳 北京 湖南]
	//[上海 深圳 北京 湖南 武汉 西安 苏州]

• ss… 表示将这个切片拆开，一个一个的装进去。

切片的删除

• 切片中没有特定的删除语句，但是可以利用切片本身的特性去进行删除。

	a1 := []int{1, 3, 5}
	a2 := a1
	var a3 = make([]int, 3, 3)
	copy(a3, a1) // copy
	fmt.Println(a1, a2, a3)

	a1 = append(a1[:1], a1[2:]...)   // 利用切片的特性进行删除数据
	fmt.Println(a1)

• 切片是对底层数组的引用，当对切片记性修改的时候，底层数组也会发生相对应的修改。

func main() {
	a1 := [4]int{1, 2, 3, 4}
	s := make([]int, 0, 4)
	s = append(a1[:1], a1[2:]...)
	s[1] = 100
	fmt.Println(a1, s)
	
	//[1 100 4 4] [1 100 4]
}

切片的排序

	var a = []int{1, 5, 3, 2, 4}
	sort.Ints(a[:])
	fmt.Println(a)

• 直接使用sort包下面的ints方法即可。