Go 语言基础1 Slice，map，string
更多个人笔记见：
github个人笔记仓库
gitee 个人笔记仓库
个人学习，学习过程中还会不断补充～ （后续会更新在github上）
文章目录
- stirng 字符串
-
- 区分 rune，byte，string
- 字符串操作
-
-
- strings 库相关
-
- fmt.Printf语法
- Slice 切片
-
-
-
- 基础知识
-
-
- 数组和切片的区别
-
- append函数
-
-
- 通过append看切片和扩容
- 通过 append 合并切片
-
- 利用\[:]的方式制造切片
-
-
- 截取示范
- 截取的地址分析
-
- := 赋值的影响
- range 的使用
-
-
- copy的使用
-
-
-
- Map映射
-
-
-
- 基本示例
- map在并发读写中的问题
- Map原理
-
-
- map 结构
-
-
-
stirng 字符串
- 求长度还是utf库中求，因为中文有占3/4字节的，用len不准确
- 符串和数组不能直接123 + “456”这样拼接
con := fmt.Sprintf("123%d",456) println(con)
区分 rune，byte，string
package main
import (
"fmt"
)
func main() {
s := "hello world" //直接字符串形式
for _, v := range s {
fmt.Printf("value is %c,type is %T\n", v, v)
//typeis：int32value (rune)
}
for _, v := range s {
fmt.Println(v) //是 int32 形式的数字
//is int32vlaue (rune)
fmt.Println(string(v))
//string
}
tokens := []string{"2", "1", "+", "3", "*"} //用 string处理
for i := 0; i < len(tokens); i++ {
fmt.Printf("type is %T\n", tokens[i])
//type is string
}
bytes := []byte("hello world") //用 byte 处理
for i := 0; i < len(bytes); i++ {
fmt.Printf("value is %c,type is %T", bytes[i], bytes[i])
//type is uint8
fmt.Println(bytes[i])
//value is 104,type is uint8
}
runes := []rune(s)
for i := 0; i < len(runes); i++ {
fmt.Printf("value is %c,type is %T\n", runes[i], runes[i])
//value is h,type is rune
fmt.Println(string(runes[i]))
//string
}
}
总结：
- 原始字符串之中 的内容每一个是 rune 存储，rune 是 int32
- byte 就是转为 int8
- string类型是不同于 rune 的，stirng 的列表中的类型就是 string 而不是 rune 的 int32
字符串操作
strings 库相关
常用：
func main() {
fmt.Println(strings.ToUpper("hello"))
fmt.Println(strings.ToLower("HELLO"))
fmt.Println(strings.Replace("hello world", "world", "go", -1)) //hello go
fmt.Println(strings.Split("hel-lo-w-rld", "-")) //[hel lo w rld]
fmt.Println(strings.Join([]string{"hel", "lo", "w", "rld"}, "-")) //hel-lo-w-rld
}
fmt.Printf语法
//输出形式
fmt.Printf("整数：%d\n", 123) // %d：十进制整数
fmt.Printf("字符：%c\n", 'A') // %c：字符
fmt.Printf("字符串：%s\n", "hello") // %s：字符串
fmt.Printf("布尔值：%t\n", true) // %t：布尔值
fmt.Printf("浮点数：%f\n", 3.14) // %f：浮点数
fmt.Printf("二进制：%b\n", 15) // %b：二进制
fmt.Printf("十六进制：%x\n", 15) // %x：十六进制（小写）
//类型相关
fmt.Printf("类型：%T\n", 123) // %T：类型
fmt.Printf("值：%v\n", 123) // %v：默认格式
fmt.Printf("Go语法：%#v\n", "hello") // %#v：Go语法格式
fmt.Printf("p=%+v\n", p) // p={x:1 y:2} 打印结构体字段和名
fmt.Printf("p=%#v\n", p) // p=main.point{x:1, y:2} 打印更具体结构体名称
Println 会自动回车，Printf 需要\n
Slice 切片
切片：定义，切片长度（实际大小len），容量（底层数组大小cap） 三个组成
基础知识
- []中有数字就是数组，没有就是切片！ （牢记）
- []int{1,2,3}就是切片
- 通常利用make()进行创建 如果使用{}就是直接书写数组内容
- []中不可以是变量比如 k ，后面这样可以：[…] int {1,2,3,4} / [5] int {1,2,3,4,5}
- make 初始化的时候如果只指定一个参数，那么就是切片长度=容量 这样初始化 注意只要是初始化的，都会用 0 占位！！
- 理解res := []int{} 或者 var res []int 或者 res := make([]int,0) 不同的创建方式，经常还是用 make 更加直观
数组和切片的区别
array：数组 （不过变量命名无所谓） slice：切片
![[…/…/attachments/Pasted image 20250525104949.png]]
基本用的都是切片
append函数
通过append看切片和扩容
- 不能直接使用索引来突破切片的长度限制
func main() {
a := make([]int, 5, 10) //长度
a = append(a, 1, 2, 3,4)
fmt.Printf("追加后切片长度为：%d，容量为：%d\n", len(a), cap(a))
fmt.Println(a[0:5])
fmt.Printf("追加后赋值的切片长度为：%d，容量为：%d\n", len(s1), cap(s1))
fmt.Printf("追加后原来的切片长度为：%d，容量为：%d\n", len(a), cap(a))
}
//追加后切片长度为：9，容量为：10
//[0 0 0 0 0]
//追加后赋值的切片长度为：12，容量为：20
//追加后原来的切片长度为：9，容量为：10
通过 append 合并切片
func main() {
array := []int{1, 2, 3, 4, 5}
array2 := []int{1, 2, 3, 4, 5}
res := append(array,array2...) //需要加...
fmt.Println(res)
//[1 2 3 4 5 1 2 3 4 5]
}
算法中常用：
a := int(len(numbers)/2) //取出中间元素的位置
nunbers = append(numbers[:a],numbers[a+1:]...) //去掉这个个数
利用[:]的方式制造切片
截取示范
- :后面的是不包括在里面的
func main() { array := []int{1, 2, 3, 4, 5} s1 := array[:3] s2 := array[:] fmt.Println(s1, s2) // [1 2 3] [1 2 3 4 5] }
截取的地址分析
- 二者地址上就差8个字节
func main() {
array := []int{1, 2, 3, 4, 5}
s1 := array[1:]
fmt.Printf("array 切片地址%p\n",array) //不是 array 这个变量的地址，做好区分
fmt.Printf("s1 切片地址%p\n",s1)
fmt.Printf("array 变量地址%p\n",&array) //和上面切片地址是不一样的
}
:= 赋值的影响
赋值的操作本质上就是参数拷贝
利用:=来共享底层数组的切片，修改时会同时影响到
func main() {
array := []int{1, 2, 3, 4, 5}
s1 := array
s2 := array[1:3]
array[0] = 100
fmt.Println(s1)
fmt.Println(s2)
//[100 2 3 4 5]
//[2 3]
}
range 的使用
func main() {
nums := []int{2, 3, 4}
sum := 0
for _, num := range nums {
sum += num
}
fmt.Println("sum:", sum)
for i, num := range nums {
if num == 3 {
fmt.Println("index:", i)
}
//index: 1
}
kvs := map[string]string{"a": "apple", "b": "banana"}
for k, v := range kvs {
fmt.Printf("%s -> %s\n", k, v)
}
//两个变量的时候传递的是key - value
for k := range kvs {
fmt.Println("key:", k)
}
//只有一个的时候，传递的是 key
for i, c := range "go" {
fmt.Println(i, c)
}
//0 103
// 1 111 本质因为字符串之中是 int32 存储的
}
#### slice 相关库
###### slices.Equal(a,b) return bool 判断是否相等
```Go
func main() {
array := []int{1, 2, 3, 4, 5}
s1 := array
res:=slices.Equal(s1, array)
fmt.Println(res) // Output: true
}
比较的时候不会看切片的 cap 是不是一样的，就是看 len 中的
copy的使用
有多少就 copy 多少，(,)从后面的 copy 到前面的
func main() {
array := []int{1, 2, 3, 4, 5}
s1 := make([]int, 6)
s2:= make([]int, len(array))
s3 := make([]int, 3)
fmt.Println(len(s1), cap(s1)) // Output: 6,6
copy(s1, array)
copy(s2, array)
copy(s3, array)
fmt.Println(s1) // Output: [1 2 3 4 5 0]
fmt.Println(s2) // Output: [1 2 3 4 5]
fmt.Println(s3) // Output: [1 2 3]
res := slices.Equal(s1, array)
res2 := slices.Equal(s2, array)
fmt.Println(res) // Output: false
fmt.Println(res2) // Output: true
}
Map映射
类似于 python 的字典
- key和value 键-值的对应
- var mapname map[keytype] valuetype 定义
基本示例
func main() {
m := make(map[string]int)
//map will auto increase
m["k1"] = 7
m["k2"] = 13
fmt.Println("map:", m)
v1 := m["k1"]
fmt.Println("v1:", v1)
v3 := m["k3"]
fmt.Println("v3:", v3)
fmt.Println("len:", len(m))
delete(m, "k2")
fmt.Println("map:", m)
//delete certain key
clear(m)
fmt.Println("map:", m)
//clear all of the map
_, prs := m["k2"]
fmt.Println("prs:", prs)
//return the value and indication about the key's existence
//to disambiguate between missing keys and keys with zero values like 0
n := map[string]int{"foo": 1, "bar": 2}
fmt.Println("map:", n)
n2 := map[string]int{"foo": 1, "bar": 2}
if maps.Equal(n, n2) {
fmt.Println("n == n2")
}
}
map在并发读写中的问题
aa := make(map[int]int)
go func (
for {
// aa[0] = 5 //不可以的，不支持并发写
_ = aa[2] //可以的，读操作不影响写操作
}
)()
go func () {
for {
_ = aa[1]
}
}()
Map原理
map 结构
指定map长度为N，会初始化生成桶，桶数量为log2N
map在超过负载因子的时候会双倍重建，如果溢桶太大就会等量重建。当用到的时候旧桶才会放入新桶