Golang-slice

切片的本质、定义 、常用函数
本质：引用类型，相当于在内存中划分出一块连续空间，其底层是一个的数组，与数组不同之处在于切片可扩容，而数组的长度是固定。
定义：var s []int
常用函数：len、cap、make、append、...、copy

切片的特点
1.数组切片，特点：切割法遵循左闭右开的原则
2.1 len与cap的使用区别。
2.2 在用cap计算第n个切片的容量时，无论切割多少次，其起点均为第n个切片的第一个元素，而终点为最初开辟的内存里的最后一个元素，而不是基于第n-1块切片的空间。
3.nil值的切片没有底层数组，相当于指针没有指向任何一块内存空间，而值为0的切片，其值不一定等于nil。

切片的基本操作
1.初始化：make函数 或 切割数组
2.判空：e.g. len(s1)==0
3.增：append ... 若切片未初始化，append函数会自动初始化
4.删：append ... Go语言里没有删除元素的函数操作，但可通过切割隔离第n个元素类似删除的操作
5.改：遍历赋值 或 根据索引赋值
6.查：遍历
7.复制：copy copy不像append会自动扩容，所以copy目标必须初始化好长度和容量
8.排序：sort

package main

import (

"fmt"
"sort"

)

func main() {

//切片的定义
var s []int
fmt.Println(s)

//通过切割数组得到的切片
s1 := [...]int{100, 200, 300, 5, 3, 9, 6, 7, 9} //s1为底层数组
s2 := s1[:4]                                    
s3 := s1[4:]
fmt.Println("s2:", s2)
fmt.Println("s3:", s3)

//通过切割切片得到的切片
//*len求当前切片的长度，而cap求基于底层数组或切片，从切割起始点开始的长度
fmt.Println(len(s2), cap(s2))
s5 := s2[3:] //[100,200,300]
fmt.Println("s5:", s5)
fmt.Printf("cap(s5):%d", cap(s5))
fmt.Println()

//make函数创建切片
k := make([]int, 5, 10)
fmt.Println(k, len(k), cap(k))

//nil值
var a []int          //只定义，但未初始化
a1 := []int{}        //已初始化
a2 := make([]int, 0) //已初始化
if a == nil {
    fmt.Println("yes")
} else {
    fmt.Println("no")
}
if a1 == nil {
    fmt.Println("yes")
} else {
    fmt.Println("no")
}
if a2 == nil {
    fmt.Println("yes")
} else {
    fmt.Println("no")
}
//判断切片是否为空，用len()==0

//切片赋值，切片是引用类型，所有切片上的元素都是指向同一内存地址，无论是改变底层数组或切片，存储于此内存空间的值也会发生改变
b := []int{1, 2, 3, 4, 5}
b1 := b[2:]
fmt.Println(b[3])
fmt.Println(b1)
fmt.Println(b1[1])
b1[1] = 8
fmt.Println(b[3])

//切片的遍历（for索引；for range）

//切片的增(添加到原切片尾)
//1.增加单一元素
Q1 := []string{"天", "下", "一"}
Q1 = append(Q1, "家")
fmt.Println(Q1)
//2.增加一个切片
Q2 := []string{"one family"}
Q1 = append(Q1, Q2...)
fmt.Println(Q1)

//切片的删
//要点:假如要删除n个元素，切割后，其后的内存空间上的元素要集体向前复制n个位置，而这一整片的内存空间长度是没有发生变化的。
var Q3 = []int{12, 14, 5, 6, 7, 89, 47, 0, 9}
Q5 := append(Q3[0:0], Q3[1:]...)
//Q4 := append(Q3[0:1], Q3[3:]...)
//fmt.Println("Q4:", Q4)
fmt.Println("Q3:", Q3)
fmt.Println("Q5:", Q5)

//切片的复制
Q7 := []int{1, 2, 3}
Q7a := Q7                //Q7a所指向的内存地址与Q7是相同的
Q7b := make([]int, 3, 3) //而Q7b则是在内存中开辟了新内存空间，使用copy函数时，要预设目标的长度和容量
copy(Q7b, Q7)
fmt.Println(Q7, Q7a, Q7b)
Q7[0] = 100
fmt.Println(Q7, Q7a, Q7b)

//切片的排序
var Q8 = []int{5, 42, 41, 66, 45, 99, 10001, 9999}
sort.Ints(Q8[:])
fmt.Println(Q8)

}