数组和切片

概念

数组是同一种数据类型元素的集合；数组的长度必须是常量，并且长度是数组类型的一部分，一旦定义，长度不能变

例如：[5]int 和 [10]int 是不同的数组类型

使用时可以修改数组成员，但是数组大小长度不可变化

数组的初始化

package main

import (
    "fmt"
)

func main() {
    var a1 [3]bool
    var a2 [4]bool
    var a122 [3]func()
    fmt.Printf("a1:%T a2:%T a122:%T\n", a1, a2, a122) //a1:[3]bool a2:[4]bool a122:[3]func()

    // 数组的初始化
    // 如果不初始化：默认元素都是零值（布尔值：false，整型和浮点型都是0，字符串为空:""，函数为nil）
        // a1:[false false false] a2:[false false false false] a122:[<nil> <nil> <nil>]
    fmt.Printf("a1:%v a2:%v a122:%v\n", a1, a2, a122) 

    // 初始化的方式
    // 1.初始化方式1
    a1 = [3]bool{true, true, true}
    fmt.Println(a1) //[true true true]

    // 2.初始化方式2：根据初始值自动推断数组的长度是多少
    a10 := [...]int{1, 2, 3, 4, 5, 6, 7, 8}
    fmt.Println(a10) //[1 2 3 4 5 6 7 8]

    // 3.初始化方式3：根据索引来初始化
    // a3 := [...]int{0:1, 4:2}  //索引为0的值为1，索引为4的值为2
    a3 := [5]int{0: 1, 4: 2} //索引为0的值为1，索引为4的值为2
    fmt.Println(a3)          //[1 0 0 0 2]
}

数组的遍历

package main

import (
    "fmt"
)

func main() {
        // 数组的遍历
    citys := [...]string{"北京", "上海", "深圳"}
    // 1.根据索引遍历
    // 用 len() 函数统计数组的长度然后在进行 for 循环是可以的。这里和string类型的遍历有差别
    for i := 0; i < len(citys); i++ {
        fmt.Println(citys[i])
    }
    // 2.for range遍历
    for _, v := range citys {
        fmt.Println(v)
    }
}

多维数组

package main

import (
    "fmt"
)

func main() {
        // 多维数组
        // 注意:多维数组只有第一层可以使用 [...]int{1, 2, 3} 来让编译器推导数组长度
    // [ [1 2] [3 4] [5 6] ]
    var a11 [3][2]int
    a11 = [3][2]int{
        [2]int{1, 2},
        [2]int{3, 4},
        [2]int{5, 6},
    }
    fmt.Println(a11) //[[1 2] [3 4] [5 6]]
    a12 := [3][2]int{
        [2]int{1, 2},
        [2]int{3, 4},
        [2]int{5, 6},
    }
    fmt.Println(a12) //[[1 2] [3 4] [5 6]]

    // 多维数组遍历
    // 1 2 3 4 5 6
    for _, v1 := range a11 {
        for _, v2 := range v1 {
            fmt.Println(v2)
        }
    }
}

数组是值类型

package main

import (
    "fmt"
)

func main() {
        // 数组是值类型
    // 赋值和传参会复制整个数组，因此改变副本的值，不会改变原来数组本身的值
    fmt.Println("------ 数组是值类型 ------")
    b1 := [3]int{1, 2, 3} //[1 2 3]
    b2 := b1              //[1 2 3] Ctrl+C Ctrl+V 相当于把world文档从文件夹A拷贝到文件夹B
    b2[0] = 100           //b2:[100 2 3]
    //b1[0] = 2 //数组可以修改值，但是长度不能变
    fmt.Println(b1, b2) //b1:[1 2 3]  b2:[100 2 3]

    // 数组支持 “==“、”!=” 操作符，因为内存总是被初始化过的
    arr1 := [...]int{1, 2, 3}
    arr2 := [...]int{1, 2, 3}
    fmt.Println(arr1 == arr2) //true
}

指针数组和数组的指针

package main

import (
    "fmt"
)

