1、数组
1.1 数组类型
var 数组名 [数组大小]数据类型
package main import "fmt"func main(){//1、定义一个数组var arr1 [5]intarr1[0] = 100arr1[1] = 200fmt.Println(arr1) //[100 200 0 0 0] }
1.2 数组的初始化方式
package main import "fmt" func main(){//第一种：var arr1 [3]int = [3]int{3,6,9} //指定类型fmt.Println(arr1)//第二种：var arr2 = [3]int{1,4,7} //自动类型推导fmt.Println(arr2)//第三种：var arr3 = [...]int{4,5,6,7} //自动类型推导fmt.Println(arr3)//第四种：var arr4 = [...]int{2:66,0:33,1:99,3:88} //指定下标初始化+自动类型推导fmt.Println(arr4) }
注意：
- 定义数组时，声明的长度不同，即使元素的数据类型相同，但整体的数组类型也是不同的，即长度也是属于类型的一部分
- Go中数组属值类型，在默认情况下是值传递，因此会进行值拷贝，即形参不影响实参
- 如想在其它函数中，去修改原来的数组，可以使用引用传递(指针方式)
package main import "fmt"func f(arr *[]int){for i := 0; i < len(*arr); i++ {(*arr)[i] += 10} }func main(){var arr []int = []int{1,2,3,4,5,6,7,8,9,0}f(&arr)fmt.Println(arr) //[11 12 13 14 15 16 17 18 19 10] }
1.3 数组内存
package main import "fmt" func main(){//声明数组：var arr [3]int16//获取数组的长度：fmt.Println(len(arr))//打印数组：fmt.Println(arr)//[0 0 0]//证明arr中存储的是地址值：fmt.Printf("arr的地址为：%p",&arr)//第一个空间的地址：fmt.Printf("arr的地址为：%p",&arr[0])//第二个空间的地址：fmt.Printf("arr的地址为：%p",&arr[1])//第三个空间的地址：fmt.Printf("arr的地址为：%p",&arr[2]) }
注意：数组每个空间占用的字节数取决于数组类型
数组优点：可以通过[]下标进行线性访问
1.4 数组遍历
1、使用普通for循环
2、使用for-range循环 （key - value）
package main import "fmt"func main(){var arr1 = [...]int{1,2,3,4,5,6,7,8,9,10}//普通for循环遍历for i := 0; i < len(arr1); i++{arr1[i] += 10fmt.Println(arr1[i]) //11 12 13 14 15 16 17 18 19 20}fmt.Println("")//for-range遍历for k,v := range arr1{v += 10 //v只是一个副本，对v的修改不会影响arr1的元素fmt.Println(arr1[k]) //11 12 13 14 15 16 17 18 19 20}fmt.Println("") }注意：使用for-range时，接收的value变量只是一个副本，副本改变不影响原来arr1数组的元素
1.5 二维数组/多维数组
定义：
package main import "fmt"func main(){//定义二维数组var arr [3][4]int = [3][4]int{{1,2,3,4},{5,6,7,8},{9,10,11,12}}//遍历二维数组for i := 0; i < len(arr); i++ {for j := 0; j < len(arr[i]); j++ {fmt.Printf("%d ",arr[i][j]) //1 2 3 4 5 6 7 8 9 10 11 12}}fmt.Println("")//定义多维数组var arr2 [3][2][2][2]int = [3][2][2][2]int{{{{1,2},{3,4}},{{5,6},{7,8}}},{{{9,10},{11,12}},{{13,14},{15,16}}},{{{17,18},{19,20}},{{21,22},{23,24}}}}//遍历多维数组for i := 0; i < len(arr2); i++ {for j := 0; j < len(arr2[i]); j++ {for k := 0; k < len(arr2[i][j]); k++ {for l := 0; l < len(arr2[i][j][k]); l++ {fmt.Printf("%d ",arr2[i][j][k][l]) //1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24}}}} }package main import "fmt"func main(){//定义二维数组var arr [3][4]int = [3][4]int{{1,2,3,4},{5,6,7,8},{9,10,11,12}}//遍历二维数组for k1,v1 := range arr{for k2,v2 := range v1{fmt.Printf("arr[%v][%v] = %v\n",k1,k2,v2)}}//定义多维数组var arr2 [2][2][2][2]int = [2][2][2][2]int{{{{1,2},{3,4}},{{5,6},{7,8}}},{{{9,10},{11,12}},{{13,14},{15,16}}}}//遍历多维数组for k1,v1 := range arr2{for k2,v2 := range v1{for k3,v3 := range v2{fmt.Printf("arr2[%v][%v][%v] = %v\n",k1,k2,k3,v3)}}} }
2、切片
2.1 切片
- 切片(slice)是golang中一种特有的数据类型
- 数组有特定的用处，但数组长度固定不可变，所以在 Go 语言的代码里并不是特别常见。相对的切片却是随处可见的，切片是一种建立在数组类型之上的抽象，它构建在数组之上并且提供更强大的能力和便捷。
- 切片(slice)是对数组一个连续片段的引用，所以切片是一个引用类型。这个片段可以是整个数组，或者是由起始和终止索引标识的一些项的子集。需要注意的是，终止索引标识的项不包括在切片内。切片提供了一个相关数组的动态窗口。
切片的语法：
var 切片名 []类型 = 数组的一个片段引用
2.2 切片的内存分析
切片有3个字段的数据：
- 一个是指向底层数组的指针
- 一个是切片的长度
- 一个是切片的容量
2.3 切片的定义
方式1：定义一个切片，然后让切片去引用一个已经创建好的数组
方式2：通过make内置函数来创建切片。基本语法: var切片名[type = make([], len,[cap])
（make底层创建一个数组，对外不可见，所以不可以直接操作这个数组，要通过slice去间接的访问各个元素，不可以直接对数组进行维护/操作）
方式3：定一个切片，直接就指定具体数组，使用原理类似make的方式。
注意：
切片定义后不可以直接使用，需要让其引用到一个数组，或者make一个空间供切片来使用
不能越界package main import "fmt"func main(){//方式一：定义一个切片，然后让切片去引用一个已经创建好的数组。var arr [5]int = [5]int{1,2,3,4,5}var slice []intslice = arr[1:3]fmt.Println(slice)//方式二：通过make内置函数来创建切片。基本语法: var切片名[type = make([], len,[cap])// make函数的三个参数：1、切片类型；2、切片的长度；3、切片的容量。slice1 := make([]int, 5, 10)fmt.Println(slice1)fmt.Println(slice1[6])//方式三：定义一个切片，直接就指定具体数组。使用原理类似make的方式。slice2 := []int{1,2,3,4,5}fmt.Println(slice2) }
简写方式：
var slice = arr[0:end] ----> var slice = arr[:end] //从起始到指定位置
var slice = arr[start:len(arr)] ----> var slice = arr[start:] //从指定位置到末尾
var slice = arr[0:len(arr)] ----> var slice = arr[:] //从起始位置到末尾位置
可以对切片继续切片：
package main import "fmt"func main(){var arr [5]int = [5]int{0,1,2,3,4}var slice1 []int = arr[:3]var slice2 []int = slice1[1:2]slice2[0] = 100fmt.Println(arr) //[0 100 2 3 4]fmt.Println(slice1) //[0 100 2]fmt.Println(slice2) //[100] }
2.4 切片的遍历
package main
import "fmt"func main(){//定义一个切片slice := []int{1,2,3,4,5}//方式一：forfor i := 0; i < len(slice); i++ {fmt.Println(slice[i]) //1 2 3 4 5}//方式二：for-rangefor _,v := range slice{fmt.Println(v) //1 2 3 4 5}
}2.5 切片的动态增长
package main
import "fmt"func main(){var arr [5]int = [5]int{0,1,2,3,4}slice := arr[2:]fmt.Println(slice) //[2 3 4 0 0]slice = append(slice, 1,2,3,4)fmt.Println(slice) //[2 3 4 1 2 3 4]slice1 := append(slice,100,200,300)fmt.Println(slice1) //[2 3 4 1 2 3 4 100 200 300]
}package main
import "fmt"
func main(){//定义数组：var intarr [6]int = [6]int{1,4,7,3,6,9}//定义切片：var slice []int = intarr[1:4] //4,7,3fmt.Println(len(slice))slice2 := append(slice,88,50)fmt.Println(slice2) //[4 7 3 88 50]fmt.Println(slice)//底层原理：//1.底层追加元素的时候对数组进行扩容，老数组扩容为新数组：//2.创建一个新数组，将老数组中的4,7,3复制到新数组中，在新数组中追加88,50//3.slice2 底层数组的指向 指向的是新数组 //4.往往我们在使用追加的时候其实想要做的效果给slice追加：slice = append(slice,88,50)fmt.Println(slice)//5.底层的新数组 不能直接维护，需要通过切片间接维护操作。
}
可以通过append函数将切片追加给切片：
2.6 切片的拷贝
使用函数：copy(目标切片，源切片)
package main
import "fmt"
func main(){//定义切片：var a []int = []int{1,4,7,3,6,9}var b []int = make([]int,10)//拷贝：copy(b,a) //将a中对应数组中元素内容复制到b中对应的数组中fmt.Println(b) //[1 4 7 3 6 9 0 0 0 0]
}3、映射
映射（map）, Go语言中内置的一种类型，它将键值对相关联，我们可以通过键 key来获取对应的值value。
3.1 语法
语法：var 变量名 map[keytype]valuetype
注意：key、value的类型：bool、数字、string、指针、channel 、还可以是只包含前面几个类型的接口、结构体、数组，key不可以是slice、map、function
特点：
- map集合在使用前一定要make
- map的key-value是无序的
- key是不可以重复的，如果遇到重复，后一个value会替换前一个value
- value可以重复的
3.2 创建方式
package main
import "fmt"
func main(){//方式1：//定义map变量：var a map[int]string//只声明map内存是没有分配空间//必须通过make函数进行初始化，才会分配空间：a = make(map[int]string,10) //map可以存放10个键值对//将键值对存入map中：a[20095452] = "张三"a[20095387] = "李四"//输出集合fmt.Println(a)//方式2：b := make(map[int]string)b[20095452] = "张三"b[20095387] = "李四"fmt.Println(b)//方式3：c := map[int]string{20095452 : "张三",20098765 : "李四",}c[20095387] = "王五"fmt.Println(c)
}3.3 map的操作
增加和更新操作:
map["key"]= value ， 如果key还没有，就是增加，如果key存在就是修改。
删除操作：
delete(map，"key") , delete是一个内置函数，如果key存在，就删除该key-value，如果key不存在，不操作，但是也不会报错
清空操作：
如果我们要删除map的所有key ,没有一个专门的方法一次删除，可以遍历一下key,逐个删除
或者map = make(...)，make一个新的，让原来的成为垃圾，被gc回收
查找操作：
value ,bool = map[key]
value为返回的value，bool为是否返回 ，要么true 要么false
package main import "fmt" func main(){//定义mapb := make(map[int]string)//增加：b[20095452] = "张三"b[20095387] = "李四"//修改：b[20095452] = "王五"//删除：delete(b,20095387)delete(b,20089546)fmt.Println(b)//查找：value,flag := b[200]fmt.Println(value)fmt.Println(flag) }
获取长度：len函数
遍历：for-range
package main import "fmt" func main(){//定义map变量//make5个键值对var mp map[string]string = make(map[string]string,5)mp["string"] = "字符串"mp["int"] = "整型"mp["float"] = "浮点型"mp["bool"] = "布尔型"mp["array"] = "数组"//遍历mapfor k,v := range mp{fmt.Printf("key = %v,value = %v\n",k,v)} }
)
)
