golang笔记05

一、map(集合)

1、介绍

map是Go中内置类型，它将一个值与一个键关联起来，可以使用相应的键检索值，Map是一种无序的键值对集合，Map最重要的一点是通过key来快速检索数据。

使用map过程中需要注意的几点：

1. map是无序的，每次打印出来的map都是不一样的，它不能通过index获取，而必须通过key获取
2. map的长度是不固定的，也就是和slice一样，也是一种引用类型
3. 内置的len函数同样适用于map，返回map拥有的key的数量
4. map的key可以是所用可比较的类型，如布尔、整数型、浮点型、复杂型、字符串也可以

2、map的使用

/*
创建方式：
1、var 变量名 map[键类型]值类型 —— var map_value map[string]string (nil无法直接使用)
2、var 变量名=make(map[键类型]值类型) —— map_value=make(map[string]string) 
3、map_value:=map[string]string {"A":65,"B":66}
4、var map_value=map[string]string {"A":65,"B":66}
如果不初始化map，那么就会创建一个nil map.nil map不能用来存放键值对
*/
package main
import (
	"fmt"
	"sort"
)
func main() {
	s:="------------------------分割线-------------------------------"
	//创建map
	mapValue :=make(map[int]string)
	fmt.Println(s)

	//存储数据给map
	mapValue[1]="李白"
	mapValue[2]="杜甫"
	mapValue[3]="王安石"
	mapValue[4]="杜牧"
	fmt.Println(s)

	//获取数据，根据key获取对应数据
	//根据key获取对应的value，如果key存在，获取数值，如果不存在，获取的是对应值类型的默认值
	fmt.Println(mapValue)
	fmt.Println(mapValue[1])
	fmt.Println(mapValue[20])//""
	fmt.Println(s)

	//判断该值是否是默认值,接受两个值，第一个值是map键值对对应的值，另一个是表示该值是否为默认值的判断
	v1,ok :=mapValue[40]
	fmt.Println(v1,ok)
	fmt.Println(s)

	//修改数据
	mapValue[1]="小白" //将mapValue[1]改为小白
	fmt.Println(mapValue[1])
	fmt.Println(s)

	//删除数据,如果key不存在，则删除操作没有对map影响
	delete(mapValue,1)//将mapValue中键值为1的键值对删除
	fmt.Println(mapValue)
	fmt.Println(s)

	//获取map长度
	fmt.Println(len(mapValue))
	fmt.Println(s)
	//map的遍历
	/*
		使用for range
		数组，slice ：index value
		map : key value
	*/
	for key,value := range mapValue{
		fmt.Println(key,value)
	}
	fmt.Println(s)
	/*
	通过字典序大小对map进行排序
	1、获取所有的key
	2、进行排序
	3、遍历map
	*/
	keys :=make([]int,0,len(mapValue))
	for key,_:=range mapValue{
		keys=append(keys,key)
	}
	fmt.Println(keys)
	//使用sort排序
	sort.Ints(keys)
	fmt.Println(keys)
	//遍历所有key来取map的所有值
	for _,key :=range keys{
		fmt.Println(key,mapValue[key])
	}
	fmt.Println(s)
}

2、map与slice的结合

package main
import "fmt"
func main() {
	/*
		1、使用map存储人的信息
		2、每个map存储一个人的信息
		3、将这些map存储到slice中
		4、打印出来
	*/
	people :=make([]map[string]string,0)
	for i:=0;i<3;i++{
		fmt.Println("请输入姓名、年龄、性别：")
		var name,age,sex string
		var mapValue=make(map[string]string)
		fmt.Scan(&name,&age,&sex)
		mapValue["name"]=name
		mapValue["age"]=age
		mapValue["sex"]=sex
		people=append(people,mapValue)
	}
	fmt.Println(people)

	for _,mpValue :=range people{
		fmt.Println(mpValue["name"],mpValue["age"],mpValue["sex"])
	}
}
输入：
请输入姓名、年龄、性别：
小欢 18 女
请输入姓名、年龄、性别：
小黄 19 男
请输入姓名、年龄、性别：
哦哦 17 女
输出：
[map[age:18 name:小欢 sex:女] map[age:19 name:小黄 sex:男] map[age:17 name:哦哦 sex:女]]
小欢 18 女
小黄 19 男
哦哦 17 女

3、map嵌套map

