2022/02/04
package main
import (
"fmt"
"sort"
)
/*
map是key-value数据结构,又称为字段或者关联数组,类似其他编程语言的集合
基本语法: var map变量名 map[keytype]valuetype
key可以是什么类型
golang中的map的key可以是很多种类型,比如bool,数字,string, 指针,channel
还可以是只包含前面几个类型的接口, 结构体, 数组
****key通常用int, string
注意: slice, map, function不可以做key;这几个没办法用 == 判断
****value通常用数字, string, map, struct
//声明一个map是不会分配内存的,初始化需要make,分配内存后才能赋值和使用
map使用细节
1.map是引用类型,遵守引用类型传递的机制,在一个函数接收map,修改后会直接修改原来的map
2.map容量达到后,再想map增加元素,会自动扩容,不会发生panic,也就说map能动态的增长键值对
3.map的value也经常使用struct,更适合管理复杂的数据
*/
func main() {
/*
map的声明和注意事项
1.在使用map前需要先make,make的作用就是给map分配数据空间
2.key 重复会覆盖之前的 value值
3.golang中的map是无序的
*/
var a map[string]string = make(map[string]string, 10)
a["no1"] = "hello"
a["no1"] = "world"
fmt.Println(a)
/*
使用map的三种使用方式
1.先声明,再make
2.声明和make一起
3.在声明的时候直接赋值
*/
//1.
var a1 map[string]string = make(map[string]string, 10)
a1["no1"] = "hello"
a1["no1"] = "world"
fmt.Println(a1)
//2.
cities := make(map[string]string)
cities["no1"] = "北京"
cities["no2"] = "南京"
cities["no3"] = "郑州"
fmt.Println(cities)
//3.
heros := map[string]string{
"no1": "g",
"no2": "g",
"no3": "g",
}
fmt.Println(heros)
/*
要存放三个学生的信息, 每个学生有name和sex信息
使用 map[string]map[string]string
*/
studentMap := make(map[string]map[string]string)
studentMap["stu01"] = make(map[string]string, 2)
studentMap["stu01"]["name"] = "lll"
studentMap["stu01"]["sex"] = "man"
studentMap["stu02"] = make(map[string]string, 2)
studentMap["stu02"]["name"] = "yyy"
studentMap["stu02"]["sex"] = "man"
studentMap["stu03"] = make(map[string]string, 2)
studentMap["stu03"]["name"] = "fff"
studentMap["stu03"]["sex"] = "man"
fmt.Println(studentMap)
fmt.Println(studentMap["stu02"])
fmt.Println(studentMap["stu02"]["name"])
/*
map的增删改查操作
1.map的增加和更新(修改)
map["key"] = value
如果key还没有,就是增加,如果key存在就是修改
2.map的删除使用了go的内置函数
delete(map, "key")
delete是一个内置函数,
如果key存在就删除该key-value,如果key不存在,就不操作但是也不会报错
3.如果我们需要删除map的所有的key,可以遍历key,逐个删除
4.map查找,如果想看map中是否存在key"no1"
val, findRes := studentMap["no1"]
if findRes {
fmt.Println("找到了val = ", val)
} else {
fmt.Println("没有no1这个key")
}
*/
//2.删除
delete(studentMap, "stu01")
fmt.Println(studentMap)
delete(studentMap, "000")
fmt.Println(studentMap)
//3.删除所有的key
//3.1 遍历所有的key,然后逐一删除
//不能用for循环,拿不到map的下标(key不一定是数字), 只能用for-range
for key, value := range studentMap {
fmt.Printf("key = %v, value = %v\n", key, value)
for k, v := range value {
fmt.Printf("k = %v, v = %v\n", k, v)
}
}
for key := range studentMap {
delete(studentMap, key)
}
fmt.Println("delete所有key以后的map,studentMap = ", studentMap)
//3.2 直接make一个新的空间
studentMap = make(map[string]map[string]string)
fmt.Println(studentMap)
//4.map的查找
val, findRes := studentMap["stu02"]
if findRes {
fmt.Println("找到了val = ", val)
} else {
fmt.Println("没有no1这个key")
}
//5.map的长度 //统计有多少对 key - value
fmt.Println("len = ", len(studentMap))
//6.map的排序
/*
1.golang中没有一个专门对map的key进行排序
2.golang中的map默认是无序的,也不是按照添加的顺序存放的
3.将map的key放入到切片中,对切片进行排序,遍历切片,按照key输出map的值
*/
map1 := map[int]int{
10: 100,
1: 13,
4: 56,
8: 90,
}
fmt.Println("map1 = ", map1)
var keys []int
for k := range map1 {
keys = append(keys, k)
}
//排序
sort.Ints(keys)
fmt.Println("keys = ", keys)
//遍历切片按照key顺序来输出
for _, v := range keys {
fmt.Printf("map1[%v] = %v\n", v, map1[v])
}
}
package main
import "fmt"
/*
map切片
切片的数据类型如果是map,则我们成为slice of map, map切片
这样使用则map个数就可以动态变化了
*/
func main() {
//案例演示
/*
使用一个map来记录monster的信息name和age,
也就是说一个monster对应一个map,并且妖怪的个数可以动态的增加
*/
//1.声明一个map切片
monsters := make([]map[string]string, 2) //准备放两个妖怪的信息
//2.增加第一个妖怪的信息
if monsters[0] == nil {
monsters[0] = make(map[string]string, 2)
monsters[0]["name"] = "牛魔王"
monsters[0]["age"] = "500"
}
if monsters[1] == nil {
monsters[1] = make(map[string]string, 2)
monsters[1]["name"] = "玉兔"
monsters[1]["age"] = "400"
}
// if monsters[2] == nil { //数组越界
// monsters[2] = make(map[string]string, 2)
// monsters[2]["name"] = "狐狸"
// monsters[2]["age"] = "300"
// }
//需要使用切片的append函数,可以动态增加
//1.先定义一个monster信息
newMonsters := map[string]string{
"name": "新妖怪",
"age": "500",
}
monsters = append(monsters, newMonsters)
fmt.Println(monsters)
}
package main
import "fmt"
/*
1. golang不是纯粹的面向对象语言,但是golang支持面向对象编程特性[OOP]
2. golang没有类,go的结构体和其他变成语言的类(class)有同等的地位,
可以理解为golang是基于struct来实现OOP特性的
3. golang面向对象变成非常简洁,
去掉了传统的OOP语言的集成,方法重载,构造函数和析构函数,隐藏了this指针等
4. golang仍然有面向对象编程的集成,封装和多态的特性,只是实现的方式不同
5.
*/
type Cat struct {
Name string
Age int
Color string
hobby string
}
type Person struct {
Name string
Age int
}
func main() {
/*
struct实例
*/
var cat1 Cat // var a int
cat1.Name = "levi"
cat1.Age = 3
cat1.Color = "white"
cat1.hobby = "fish"
fmt.Println(cat1)
/*
创建结构体变量和访问结构体字段的几种方式
1.直接声明 var cat1 Cat
*/
//2.
p2 := Person{}
p2.Name = "levi"
p2.Age = 18
fmt.Println(p2)
//3.
p3 := Person{"mary", 20}
fmt.Println(p3)
//4.
p4 := new(Person)
(*p4).Age = 18
p4.Age = 12
//两种写法等价,标准的字段赋值方式是(*p4).Age = 18
//go设计者为了方便,底层会对p4.Age = 12 进行处理
//会给p4加上取值运算符
var p5 *Person = new(Person)
fmt.Println(*p4)
fmt.Println(*p5)
//5.
var p6 *Person = &Person{}
p6.Age = 10
fmt.Println(*p6)
}
package main
import "fmt"
/*
1.使用map[string]map[string]string的map类型
2.key表示用户名,唯一
3.如果某个用户名存在,就将其密码修改为"888888", 如果不存在就增加这个用户的信息
4.编写一个函数完成功能
*/
func modifyUser(users map[string]map[string]string, name string) {
if users[name] != nil {
users[name]["pswd"] = "888888"
} else {
newUser := make(map[string]string)
newUser["nickname"] = name + "qwq"
newUser["pswd"] = "1123"
users[name] = newUser
}
}
func main() {
var users map[string]map[string]string = make(map[string]map[string]string, 10)
users["smith"] = make(map[string]string, 2)
users["smith"]["nickname"] = "gaga"
users["smith"]["pswd"] = "112322"
modifyUser(users, "smith")
modifyUser(users, "levi")
modifyUser(users, "qqq")
modifyUser(users, "www")
fmt.Println(users)
}