Go语言数组数组
一维数组
- 数组定义格式:
var arr [3]int - 数组的初始化方式
- 先定义后初始化
注意点:Go语言数组支持先定义后一次性初始化
//1.先定义后初始化 var nums [3]int //先定义数组再逐个初始化 nums[0] = 1 nums[1] = 2 nums[2] = 3 //先定义数组再一次性初始化 nums = [3]int{2,3,4} fmt.Println(nums)- 定义的同时初始化
-
注意点:给数组一次性赋值的时候一定要在值的前面加上数组的类型,而且必须要和数据类型一模一样 - C语言中数组没有初始化保存的是垃圾数据,Go语言中数组没有初始化保存的是零值
-
//var arr [3]int = [3]int{2, 3, 4} //定义的同时部分初始化,未初始话的元素为0 var arr [3]int = [3]int{1,3} //指定元素初始化 var arr [3]int = [3]int{2:4} //[...]的含义, 让编译器根据赋值的元素个数自动计算数组的元素个数 arr := [...]int{1,3,4} fmt.Println(arr) fmt.Println(arr[0]) fmt.Println(arr[1]) fmt.Println(arr[2]) - 先定义后初始化
零值
- 什么是零值
- 数据类型未初始化,系统自动添加的数据
- 各种数据类型零值
- int/int8/int16/int32/int64/uint/uint8/uint16/uint32/uint64/byte/rune/uintptr的默认值是0
- float32/float64的默认值是0.0
- bool的默认值是false
- string的默认值是""
- pointer/function/interface/slice/channel/map/error的默认值是nil
值类型
- Go语言在数组中是值类型,所以数组之间的赋值是值拷贝关系,而不是指向关系
- 如果想让两个数组可以相互赋值, 那么两个数组的类型必须一致类型一致包括元素个数, 元素个数也是Go语言中数组类型的一部分
- 如果数组中存储的元素类型支持== != 操作,而且两个数组的类型是一个样的, 那么数组也支持== !=操作
package main
import "fmt"
func main() {
nums := [...]int {2,3,4}
arr := [...]int{2,3,4}
fmt.Println(nums == arr) //true
nums := [3]int{1,2,3}
res := nums
fmt.Println(res) //[1,2,3]
nums := [3]int{1,2,3}
change(nums)
fmt.Println(nums) //[1,2,3]
}
//函数内部无法改变数组元素的值
func change(nums [3]int) {
nums[2] = 666
}
二维数组
- Go语言二维数组格式:
var 数组名称[一维数组个数][一维数组元素个数]数组类型
package main
func main() {
//定义二维数组格式
var nums [2][3]int = [2][3]int{
{1,3,5},
{2,5,6},
}
//简单定义方法
nums := [2][3]int{
{1,2,3},
{4,5,6},
}
arr := [...][3]int{
{12,3,5},
{1,2,6},
}
fmt.Println(arr)
//二维数组也可以省略元素个数,但是只可以省略行数,不可以省略列数
arr := [...][3]int{
{12,3,5},
{1,2,6},
}
//遍历二维数组
for i:=0; i< 2; i++{
for j:=0;j < 3 ;j++ {
fmt.Println(arr[i][j])
}
}
}
数组的遍历
- Go语言数组遍历两种方法
- 普通for循环遍历
nums := [...]int{2, 3, 5, 1, 3, 6} //普通for循环遍历 for i := 0; i < 6; i++ { fmt.Println("index= ", i, "value = ", nums[i]) }- for..range遍历
nums := [...]int{2, 3, 5, 1, 3, 6} //高级for循环遍历 for key,value := range nums{ fmt.Println(key,"-->",value) }
Go语言切片
切片
-
什么是切片
- 在Go语言中,数组的长度一旦确定就无法改变,为了解决这一问题,推出了一种数据类型切片
- 切片简单理解就是一个可变长度的数组,底层的实现原理就是一个结构体, 结构体中有一个指针指向了一个数组
本质上所有的数据都是保存在指向的数组中的
-
创建切片
- 通过数组创建切片1
通过数组来创建 格式: [起始位置:结束位置], 从起始位置开始截取, 直到结束位置, 但是不包括结束位置 注意: 截取了多少个元素, len就等于几 容量等于数组的长度 - 起始位置 nums := [5]int{1,2,3,4,5} //1.通过数组创建切片 //1.1[起始位置 : 结束位置] 从起始位置开始截取,直到结束位置,但是不包括结束位置索引对应的元素 var sce []int = nums[2 : 4] //1.2[: 结束位置]只指定结束位置,不指定起始位置,就是从开始位置截取直到指定的位置,但是也不包括指定位置的元素 var sce []int = nums[:3] //1.3[起始位置 : ] 从起始位置开始截取,直到末尾 var sce []int = nums[0:] //1.4[: ]只有一个:,从开始位置截取,直到末尾结束 var sce []int = nums[:] fmt.Println(sce) //计算切片的长度len当前保存的数据个数 fmt.Println(len(sce)) //计算切片的容量cap总共能够保存数据的个数 fmt.Println(cap(sce))- 通过数组创建切片2
切片的第三个参数max,不能小于第二个参数,作用是用来控制切片容量的
//如果指定了第三个参数, 那么切片的容量就等于 第三个参数 - 第一个参数 //注意点: 如果没有指定第三个参数,那么切片的容量 = 数组的容量 - 第一个参数值 // 如果指定了第三个参数,那么切片的容量 = 第三个参数 - 第一个参数值 arr := [7]int{1,2,3,4,5,6,7} sce := arr[1:4:4] fmt.Println(sce) fmt.Println(len(sce)) fmt.Println(cap(sce))- 通过make()函数创建切片
// 2.通过make函数创建切片 // 第一个参数: 告诉系统要存储什么类型的数据 // 注意点: 如果是创建切片一定要在传入的数据类型前面写上[] // 第二个参数: 告诉系统创建出来的切片len等于多少 // 第三个参数: 告诉系统创建出来的切片cap等于多少 // 注意点: 第三个参数可以省略, 如果省略切片的容量就等于切片的长度(等于第二个参数) //var sce []int = make([]int, 2, 5) var sce []int = make([]int, 2) fmt.Println(sce) fmt.Println(len(sce)) fmt.Println(cap(sce))- 通过语法糖创建切片
// 3.通过Go提供的语法糖来创建 // 一定要注意[]里面没有值就是切片 // 通过Go提供的语法糖来创建len等于cap var sce []int = []int{1, 3, 5} // 相当于make([]int, 3) fmt.Println(sce) fmt.Println(len(sce)) fmt.Println(cap(sce))
切片与数组
- [ ]没有数字就是切片,有数字就是数组,[...]这种定义格式是数组
//定义数组
var arr [5]int = [5]int{1,3,4,5,6}
var arr = [5]int{1,3,4,5,6}
arr := [5]int{1,3,4,5,6}
arr := [...]int{1,3,4,5,6}
//定义二维数组
var arrs [2][3]int = [2][3]int{
{1,3,5},
{2,4,6},
}
var arrs = [2][3]int{
{1,3,5},
{2,4,6},
}
arrs := [2][3]int{
{1,3,5},
{2,4,6},
}
arrs := [...][3]int{
{1,3,5},
{2,4,6},
}
//定义切片
var sce []int = []int{1,3,5}
var sce = []int{1,3,5}
sce := []int{1,3,5}
//定义一个切片,切片中保存的是数组
var sec [][3]int = [][3]int{
{1, 3, 5},
{2, 4, 6},
}
var sec = [][3]int{
{1, 3, 5},
{2, 4, 6},
}
sec := [][3]int{
{1, 3, 5},
{2, 4, 6},
}
//定义一个切片,切片中保存切片
var sec[][]int = [][]int {
{1, 3, 5},
{2, 4, 6},
}
var sec = [][]int {
{1, 3, 5},
{2, 4, 6},
}
sec := [][]int {
{1, 3, 5},
{2, 4, 6},
}
append函数
- append函数格式 :
append(切片,数据) - append函数作用: 追加切片中的数据
- append函数注意点
- 如果通过append函数追加数据之后超过了原有的容量, 那么系统内部会自动按照当前容量*2的方式重新定义一个数组作为切片保存数据的模型
- 在扩容的时候会重新定义一个新的切片, 所以需要返回一个切片
- 扩容问题
- 容量小于1024的时候扩容, 会按照原有容量的2倍扩容
- 容量大于1024的时候扩容,会按照原有的1/4进行扩容
sec := make([]int, 1024, 1024)
sec = append(sec, 6)
fmt.Println(len(sec))
fmt.Println(cap(sec))//1280
切片的使用
- 定义切片
sec := []int{1,3,5,7,9,11}
- 修改切片中的数据
sec[2] = 666
- 增加切片中的数据
sec = append(sec, 7)
fmt.Println(sec)
- 删除切片中指定的数据
//5.删除切片中的指定索引对应的数据
index := 3
//不仅可以利用数组获取切片,还可以用切片获取切片
//sec = sec[:index]
//fmt.Println(sec) //[1 3 5]
//sec = sec[index +1 :]
//fmt.Println(sec) //[9 11]
//将第二个切片追加到第一个切片后面即可
sec = append(sec[:index], sec[index +1 :]...)
fmt.Println(sec) //[1 3 5 9 11]
切片的内存地址
package main
import "fmt"
func main() {
/*
通过切片生成切片的注意点
*/
//1.创建一个数组
var arr = [3]int{1,2,3}
//Go语言中不能通过数组名称获取数组的地址
//fmt.Printf("%p\n", arr)
fmt.Printf("%p\n", &arr) //0xc0420500a0
fmt.Printf("%p\n", &arr[0]) //0xc0420500a0
//2.通过数组创建一个切片
//直接打印sce打印的是sce中指针保存的地址,也就是底层指向的那个数组的地址
sce := arr[:]
fmt.Printf("%p\n", sce) //0xc0420500a0
//3.通过切片创建切片
//通过切片创建一个切片, 新的切片和老的切片底层指向同一个数组
sce2 := sce[:]
fmt.Printf("%p\n", sce2) //0xc0420500a0
//修改数组中的值
arr[2] = 666
sce[2] = 666
sce2[2] = 666
fmt.Println(arr)
fmt.Println(sce)
fmt.Println(sce2)
}
copy函数
package main
import "fmt"
func main() {
/*
copy函数的作用是将源切片的值拷贝到目标切片当中
函数格式 copy(目标切片, 源切片)
*/
sec1 := []int{1, 2, 3, 6, 9, 10}
sec2 := make([]int, 2, 5)
fmt.Println(sec2)
//将源切片的值拷贝到目标切片当中
//注意点: 拷贝的时候是以目标切片为准,目标切片中长度为多少将来只能拷贝多少个值进来
copy(sec2, sec1)
fmt.Println(sec2)
}
切片与字符串
注意点: 切片和数组不同, 切片不支持== !=操作
package main
import "fmt"
func main() {
/*
1.切片可以再生成新的切片, 两个切片底层指向同一个数组
2.切片和数组不同, 切片不支持== !=操作
3.在Go语言中字符串的底层实现就是切片, 所以可以通过字符串来生成切片
*/
//数组可以使用== !=操作
//arr := [3]int{1,2,3}
//arr2 := [3]int{4,5,6}
//arr = arr2
//fmt.Println(arr)
var str string = "www.it666.com"
sec := make([]byte, len(str))
copy(sec,str)
fmt.Println(len(str))
fmt.Printf("%s\n",sec) //www.it666.com
}
切片与数组注意点
数组定义后不初始化,可以使用,切片定义后可以一次性初始化,但是不能逐个初始化,但是可以使用append函数添加数据- 数组定义后直接使用
var arr [4]int
//数组定义后可以直接使用
arr[0] = 1
arr[1] = 3
arr[2] = 5
arr[3] = 7
fmt.Println(arr)
- 切片定义后不能直接使用
var sce []int
//不能逐个初始化,会报错
//sce[0] = 1
//sce[1] = 3
//sce[2] = 5
//可以使用append函数添加数据
sce = append(sce,1)
sce = append(sce,3)
sce = append(sce,5)
sce = append(sce,7)
sce = append(sce,9)
//打印切片
fmt.Println(sce)
fmt.Println(len(sce))
fmt.Println(cap(sce))
- 计算数组的长度方式
//计算数组长度的方式
//第一种方式(推荐)使用len函数
arr := [4]int{1,3,5,7}
//length := len(arr)
//fmt.Println(length)
//第二种方式,使用unsafe.Sizeof函数计算(不推荐)
length1 := unsafe.Sizeof(arr)
length2 := unsafe.Sizeof(arr[0])
fmt.Println(length1 / length2)
- 计算切片的长度
//计算切片的长度
//第一种方式(推荐)使用len函数
//注意点: 切片的长度不能使用unsafe.Sizeof函数计算
//由于切片本质是结构体,所以unsafe.Sizeof计算的是结构体的字节数,不是指向数组的字节数
sce := []int{1,3,5,6}
length := len(sce)
fmt.Println(length)
- 切片与数组的传递
- 数组传递是值传递
- 切片传递是地址(指针)传递
package main
import "fmt"
func main() {
/*
1.数组作为函数参数是值传递,在函数内部修改形参是不会影响外部实参的值
2.切片作为函数的参数是地址传递(指针), 在函数内修改形参, 会影响到函数外的实参
*/
//arr := [4]int{1,3,4,5}
//fmt.Println(arr)
//change1(arr)
//fmt.Println(arr)
sce := []int{1,2,3,4}
fmt.Println(sce)
change2(sce)
fmt.Println(sce)
}
//数组是值传递
func change1(arr [4]int) {
arr[0] = 666
}
//切片是地址传递指针
func change2(sce []int) {
sce[0] = 666
}
可变参数
- 可变参数底层实现就是切片
package main
import "fmt"
func main() {
/*
可变参数,底层其实就是一个切片
*/
res := sum(10,20,30)
fmt.Println(res)
}
//可变参数底层就是一个切片
//注意点: 当一个函数中定义可变参数时候,可变参数只能放在形参列表的最后面
func sum(nums ...int) (res int) {
for _, value := range nums {
res += value
}
return
}
