Golang 数组、切片、map使用方法、内存原理

1数组：

在内存中开辟一块连续的存储地址

1.1特点：

1. 有序、可重复、数据类型一致
2. 定长：数组一旦创建长度，不能更改长度大小，但是可以修改其存储的内容

1.2数组语法：

1.3 定义数组方式

var arr [10] int               //默认为0。0。0。0。
var arr1=[10] int {1,2,3,4,5,6}       //值为1,2,3,4,5,6 ，0，0，0，0，
arr2:=[10] int {1,2,3,4,5,6}      //推导类型
arr3:=[...] int {1,2,3,4,5,6}     //长度为实际存储的长度
arr4:=[...] int {1:9,10:3}       //指定下标位置赋值

1.4 数组存取方式

arr[2]=5

//数组是值传递，是将此数组的值拷贝了一份，赋给其他变量数组
temp:=[10] int {}
temp=arr
temp[0]=99    //temp的赋值不影响原数组的值

1.5 数组的循环操作 range方式

for index,value:=range arr{
fmt.Println(index) //数组下标
fmt.Println(value) //数组元素值
}

//数组len(),cap()，数组的长度和容量一致的。

2 切片：

在内存中开辟一块连续的存储地址,长度不固定

2.1 切片特点：

1. 变长：长度和容量都可以更改
2. 引用类型（操作的是指针）
3. 有序

2.2 创建切片：

2.2.1 定义切片的方式

var slice [] int //不写空间大小 ,len=0,cap=0     暂时还没有开辟空间 ，不能够操作赋值的情况
fmt.Println(slice, len(slice), cap(slice))

2.2.2 特别注意：

slice[0]=1 //暂时还没有开辟空间 ，不能够操作赋值的情况，会提示数组越界错误
slice[1]=1

2.2.3 make方式开辟切片空间

//make方式开辟空间，make([]类型，长度，容量)
slice = make([]int, 5, 10) //开辟切片空间后，才可以进行赋值操作
slice[0] = 1               //
slice[1] = 1

2.2.4 定义切片时，直接初始化

slice2 := []int{1, 2, 3, 45, 6}

2.2.5 基于数组的基础上创建切片

arr6 := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
slice3 := arr6[2:7]
fmt.Println(arr6)                     //[1 2 3 4 5 6 7 8 9 10]
fmt.Println(slice3)                   //[3 4 5 6 7]
fmt.Println(len(slice3), cap(slice3)) //len=5  cap=8

2.3切片内存原理（非常重要）

slice3[0] = 100 //切片的下标以自身为准，从0开始  赋值操作时注意不要超过切片的下标index值

//修改基于数组的切片，数组大小空间范围内，修改切片时，原数组的值也相应变化

fmt.Println(arr6)   //[1 2 100 4 5 6 7 8 9 10]
fmt.Println(slice3) //[100 4 5 6 7]

//当切片超过len,但是小于cap的操作
//切片通过append方式增加长度

slice3 = append(slice3, 88888) //切片追加元素，但是因为切片此时的指针定位，还在切片cap范围内，所以，不需要另外拷贝数据分配新地址空间，所以原数组受影响
fmt.Println(arr6)              //[1 2 100 4 5 6 7 88888 9 10]
fmt.Println(slice3)            //[100 4 5 6 7 88888]

//当超过cap时，拷贝数据到新的地址空间，此时不影响原数组
slice3 = append(slice3, 99, 99, 99, 99, 99, 99, 99, 99)
fmt.Println(arr6)   //[1 2 100 4 5 6 7 88888 9 10]
fmt.Println(slice3) //[100 4 5 6 7 88888 99 99 99 99 99 99 99 99]

3 Map集合（映射）：

3.1特点：

1. 存储无序的键值对
2. 键值对一一对应
3. 键不能重复，重复了就覆盖
4. 无序

3.2 创建map:

3.2.1 方式一

//方式一：定义map变量，但是未开辟存储空间，即空map  nil
var map1 map[int]string //map[]
fmt.Printf("%p", &map1)
map1[1] = "hello" //   未开辟空间时，不可以进行赋值操作
fmt.Println(map1) //panic: assignment to entry in nil map

3.2.2方式二

//方式二：直接初始化方式
map2 := map[int]string{1: "hello", 2: "world", 3: "!"}
fmt.Println(map2)

3.2.3方式三

//方式三：make开辟空间方式
map3 := make(map[int]string) //开辟空间后即可以赋值
fmt.Println(map3)

3.3添加元素

map3[1] = "你好" //添加元素
map3[2] = "呀"
fmt.Println(map3) //map[1:你好 2:呀]

3.4删除元素

//删除map中的元素
delete(map3, 2)   //删除操作
fmt.Println(map3) //map[1:你好]

3.5注意事项

//获取map操作，当key不存在时，会报错，可以使用ok的方式判断map键值对是否存在
value, ok := map3[1] //你好 true
fmt.Println(value, ok)
value1, ok1 := map3[5] // false
fmt.Println(value1, ok1)

3.6For range 遍历map

//for range方式遍历map
for key, value := range map3 { //key 键   value 值
fmt.Println(key, value) //1 你好
}