//map是引用数据类型，传递的是地址同slice
package main
import "fmt"
func main() {
	//map嵌套另一个map
	mapValue:=make(map[string]map[string]string)
	m1:=map[string]string {"name":"小黑"}
	m2:=map[string]string {"name":"小红"}
	mapValue["first"]=m1
	mapValue["second"]=m2
	fmt.Println(mapValue)
	//遍历
	for _,value :=range mapValue{
		for key,val :=range value{
			fmt.Println(key,val)
		}
	}
}
输出：
map[first:map[name:小黑] second:map[name:小红]]
name 小黑
name 小红

二、字符串string

1、介绍

字符串是一个字节的切片，可以通过将其内容封装在 “ ” 中来创建字符串，Go中的字符串是Unicode兼容的并且是UTF-8编码的

2、strings包使用

//string不能任意修改   https://pkg.go.dev/strings@go1.18.2 strings包参考文档
package main
import (
	"fmt"
	"strings"
)
func main() {
	var str string="nihao"
	fmt.Println(str)
	fmt.Println(str[1])//unicode码
	fmt.Printf("%d %T\n",str[1],str[1])

	//string包使用
	//判断该字符是否在string中，strings.Contains(字符串，需要判断的字符串)
	//str="nihao"
	fmt.Println(strings.Contains(str,"aa"))//判断后面的字符是否全部在字符串里面
	fmt.Println(strings.ContainsAny(str,"aa"))//判断后面的字符任意一个字符是否在字符串里面
	fmt.Println(strings.Count(str,"aa"))//统计后面字符在字符串中出现的次数
	s2:="2019abc.txt"
	fmt.Println(strings.HasPrefix(s2,"2019"))//判断字符串以什么开头的
	fmt.Println(strings.HasSuffix(s2,".txt"))//判断字符串以什么结尾的
	fmt.Println(strings.Index(s2,"2"))//查找字符的第一次出现的位置，没有则返回-1
	fmt.Println(strings.IndexAny(s2,"ba"))//查找任意一个字符第一次出现的位置(返回下标小的)，没有则返回-1
	fmt.Println(strings.LastIndex(s2,"t"))//查找字符的最后出现的位置，没有则返回-1

	//字符串拼接
	s3:=[]string{"A","B","C"}
	s4:=strings.Join(s3,"-")//将切片s3中的元素，用“-“连接起来
	s3=append(s3,"1")
	fmt.Println(s4)

	//字符串切割
	slice1:=strings.Split(s4,"-")//将字符串用-为分隔符切割放入切片中
	fmt.Println(slice1)

	//重复拼接
	s5:=strings.Repeat("hello",5)//将5个hello拼接在一起
	fmt.Println(s5)

	//替换,s5中的l全部替换成*,
	//第一个参数需要替换的字符串，第二个参数老的字符，第三个参数新的字符，第四个参数替换几次，-1表示全部替换
	s5=strings.Replace(s5,"l","*",-1)
	fmt.Println(s5)

	fmt.Println(strings.ToLower(s5))//全部变成小写
	fmt.Println(strings.ToUpper(s5))//全部变成大写

	//截取子串
	s6:=s5[1:3]
	fmt.Println(s6)
}

3、strconv包使用

package main

import (
	"fmt"
	"strconv"
)

func main() {
	/*
		strconv包：字符串和基本数据类型
		string convert
	*/
	//1、字符串转化为其他数据类型
	s1:="true"
	s3:="100"
	b1,err1 :=strconv.ParseBool(s1)
	//第一个参数转化源，第二个参数转化源的进制，第三个参数转成int的多少位
	b2,err2:=strconv.ParseInt(s3,2,64)
	if err1!=nil||err2!=nil{
		return
	}
	fmt.Printf("%T\n",b1)//b1是转化的值
	fmt.Printf("%T %d\n",b2,b2)//b2是转化的值,b2=4

	//2、将其他类型转化为string
	 s2:= strconv.FormatBool(b1)
	 s4:=strconv.FormatInt(b2,2)//b2=4,转化为二进制是100，再转化为string
	 fmt.Printf("%T\n",s2)
	 fmt.Printf("%T %s\n",s2,s4)

	 //itoa() atoi()
	 s5:=strconv.Itoa(-43)//int转为string
	 s6,err4:=strconv.Atoi("-42")//string转为int
	if err4!=nil{
		return
	}
	fmt.Printf("%T %s\n",s5,s5)
	fmt.Printf("%T %d",s6,s6)
}