func main() {
        // 指针数组
    // [n]*T表示指针数组
    s1 := "abc"
    s2 := &s1
    s3 := &s1
    arr3 := [...]*string{s2, s3}
    fmt.Println(arr3) //[0xc00008e240 0xc00008e240]

    // 数组的指针
        // *[n]T表示数组的指针
    arr4 := [...]int{1, 2}
    op := &arr4
    fmt.Println(*op)          //[1 2]
    fmt.Printf("%T\n", *op)   //[2]int
    fmt.Printf("%p\n", op)    //0xc0000180e0  op的值是数组arr4这个变量的指针
    fmt.Printf("%p\n", &op)   //0xc00000e030  op自己在内存中的地址
    fmt.Printf("%p\n", &arr4) //0xc0000180e0  op的值是数组arr4这个变量的指针
}

数组练习

package main

import "fmt"

// array数组练习题
// 1.求数组[1, 3, 5, 7, 8]所有元素的和
// 2.找出数组中和为指定值的两个元素的下标，比如从数组[1, 3, 5, 7, 8]中找出和为8的两个元素的下标分别为(0,3)和(1,2)

func main() {
    // 1
    a1 := [...]int{1, 3, 5, 7, 8}
    sum1 := 0
    for _, v := range a1 {
        sum1 += v
    }
    fmt.Println("sum1:", sum1)

    // 2
    a2 := [...]int{1, 3, 5, 7, 8}
    for i := 0; i < len(a2); i++ {
        for j := i + 1; j < len(a2); j++ {
            if a2[i]+a2[j] == 8 {
                fmt.Printf("(%d,%d)\n", i, j)
            }
        }
    }
}

概念

切片是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。它非常灵活，支持自动扩容

切片是一个引用类型(数组是一个值类型)，它的内部结构包含地址、长度和容量。切片一般用于快速地操作一块数据集合

内置的len()函数求切片长度，内置的cap()函数求切片的容量

切片的底层就是一个数组，所以我们可以基于数组通过切片表达式得到切片

判断切片是否为空 请始终使用len(s) == 0来判断，而不应该使用s == nil来判断 初始化以后的切片 != nil

package main

import (
    "fmt"
)

