Golang基础2-Array、Slice、Map

news/2024/9/20 1:29:19/ 标签: 算法

Array

数组

1. var a [5]int b:=[5]int{} c:=[...]int{}这样格式定义
2. var a[5]int 和var a[10]int是不同类型
3. 从0开始下标，到len(a)-1
4. 遍历方式：

for i := 0; i < len(a); i++ {
}for index, v := range a {
}

1. 注意越界问题，panic
2. 值类型，传参时会拷贝产生副本，不是指针 (因此会有性能问题）可以考虑传指针或者slice等引用类型
3. 指针数组 [n]*T 数组指针 *[n]T。

简单demo

package mainimport "fmt"// 定义数组测试
func Test1() {var a [5]intb := [...]float64{1, 2, 3}//cap和len都会输出数组长度lenA := cap(a)lenB := len(b)fmt.Println(a, lenA)fmt.Println(b, lenB)//[0 0 0 0 0] 5//[1 2 3] 3
}// 循环输出测试
func PrintArr(arr [5]int) {//对比地址可以发现是拷贝的值fmt.Println(&arr[0])//循环输出元素测试for i := 0; i < len(arr); i++ {fmt.Println(i, "->", arr[i])}fmt.Println("***********************")for index, value := range arr {fmt.Println(index, "->", value)}
}func main() {//Test1()arr := [5]int{1, 2, 3, 4}fmt.Println(&arr[0])PrintArr(arr)
}

Slice

切片

最常用，最重要类型之一

变长序列，引用了数组对象，灵活

指针(底层数组，但不一定数组首地址)，长度len，容量cap

初始化demo

package mainimport "fmt"func main() {//var arr1 [5]int//声明切片,注意与数组对比var s1 []intif s1 == nil {fmt.Println("初始化为空!")} else {fmt.Println("不为空！")}fmt.Println(s1)// :=s2 := []int{}fmt.Println(s2)// make方式 len(2) cap(3)var s3 []int = make([]int, 2, 3)fmt.Println(s3, "len(s3)=", len(s3), " cap(s3)=", cap(s3))//len(4) cap(4)s4 := make([]int, 4)fmt.Println(s4, "len(s4)=", len(s4), " cap(s4)=", cap(s4))//从数组中切片arr := [5]int{1, 2, 3, 4, 5}//左[  右)s6 := arr[1:4]fmt.Println(s6)
}

简单理解slice底层demo

具体源码在src/runtime/slice.go当中

package mainimport "fmt"func main() {arr := [6]int{0, 1, 2, 3, 4, 5}x := arr[:6]y := arr[1:3]fmt.Println(arr)fmt.Println(x, y)//    [0 1 2 3 4 5]//    [0 1 2 3 4 5] [1 2]fmt.Println()arr[1] = 100fmt.Println(arr)//实际操作底层数组fmt.Println(x, y)//    [0 100 2 3 4 5]//    [0 100 2 3 4 5] [100 2]fmt.Println()x[2] = 200fmt.Println(arr)//实际操作底层数组fmt.Println(x, y)
}

追加元素append demo

共享内存下容易出现的bug，请仔细分析

老数组

初始化时若：newSlice := array[1:2:2] ，如果第三个值(cap(slice))大于len(slice)

cap>len的时候请注意共享内存下的数据。

package mainimport "fmt"// 切片len<cap 注意会影响共享内存下的值
func main() {array := [4]int{10, 20, 30, 40}slice := array[0:2]newSlice := append(slice, 300)//这两个很有区别，这个扩容超出cap进行重新分配//newSlice := append(slice, 300, 400, 500)fmt.Println(slice, newSlice)fmt.Printf("&slice=%p &newSlice=%p\n", &slice, &newSlice)fmt.Printf("&slice[0]=%p &newSlice[0]=%p\n", &slice[0], &newSlice[0])fmt.Println(slice, newSlice, array)newSlice[1] = 200fmt.Printf("&slice=%p &newSlice=%p\n", &slice, &newSlice)fmt.Printf("&slice[0]=%p &newSlice[0]=%p\n", &slice[0], &newSlice[0])fmt.Println(slice, newSlice, array)
}

新数组：

扩容策略，即内存不够的时候重新分配array数组

当cap比较小的时候，扩容直接2倍

随着增大就扩容1/3，1/4等等逐渐减少

新数组扩容demo

package mainimport "fmt"// 了解分配策略
func main() {//初始化sliceslice := []int{0}c := cap(slice)num := 0 //计数，扩容次数for i := 0; i < 1024; i++ {//添加前cappreArr := &slice[0]preSlice := &sliceslice = append(slice, i)//添加后cap变大了就代表扩容了if n := cap(slice); n > c {fmt.Println("cap:", c, " --> ", n)fmt.Printf("  扩容前后底层array地址：%p --> %p\n", preArr, &slice[0])fmt.Printf("  扩容前后slice地址：%p --> %p\n\n", preSlice, &slice)c = nnum++}}fmt.Println("扩容了", num, "次！")}

总结：对于slice append造成扩容时，其slice的地址&slice不变，变化的是其内部array的地址

Slice详解分析：

https://halfrost.com/go_slice/

删除切片某元素demo

go语言并没有删除切片元素的接口，因此只能根据特性删除，[:]

删除开头元素：

    //方法1：移动array的指针   s := []int{1, 2, 3, 4}fmt.Printf("%#v\n", s)//fmt.Println(unsafe.Sizeof(int(0)))fmt.Printf("&s = %p\n", &s)fmt.Printf("&s[0] = %p\n\n", &s[0])//删除前两个元素，把底层的ptr向右移动s = s[2:]fmt.Printf("%#v\n", s)fmt.Printf("&s = %p\n", &s)fmt.Printf("&s[0] = %p\n\n", &s[0])//方法2：不改变array指针，但是代价是后面array数据向前移动s := []int{1, 2, 3, 4}fmt.Printf("&s = %p\n", &s)fmt.Printf("&s[0] = %p\n\n", &s[0])//删除掉a[0]s = append(s[:0], s[1:]...)fmt.Printf("%#v\n", s)fmt.Printf("&s = %p\n", &s)fmt.Printf("&s[0] = %p\n\n", &s[0])//方法3：copy函数辅助s := []int{1, 2, 3, 4}fmt.Printf("%#v\n", s)fmt.Printf("&s = %p\n", &s)fmt.Printf("&s[0] = %p\n\n", &s[0])//删除掉a[0] a[1]s = s[:copy(s, s[2:])]fmt.Printf("%#v\n", s)fmt.Printf("&s = %p\n", &s)fmt.Printf("&s[0] = %p\n\n", &s[0])

删除中间元素

    s := []int{0, 1, 2, 3, 4, 5, 6, 7}fmt.Printf("%#v\n", s)fmt.Printf("&s = %p\n", &s)fmt.Printf("&s[0] = %p\n\n", &s[0])//删除a[3]//s = append(s[:3], s[4:]...)//s = s[:3+copy(s[3:], s[4:])] // 删除中间1个元素//删除a[3]之后的3个元素//s = append(s[:3], s[6:]...)s = s[:3+copy(s[3:], s[6:])] // 删除中间1个元素fmt.Printf("%#v\n", s)fmt.Printf("&s = %p\n", &s)fmt.Printf("&s[0] = %p\n\n", &s[0])

删除尾部元素

a = []int{1, 2, 3}
a = a[:len(a)-1] // 删除尾部1个元素
a = a[:len(a)-N] // 删除尾部N个元素

切片删除元素：Go语言从切片中删除元素

container/list

这个是container中的list使用，也常见，了解即可。

package mainimport ("container/list""fmt"
)func main() {var mylist = list.List{}mylist.PushBack(123)mylist.PushBack(456)mylist.PushBack(789)fmt.Println(mylist)// 遍历listfor i := mylist.Front(); i != nil; i = i.Next() {fmt.Println(i.Value)}fmt.Println("--------------")for i := mylist.Back(); i != nil; i = i.Prev() {fmt.Println(i.Value)}// 其他需求，自己查阅资料}

https://juejin.cn/post/6888117219213967368#heading-2

Map

哈希表，无序key/value键值对

map[keyType][valueType] ,key是唯一的，其对应的value也唯一

map必须初始化才能读写，否则只能读

线程不安全，在多线程当中使用sync.Map,我编辑在了并发编程当中

简单demo

package mainimport "fmt"// 全局初始化
var map1 map[int]stringfunc main() {//等价//可以声明时初始化//scoreMap := map[string]int{}//可以声明初始化空间scoreMap := make(map[string]int, 0)scoreMap["张三"] = 100scoreMap["赵六"] = 10scoreMap["李四"]=60// 双参数返回，val,ok，如果单参数val，!ok返回空，有可能key是空if value, ok := scoreMap["张三"]; ok {fmt.Println(value)} else {fmt.Println("查无此人")}fmt.Println(scoreMap)fmt.Printf("%#v\n", scoreMap)// 删除key,valuedelete(scoreMap, "张三")fmt.Println(scoreMap)fmt.Printf("%#v\n", scoreMap)
}

输出是没有顺序的，如果想要按照一定顺序，可以先取出key，然后排序，之后输出。

key对应一个value，其中如果value切片的话会很灵活，map类型的切片也很灵活

对map进行打印

    var courseMap = map[string]string{"go":   "go语言圣经","gin":  "深入理解gin框架","grpc": "grpc理解",}for key, value := range courseMap {fmt.Println(key, "-->", value)}fmt.Println("---------------")for key := range courseMap {fmt.Println(key, "-->", courseMap[key])}