Golang 切片

前言

在Go语言中，切片是一个引用类型，它提供了对数组的动态窗口。切片并不存储任何数据，它只是描述了底层数组中的一个片段。切片的定义包括三个部分：指向数组的指针、切片的长度和切片的容量

基本使用

1. 声明切片：声明一个未初始化的切片，其值为nil

var s []int

2. 创建并初始化切片

• 可以通过make函数创建切片，并指定切片的长度和容量

s := make([]int, 5) // 长度和容量都是5

• 切片也可以通过字面量进行初始化：

s := []int{
   1, 2, 3, 4, 5}

3. 切片现有数组：可以从一个数组或另一个切片创建新的切片

arr := [5]int{
   1, 2, 3, 4, 5}
s := arr[1:3] // 创建一个新切片，包含arr[1]到arr[2]

4. 切片的长度和容量

• 长度：切片中元素的数量，使用len(s)获取。
• 容量：从切片的开始位置到底层数组结束位置的元素数量，使用cap(s)获取

fmt.Println(len(s)) // 输出切片的长度
fmt.Println(cap(s)) // 输出切片的容量

5. 切片扩展和收缩：可以重新切片来扩展或收缩一个切片，但不能超过其容量

s = s[:4] // 扩展切片的长度到4，如果容量允许的话

6. 添加元素到切片：使用append函数可以向切片添加新元素，如果超过原切片的容量，将自动分配新的底层数组

s = append(s, 6) // 添加元素6到切片

7. 遍历切片：可以使用for循环来遍历切片

for i, value := range s {
   
    fmt.Println(i, value) // 输出索引和对应的值
}

排序

对切片排序通常使用标准库中的sort包，sort包提供了针对切片的排序函数，可以对不同类型的切片进行排序，包括整数、浮点数、字符串切片等。此外，也可以自定义排序规则
举几个例子

1. 整数切片

import "sort"

func main() {
   
    s := []int{
   3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}
    sort.Ints(s)
    fmt.Println(s) // 输出: [1 1 2 3 3 4 5 5 5 6 9]
}

2. 字符串切片

import "sort"

func main() {
   
    s := []string{
   "apple", "pear", "banana", "peach"}
    sort.Strings(s)
    fmt.Println(s) // 输出: [apple banana peach pear]
}

3. 浮点数切片

import "sort"

func main() {
   
    s := []float64{
   3.14, 1.59, 2.65, 3.58}
    sort.Float64s(s)
    fmt.Println(s) // 输出: [1.59 2.65 3.14 3.58]
}

4. 自定义排序规则

import "sort"

type Person struct {
   
    Name string
    Age  int
}

func main() {
   
    people := []Person{
   
        {
   "Bob", 31},
        {
   "John", 42},
        {
   "Michael", 17},
        {
   "Jenny", 26},
    }

    // 按年龄排序
    sort.Slice(people, func(i, j int) bool {
   
        return people[i].Age < people[j].Age
    })
    
    fmt.Println(people) // 输出: [{Michael 17} {Jenny 26} {Bob 31} {John 42}]
}

降序
可以使用自定义排序，也可以用sort.Reverse配合sort.Sort来达成降序目的

• sort.Reverse 函数接受一个 sort.Interface 类型的参数，并返回一个新的 sort.Interface
• sort.Sort 对这个逆序接口进行排序
  例1：int类型切片逆序

import (
    "fmt"
    "sort"
)

func main() {
   
    list := []int{
   3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}
    // sort.Reverse 返回的是 sort.Interface 类型
    // sort.IntSlice(list) 转换切片为 sort.IntSlice 类型，这样就可以使用 sort.Reverse
    sort.Sort(sort.Reverse(sort.IntSlice(list)))
    fmt.Println(list) // 输出: [9 6 5 5 5 4 3 3 2 1 1]
}

例2：float64类型切片逆序

import (
    "fmt"
    "sort"
)

func main() {
   
    list := []float64{
   3.14, 1.59, 2.65, 3.58}
    sort.Sort(sort.Reverse(sort.Float64Slice(list)))
    fmt.Println(list) // 输出: [3.58 3.14 2.65 1.59]
}

例3：string类型切片逆序

import (
    "fmt"
    "sort"
)

func main() {
   
    list := []string{
   "apple", "pear", "banana", "peach"}
    sort.Sort(sort.Reverse(sort.StringSlice(list)))
    fmt.Println(list) // 输出: [pear peach banana apple]
}

例4：自定义结构体类型Person切片逆序

import (
    "fmt"
    "sort"
)

type Person struct {
   
    Name string
    Age  int
}

// ByAge 实现 sort.Interface 来按年龄排序
type ByAge []Person

func (a ByAge) Len() int           {
    return len(a) }
func (a ByAge) Swap(i, j int)      {
    a[i], a[j] = a[j], a[i] }
func (a ByAge) Less(i, j int) bool {
    return a[i].Age > a[j].Age } // 降序

func main() {
   
    people := []Person{
   
        {
   "Bob", 31},
        {
   "John", 42},
        {
   "Michael", 17},
        {
   "Jenny", 26},
    }
    
    sort.Sort(ByAge(people))
    fmt.Println(people) // 输出: [{John 42} {Bob 31} {Jenny 26} {Michael 17}]
}

熟悉后，其他用法可自行探索