func main() {
    // 切片的定义
    var s1 []int                  //定义一个存放int类型元素的切片
    var s2 []string               //定义一个存放string类型元素的切片
    fmt.Println(s1, s2)           //[] []
    fmt.Println(s1 == nil)        //true
    fmt.Println(s2 == nil)        //true
    fmt.Println(len(s1), len(s2)) // 0 0

        // 切片初始化
    s1 = []int{1, 2, 3}
    s2 = []string{"沙河", "张江", "平山村"}
    fmt.Println(s1, s2)           //[1 2 3] [沙河 张江 平山村]
    fmt.Println(s1 == nil)        //false
    fmt.Println(s2 == nil)        //false
    fmt.Println(len(s1), len(s2)) // 3 3

        // 长度和容量
    fmt.Printf("len(s1):%d cap(s1):%d\n", len(s1), cap(s1)) //len(s1):3 cap(s1):3
    fmt.Printf("len(s2):%d cap(s2):%d\n", len(s2), cap(s2)) //len(s2):3 cap(s2):3

        // 由数组得到切片
    a1 := [...]int{1, 3, 5, 7, 9, 11, 13} //数组
    s3 := a1[0:4]                         //基于一个数组切割，顾首不顾尾
    fmt.Println(s3)                       //[1 3 5 7]
    s4 := a1[1:6]
    fmt.Println(s4) //[3 5 7 9 11]
    s5 := a1[:4]
    s6 := a1[3:]
    s7 := a1[:]
    fmt.Println(s5) //[1 3 5 7]
    fmt.Println(s6) //[7 9 11 13]
    fmt.Println(s7) //[1 3 5 7 9 11 13]
        // 切片的容量：是指底层数组的容量
    fmt.Printf("len(s5):%d cap(s5):%d\n", len(s5), cap(s5)) // len(s5):4 cap(s5):7
    // 切片容量：底层数组从切片的第一个元素到最后的元素数量
    fmt.Printf("len(s6):%d cap(s6):%d\n", len(s6), cap(s6)) // len(s6):4 cap(s6):4
    // 切片再切割
    s8 := s6[3:]                                            //[13]
    fmt.Printf("len(s8):%d cap(s8):%d\n", len(s8), cap(s8)) //len(s8):1 cap(s8):1

        // 切片是引用类型，都指向了底层的一个数组
    // 修改底层数组的值，会影响切片
    fmt.Println("s6: ", s6) //[7 9 11 13]
    a1[6] = 1300            //修改底层数组的值
    fmt.Println("s6: ", s6) //[7 9 11 1300]
    fmt.Println("s8: ", s8) //[1300]
    fmt.Println("a1: ", a1) //[1 3 5 7 9 11 1300]

        // 修改切片，会修改底层数组吗?如果只是修改值的话不涉及到扩容，是会修改原底层数组的
    s8[0] = 10000
    fmt.Println(s8)           //[10000]
    fmt.Println(a1)           //[1 3 5 7 9 11 10000] a1数组发生改变
    s8 = append(s8, 20000)    //此处已经产生了新的数组，切片s8的容量是1，s8的切片不再指向原来的底层数组
    fmt.Printf("s8:%v\n", s8) //[10000 20000]
    fmt.Println(a1)           //[1 3 5 7 9 11 10000] a1数组不发生改变

        // append追加数组元素,如果底层数组容量不够的时候会扩容，产生新的数组
    a10 := [5]int{1, 2, 3}
    s10 := a10[:]
    fmt.Printf("len(s10):%d cap(s10):%d\n", len(s10), cap(s10)) //len(s10):5 cap(s10):5
    //s10 = append(s10, 4)
    //fmt.Println(cap(s10)) //10
    s10[3] = 1
    //fmt.Println(a10, s10) //[1 2 3 0 0] [1 2 3 1 0 4] 如果没注释s10的append，证明Go已经把底层的数组换了
    fmt.Println(a10, s10) //[1 2 3 1 0] [1 2 3 1 0] 如果注释了s10的append，则s10[3]=1修改的是底层元素
}

make函数初始化切片

package main

import (
    "fmt"
)

func main() {
        // make函数初始化切片
    var a = make([]string, 5, 10) // make(类型，长度，容量)
    fmt.Printf("cap:%d %#v\n", cap(a), a) //cap:10 []string{"", "", "", "", ""}

        // append()
        for i := 0; i < 10; i++ {
        a = append(a, fmt.Sprintf("%v", i)) // 拼接成字符串
    }
    fmt.Printf("%#v\n", a)
        //[]string{"", "", "", "", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}

    fmt.Println(len(a), cap(a)) //15 20

        // 初始化
    s1 := make([]int, 5, 10)                                          //make(类型，长度，容量)
    fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d\n", s1, len(s1), cap(s1)) //s1=[0 0 0 0 0] len(s1)=5 cap(s1)=10

    s2 := make([]int, 0, 10)
    fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d\n", s2, len(s2), cap(s2)) //s1=[] len(s1)=0 cap(s1)=10

        // 切片的赋值
    s3 := []int{1, 3, 5}
    s4 := s3            //s3和s4都指向了同一个底层数组
    fmt.Println(s3, s4) //[1 3 5] [1 3 5]
    s3[0] = 1000
    fmt.Println(s3, s4) //[1000 3 5] [1000 3 5]
}

切片的遍历

package main

import (
    "fmt"
)

func main() {
        // 切片的遍历
        s3 := []int{1, 3, 5}

    // 1.索引遍历
    for i := 0; i < len(s3); i++ {
        fmt.Println(s3[i])
    }

    // 2.for range循环
    for _, v := range s3 {
        fmt.Println(v)
    }
}

切片的append()

package main

import (
    "fmt"
)

// append()为切片追加元素
// 可能会导致数组扩容，从而让切片指向新的数组

