数组和切片
【1】、数组
1、什么是数组
一组数
- 数组需要是相同类型的数据的集合
- 数组是需要定义大小的
- 数组一旦定义了大小是不可以改变的。
package main
import "fmt"
// 数组
// 数组和其他变量定义没什么区别，唯一的就是这个是一组数，需要给一个大小 [6]int [10]string
// 数组是一个相同类型数据的==有序==集合，通过下标来取出对应的数据
// 数组几个特点：
// 1、长度必须是确定的，如果不确定，就不是数组，大小不可以改变
// 2、元素必须是相，同类型不能多个类型混合, [any也是类型，可以存放任意类型的数据]
// 3、数组的中的元素类型，可以是我们学的所有的类型，int、string、float、bool、array、slice、map
func main() {
// 派生数据类型
// 数组的定义：【数组大小size】变量的类型 我们定义了一组这个类型的数的集合，大小为size
// 默认值是00000
var arr1 [5]int
arr1[0] = 1
arr1[1] = 2
arr1[2] = 3
arr1[3] = 4
arr1[4] = 5
fmt.Println(arr1)
for i := 0; i < len(arr1); i++ {
fmt.Printf("%d\n", arr1[i])
}
// 数组中的常用方法 len()获取数组的长度 cap() 获取数组的容量
fmt.Println("数组的长度：", len(arr1)) // 数组的长度： 5
fmt.Println("数组的容量：", cap(arr1)) // 数组的容量： 5
// 修改数组的值
arr1[1] = 100
fmt.Println(arr1)
}
2、初始化数组
package main
import "fmt"
func main() {
// 数组的赋值初始化
var arr1 = [5]int{0, 1, 2, 3, 4}
fmt.Println(arr1)
// 快速赋值
arr2 := [5]int{0, 1, 2, 3, 4}
fmt.Println(arr2)
// 接受用户输入的数据，变为数组
// ... 代表数组长度
// Go的编译器会自动根据数组的长度来给 ... 赋值，自动推导长度
// 注意点：这里的数组不是无限长的，也是固定的大小，大小取决于数组元素个数
arr3 := [...]int{0, 1, 2, 3, 4, 5, 5, 5, 6, 7, 8, 9}
fmt.Println(len(arr3), arr3)
// 数组默认值,只给其中某几个元素赋值
var arr4 [10]int
fmt.Println(arr4)
arr4[6] = 600
arr4[5] = 500
fmt.Println(arr4)
}
3、遍历数组元素
package main
import "fmt"
/*
1、直接通过下标获取元素 arr[index]
2、 0-len i++ 可以使用for循环来结合数组下标进行遍历
3、for range：范围 (new)
*/
func main() {
arr3 := [...]int{0, 1, 2, 3, 4, 5, 5}
for i := 0; i < len(arr3); i++ {
fmt.Println(arr3[i])
}
// goland 快捷方式 数组.for，未来循环数组、切片很多时候都使用for range
// for 下标,下标对应的值 range 目标数组切片
// 就是将数组进行自动迭代。返回两个值 index、value
// 注意点，如果只接收一个值，这个时候返回的是数组的下标
// 注意点，如果只接收两个值，这个时候返回的是数组的下标和下标对应的值
for _, value := range arr3 {
fmt.Println("value:", value)
}
}
4、数组是值类型
package main
import "fmt"
// 数组是值类型： 所有的赋值后的对象修改值后不影响原来的对象。
func main() {
arr3 := [...]int{0, 1, 2, 3, 4, 5, 5}
arr4 := [...]string{"111", "222"}
fmt.Printf("%T\n", arr3)
fmt.Printf("%T\n", arr4)
arr5 := arr3
arr3[6] = 7
fmt.Printf("%T\n", arr3)
fmt.Println(arr5) // 数组是值传递，拷贝一个新的内存空间
}
5、数组排序
arr := [6]int{1,2,3,4,5,0}
// 升序 ASC ： 从小到大 0,1,2,3,4,5 A-Z 00:00-24:00
// 降序 DESC ： 从大到小 5,4,3,2,1,0
// 冒泡排序
package main
import "fmt"
func main() {
arr1 := [...]int{1, 2, 3, 4, 5, 0, 77, 95, 11, 23, 54, 88, 33, 10, 23, 19}
//var temp int = 0
for i := 0; i < len(arr1); i++ {
for j := i + 1; j < len(arr1); j++ {
if arr1[i] > arr1[j] {
arr1[i], arr1[j] = arr1[j], arr1[i]
}
}
}
fmt.Println(arr1)
}
6、多维数组
一维数组： 线性的，一组数
二维数组： 表格性的，数组套数组
三维数组： 立体空间性的，数组套数组套数组
xxxx维数组：xxx，数组套数组套数组.....
package main
import "fmt"
func main() {
// 定义一个多维数组 二维
arr := [3][4]int{
{0, 1, 2, 3}, // arr[0] //数组
{4, 5, 6, 7}, // arr[1]
{8, 9, 10, 11}, // arr[2]
}
// 二维数组，一维数组存放的是一个数组
fmt.Println(arr[0])
// 要获取这个二维数组中的某个值，找到对应一维数组的坐标，arr[0] 当做一个整体
fmt.Println(arr[0][1])
fmt.Println("------------------")
// 如何遍历二维数组
for i := 0; i < len(arr); i++ {
for j := 0; j < len(arr[i]); j++ {
fmt.Println(arr[i][j])
}
}
// for range
for i, v := range arr {
fmt.Println(i, v)
}
}
【2】、切片
Go 语言切片是对数组的抽象。
Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go 中提供了一种灵活，功能强悍的内置类型 切片("动态数组")，与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。
切片是一种方便、灵活且强大的包装器，切片本身没有任何数据，他们只是对现有数组的引用。
切片与数组相比，不需要设定长度，在[]中不用设定值，相对来说比较自由
从概念上面来说 slice 像一个结构体，这个结构体包含了三个元素：
- 指针：指向数组中 slice 指定的开始位置
- 长度：即slice的长度
- 最大长度：也就是 slice 开始位置到数组的最后位置的长度
1、切片的定义
package main
import "fmt"
func main() {
var s1 []int // 变长，长度是可变的
fmt.Println(s1)
// 切片空的判断，初始化切片中，默认是nil
if s1 == nil {
fmt.Println("s1是空的")
}
fmt.Printf("%T\n", s1)
s2 := []int{1, 2, 3, 4}
fmt.Println(s2[2])
}
2、make来创建切片
package main
import "fmt"
func main() {
// make()
// make([]Type,length,capacity) // 创建一个切片，长度，容量
s1 := make([]int, 5, 10)
fmt.Println(s1)
fmt.Println(len(s1), cap(s1))
// 思考：容量为10，长度为5，我能存放6个数据吗？
s1[0] = 10
s1[7] = 200 // index out of range [7] with length 5
// 切片的底层还是数组 [0 0 0 0 0] [2000]
// 直接去赋值是不行的，不用用惯性思维思考
fmt.Println(s1)
// 切片扩容
}
3、切片扩容
package main
import "fmt"
func main() {
s1 := make([]int, 0, 5)
// 切片扩容，append()
s1 = append(s1, 1, 2)
fmt.Println(s1)
s2 := []int{100, 200, 300, 400}
// 切片扩容之引入另一个切片。
// slice = append(slice, anotherSlice...)
// ... 可变参数 ...xxx
// [...] 根据长度变化数组的大小定义
// anotherSlice... , slice...解构，可以直接获取到slice中的所有元素
s1 = append(s1, s2...)
fmt.Println(s1)
}
4、遍历切片
package main
import "fmt"
func main() {
s1 := make([]int, 0, 5)
fmt.Println(s1)
// 切片扩容，append()
s1 = append(s1, 1, 2)
fmt.Println(s1)
// 问题：容量只有5个，那能放超过5个的吗？ 可以，切片是会自动扩容的。
s1 = append(s1, 2, 3, 3, 4, 4, 5, 6, 6, 7, 7)
fmt.Println(s1)
// 切片扩容之引入另一个切片。
// new ： 解构 slice.. ，解出这个切片中的所有元素。
s2 := []int{100, 200, 300, 400}
// slice = append(slice, anotherSlice...)
// ... 可变参数 ...xxx
// [...] 根据长度变化数组的大小定义
// anotherSlice... , slice...解构，可以直接获取到slice中的所有元素
// s2... = {100,200,300,400}
s1 = append(s1, s2...)
// 遍历切片
for i := 0; i < len(s1); i++ {
fmt.Println(s1[i])
}
for i := range s1 {
fmt.Println(s1[i])
}
}
5、扩容的内存分析
// 1、每个切片引用了一个底层的数组
// 2、切片本身不存储任何数据，都是底层的数组来存储的，所以修改了切片也就是修改了这个数组中的数据
// 3、向切片中添加数据的时候，如果没有超过容量，直接添加，如果超过了这个容量，就会自动扩容，成倍的增加， copy
// - 分析程序的原理
// - 看源码
//
// 4、切片一旦扩容，就是重新指向一个新的底层数组。
package main
import "fmt"
func main() {
s2 := []int{1, 2, 3}
fmt.Println(len(s2), cap(s2))
fmt.Printf("%p\n", s2)
s2 = append(s2, 4, 5)
fmt.Println(len(s2), cap(s2))
fmt.Printf("%p\n", s2)
s2 = append(s2, 4, 5)
fmt.Println(len(s2), cap(s2))
fmt.Printf("%p\n", s2)
s2 = append(s2, 4, 5)
fmt.Println(len(s2), cap(s2))
fmt.Printf("%p\n", s2)
s2 = append(s2, 4, 5)
fmt.Println(len(s2), cap(s2))
fmt.Printf("%p\n", s2)
s2 = append(s2, 4, 5)
fmt.Println(len(s2), cap(s2))
fmt.Printf("%p\n", s2)
s2 = append(s2, 4, 5)
fmt.Println(len(s2), cap(s2))
fmt.Printf("%p\n", s2)
/* 3 3
0xc000126078
5 6
0xc000144030
7 12
0xc000102060
9 12
0xc000102060
11 12
0xc000102060
13 24
0xc000152000
15 24
0xc000152000
*/
}
package main
import "fmt"
func main() {
s2 := []int{1, 2, 3}
fmt.Printf("len:%d,cap:%d,%v\n", len(s2), cap(s2), s2)
s3 := make([]int, len(s2), cap(s2)*2)
copy(s3, s2)
fmt.Printf("len:%d,cap:%d,%v\n", len(s3), cap(s3), s3)
}
6、使用数组创建切片
package main
import "fmt"
func main() {
arr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
// 数组的截取
// 通过数组创建切片
s1 := arr[:5] // 1-5
s2 := arr[3:8] // 4-8
s3 := arr[5:] // 6-10
s4 := arr[:] // 0-10
fmt.Println(s1)
fmt.Println(s2)
fmt.Println(s3)
fmt.Println(s4)
// 查看容量和长度
// 截取后切片的长度就是截取数组的元素个数，切片的容量就是从截取数组的开始位置到数组的最后位置
fmt.Printf("s1 len:%d, cap:%d\n", len(s1), cap(s1)) // s1 len:5, cap:10
fmt.Printf("s2 len:%d, cap:%d\n", len(s2), cap(s2)) // s2 len:5, cap:7
fmt.Printf("s3 len:%d, cap:%d\n", len(s3), cap(s3)) // s3 len:5, cap:5
fmt.Printf("s4 len:%d, cap:%d\n", len(s4), cap(s4)) // s4 len:10, cap:10
// 切片的内存地址，就是截取数组开始的地址 cap(切片)=len(数组) 他们的内存地址就相同
fmt.Printf("%p,%p\n", s1, &arr) // 0xc000016230,0xc000016230
fmt.Printf("%p,%p\n", s2, &arr[3]) // 0xc000016248,0xc000016248
fmt.Printf("%p,%p\n", s2, &arr[3]) // 0xc000016248,0xc000016248
fmt.Printf("%p,%p\n", s3, &arr[5]) // 0xc000016258,0xc000016258
fmt.Printf("%p,%p\n", s4, &arr[0]) // 0xc000016230,0xc000016230
// 修改数组的内容, 切片也随之发生了变化 （切：切片不保存数据-->底层的数组 ）
arr[2] = 100
fmt.Println(arr) // [1 2 100 4 5 6 7 8 9 10]
fmt.Println(s1) // [1 2 100 4 5]
fmt.Println(s2) // [4 5 6 7 8]
fmt.Println(s3) // [6 7 8 9 10]
fmt.Println(s4) // [1 2 100 4 5 6 7 8 9 10]
fmt.Println("--------------------------------------------")
// 修改切片的内容，发现数组也随之发生了变化。（本质：修改的都是底层的数组）
s2[2] = 80
fmt.Println(arr) // [1 2 100 4 5 80 7 8 9 10]
fmt.Println(s1) // [1 2 100 4 5]
fmt.Println(s2) // [4 5 80 7 8]
fmt.Println(s3) // [80 7 8 9 10]
fmt.Println(s4) // [1 2 100 4 5 80 7 8 9 10]
fmt.Println("--------------------------------------------")
// 切片扩容,如果容量超过了cap，那么不会影响原数组，因此此时s1指向的是一个新的数组
s1 = append(s1, 11, 12, 13, 14, 15, 16)
fmt.Println(arr) // [1 2 100 4 5 80 7 8 9 10]
fmt.Printf("s1:%p,arr:%p\n", s1, &arr) // s1:0xc0000d4000,arr:0xc0000ac0f0
}
7、切片：引用类型
package main
import "fmt"
func main() {
arr1 := [3]int{1, 2, 3}
arr2 := arr1
fmt.Println("arr1:", arr1, "arr2:", arr2)
fmt.Printf("arr1:%p,arr2:%p\n", &arr1, &arr2) // arr1:0xc0000aa078,arr2:0xc0000aa090
arr1[1] = 10
fmt.Println("arr1:", arr1, "arr2:", arr2) // [3 4 5] [3 4 5]
fmt.Println("---------------------------------")
s1 := make([]int, 0, 5)
s1 = append(s1, 3, 4, 5)
s2 := s1
fmt.Println(s1, s2)
fmt.Printf("s1:%p,s2:%p\n", s1, s2) //s1:0xc0000c8030,s2:0xc0000c8030
s1[1] = 30
fmt.Println(s1, s2) // [3 30 5] [3 30 5]
}
8、深拷贝、浅拷贝
深拷贝：拷贝是数据的本身
- 值类型的数据，默认都是深拷贝，array、int、float、string、bool、struct....
浅拷贝：拷贝是数据的地址，会导致多个变量指向同一块内存。
- 引用类型的数据： slice、map
- 因为切片是引用类的数据，直接拷贝的是这个地址
package main
import "fmt"
func main() {
// 将原来切片中的数据拷贝到新切片中
s1 := []int{1, 2, 3, 4}
s2 := make([]int, 0) // len:0 cap:0
for i := 0; i < len(s1); i++ {
s2 = append(s2, s1[i])
}
fmt.Println(s1, s2)
fmt.Printf("%p,%p\n", s1, s2)
s1[2] = 200
fmt.Println(s1, s2)
}
9、函数中参数传递问题
按照数据的存储特点来分：
- 值类型的数据：操作的是数据本身、int 、string、bool、float64、array...
- 引用类型的数据：操作的是数据的地址 slice、map、chan....
package main
import "fmt"
func main() {
// 值传递
arr := [3]int{1, 2, 3}
fmt.Println(arr)
update(arr)
fmt.Println(arr)
// 引用传递
s1 := []int{4, 5, 6}
fmt.Println(s1)
update_s(s1)
fmt.Println(s1)
}
func update(arr [3]int) {
fmt.Println(arr)
arr[1] = 100
fmt.Println(arr)
}
func update_s(s1 []int) {
fmt.Println(s1)
s1[1] = 20
fmt.Println(s1)
}