Golang语言系列-05-数组和切片

数组和切片

数组

概念

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

例如：[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
}