func main() {
    s1 := []string{"北京", "上海", "深圳"}
    fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d\n", s1, len(s1), cap(s1)) //s1=[北京 上海 深圳] len(s1)=3 cap(s1)=3
    //s1[3] = "guangzhou" //panic: runtime error: index out of range [3] with length 3

    // 调用append函数必须用原来的切片变量接收返回值
    // append追加元素，原来的底层数组放不下的时候，Go就会把底层数组换一个
    // 必须用变量接收append的返回值
    s1 = append(s1, "广州")
    fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d\n", s1, len(s1), cap(s1))
        //s1=[北京 上海 深圳 广州] len(s1)=4 cap(s1)=6

    s1 = append(s1, "杭州", "成都")
    fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d\n", s1, len(s1), cap(s1))
        //s1=[北京 上海 深圳 广州 杭州 成都] len(s1)=6 cap(s1)=6

    ss := []string{"武汉", "西安", "苏州"}
    s1 = append(s1, ss...)
        //表示拆开(打散)，一个一个的元素添加到别的切片

        fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d\n", s1, len(s1), cap(s1))
        //s1=[北京 上海 深圳 广州 杭州 成都 武汉 西安 苏州] len(s1)=9 cap(s1)=12
}

切片的拷贝

package main

import (
    "fmt"
)

// 切片的copy

func main() {
    a1 := []int{1, 3, 5}
    aa := a1[:1]
    fmt.Println(cap(aa), len(aa), aa) // 容量是3 长度是1 [1]
    a2 := a1                          //赋值 a2 a1 指向的是同一个底层数组
    var a3 = make([]int, 3, 3)
    copy(a3, a1)            //copy 底层数组复制了一份，a3 和 a1 指向的不是同一个底层数组
    fmt.Println(a1, a2, a3) //[1 3 5] [1 3 5] [1 3 5]
    a1[0] = 100
    fmt.Println(a1, a2, a3) //[100 3 5] [100 3 5] [1 3 5]

    // 将a1中的索引为1的 3 这个元素删掉。 ... 由于切片没有直接删除元素的方法，所以可以采用这种方法
    a1 = append(a1[:1], a1[2:]...) // a1[:1] 容量是3，append 1 个元素的时候，底层数组没有发生变化
    fmt.Println(a1)                // [100 5]
    fmt.Println(cap(a1))           // 3
    fmt.Println(a2)                // [100 5 5]

    x1 := [...]int{1, 3, 5} //数组
    fmt.Println("===", x1)
    s1 := x1[:] //数组经过[L:M]以后，可以得到切片
    fmt.Println(s1, len(s1), cap(s1))
    // 1.切片不保存具体的值
    // 2.切片对应一个底层数组
    // 3.底层数组都是占用一块连续的内存
    fmt.Printf("%p\n", &s1[0])
    s1 = append(s1[:1], s1[2:]...)    //s1[:1] 容量是3，append 1 个元素的时候，底层数组没有发生变化
    fmt.Printf("%p\n", &s1[0])        //Go语言中不存在指针操作，只需要记住两个符号：&:取地址 *:根据地址取值
    fmt.Println(s1, len(s1), cap(s1)) //[1 5] 2 3
    fmt.Println(x1)                   //[1 5 5]
    s1[0] = 100
    fmt.Println(x1) //[100 5 5]
}

切片练习

package main

import (
    "fmt"
    "sort"
)

// 切片练习题

func main() {
    var a = make([]int, 5, 10) //初始化切片，长度5，容量10
    fmt.Println(a)             //[0 0 0 0 0]
    for i := 0; i < 10; i++ {
        a = append(a, i)
    }
    fmt.Println(a)      //[0 0 0 0 0 0 1 2 3 4 5 6 7 8 9]
    fmt.Println(cap(a)) //20

    var a1 = [...]int{3, 7, 8, 9, 1}
    sort.Ints(a1[:]) //对切片进行排序
    fmt.Println(a1)  //[1 3 7 8 9]

    // 要检查切片是否为空，请始终使用len(s) == 0来判断，而不应该使用s == nil来判断
    var aa []int           //只定义，没初始化
    fmt.Println(aa == nil) //true
    var bb []int           //定义
    bb = []int{}           //初始化后就不为nil了，但是还是空的切片
    fmt.Println(bb == nil) //false
    fmt.Println(aa, bb)    //[] []
    if len(bb) == 0 {
        fmt.Println("空数组")
    }
}



package main

import "fmt"

//切片练习

func main() {
    //ex1
    //s1 := make([]int, 4, 100)
    //s1[0] = 1
    //s1[1] = 2
    //fmt.Println(s1) //[1 2 0 0]
    //s2 := s1[:]     //再切片，切片的切片，底层数组还是同一个
    ////s2 := s1 //赋值 底层数组是同一个
    //s2[0] = 100
    //fmt.Println(s1)               //[100 2 0 0]
    //fmt.Println(s2)               //[100 2 0 0]
    //fmt.Println(cap(s1), cap(s2)) //100 100

    //ex2
    //s1 := make([]int, 4, 4)
    //s1[0] = 1
    //s1[1] = 2
    //fmt.Println(s1) //[1 2 0 0]
    //s2 := s1[:]     //切片的再切片 len:4 cap:4
    //
    ////append()扩容以后会形成新的数组
    //s2 = append(s2, 100) //形成新的底层数组 [1 2 0 0 100] len:4 cap:8
    //
    //fmt.Println(s1)               //[1 2 0 0]
    //fmt.Println(s2)               //[1 2 0 0 100]
    //fmt.Println(cap(s1), cap(s2)) //4 8

    //ex3
    //s1 := make([]int, 4, 4)
    //s1[0] = 1
    //s1[1] = 2
    //fmt.Println(s1)                         //[1 2 0 0]
    //s2 := s1[:2]                            //[1 2] len:2 cap:4
    //fmt.Println("==", s2, len(s2), cap(s2)) //[1 2] 2 4
    //s2 = append(s2, 100)                    //append()这里没有扩容，因为长度是2，容量是4，所以不会形成新的底层数组,此时底层数组是:[1 2 100]
    //fmt.Println(s1)                         //[1 2 100 0]
    //fmt.Println(s2)                         //[1 2 100] 这里s2的长度是3，不是4哦，所以是 [1 2 100]
    //fmt.Println(cap(s1), cap(s2))           //4 4
    //fmt.Println(len(s1), len(s2))           //4 3

    //ex4
    //var s1 = [...]int{1, 2, 3, 4, 5}
    //s2 := s1[2:] //[3 4 5] len:3 cap:3
    //
    //s2 = append(s2, 100) //扩容了，产生新的底层数组 [3 4 5 100] len:4 cap:6
    //
    //fmt.Println(s1)               //[1 2 3 4 5]
    //fmt.Println(s2)               //[3 4 5 100]
    //fmt.Println(cap(s1), cap(s2)) //5 6
    //fmt.Println(len(s1), len(s2)) //5 4

    //ex5
    //var arr = [...]int{1, 2, 3, 4, 5}
    //slice := arr[:2]                  //[1 2] len:2 cap:5
    //slice = append(slice, 6, 7)       //没扩容 切片是:[1 2 6 7] len:4 cap:5
    //slice[0] = 100                    //[100 2 6 7]
    //fmt.Println(arr)                  //[100 2 6 7 5]
    //fmt.Println(slice)                //[100 2 6 7]
    //fmt.Println(cap(arr), cap(slice)) //5 5
    //fmt.Println(len(arr), len(slice)) //5 4

    //ex6
    var arr = [...]int{1, 2, 3, 4, 5}
    slice := arr[:2] // [1 2] len:2 cap:5

    slice = append(slice, 6, 7, 8, 9, 10) //底层数组扩容了，切片是[1 2 6 7 8 9 10]
    slice[0] = 100                        //[100 2 6 7 8 9 10]

    fmt.Println(arr)                  //[1 2 3 4 5]
    fmt.Println(slice)                //[100 2 6 7 8 9 10]
    fmt.Println(cap(arr), cap(slice)) //5 10
    fmt.Println(len(arr), len(slice)) //5 7
}