• 5.Go语言-map类型


    1.map

    • map是一种无序的基于key-value的数据结构,Go语言中的map是引用类型,必须初始化才能使用。map如果不做初始化,它就是个nil

    • map定义:

      • Go语言中map的定义语法:

        map[keytype]ValueType
        
      • 其中:

        • keyType 表示键的类型
        • ValueType表示键对应的值的类型
    • 初识map:

      package main
      
      import "fmt"
      
      //map(映射)
      func main() {
      	//键是字符串类型,值是int类型
      	//只是声明map类型,但是没有初始化,没有初始化默认a就是初始值nil
      	var a map[string]int
      	fmt.Println(a == nil)//true
      	//map的初始化
      	a = make(map[string]int, 8)
      	fmt.Println(a == nil)//false
          fmt.Println(a)//map[]
      }
      
      
    • map中添加键值对

      package main
      
      import "fmt"
      
      //map(映射)
      func main() {
      	//map的初始化
          a := make(map[string]int, 8)
      	//map中如何添加键值对
      	a["皮城女警"] = 150
      	a["赏金猎人"] = 200
      	fmt.Println(a)
      	fmt.Printf("a:%#v
      ", a)//连数据类型和数据都显示
      	fmt.Printf("type:%T
      ", a)
      }
      
      // map[皮城女警:150 赏金猎人:200]
      // a:map[string]int{"皮城女警":150, "赏金猎人":200}   
      // type:map[string]int
      
      
    • 声明map的同时完成初始化

      package main
      
      import "fmt"
      
      //map(映射)
      func main() {
      	//声明map的同时完成初始化
      	b := map[int]bool{
      		1: true,
      		2: false,
      	}
      	fmt.Printf("b:%#v
      ", b)
      	fmt.Printf("type:%T", b)
      	
      }
      //b:map[int]bool{1:true, 2:false}
      	//type:map[int]bool
      
    • 判断 值是否在map中

      //map(映射)
      package main
      
      import "fmt"
      
      
      func main() {
      	//判断某个键存不存在
      	var scoreMap = make(map[string]int, 8)
      	scoreMap["小明"] = 99
      	scoreMap["小红"] = 89
      	//判断 小刚  在不在scoreMap中
      	v, ok := scoreMap["小刚"]
      	fmt.Println(v, ok)// 0 false
      	if ok {
      		fmt.Println("小刚在scoreMap中")
      	} else {
      		fmt.Println("查无此人") // 查无此人
      	}
      
      }
      
    • map的遍历(使用for...range)

      • map是无序的,键值对和添加的顺序无关
      package main
      
      import "fmt"
      
      //map(映射)
      func main() {
      	//map的遍历
      	var scoreMap = make(map[string]int, 8)
      	scoreMap["小明"] = 99
      	scoreMap["小红"] = 89
      	scoreMap["小刚"] = 65
      	//for range遍历
      	for k, v := range scoreMap {
      		fmt.Println(k, v)
      	}
          //只遍历key
          for k := range scoreMap {
      		fmt.Println(k)
      	}
          //只遍历value
          for _, v := range scoreMap {
      		fmt.Println(v)
      	}
          
      
      }
      //小刚 65
      //小明 99
      //小红 89
      
    • 使用delete函数删除map键值对

      package main
      
      import "fmt"
      
      //map(映射)
      func main() {
      	var scoreMap = make(map[string]int, 8)
      	scoreMap["小明"] = 99
      	scoreMap["小红"] = 89
      	scoreMap["小刚"] = 65
      	//删除小刚 这个键值对
      	delete(scoreMap, "小刚")
      	fmt.Println(scoreMap)
      
      }
      
      
    • 按照key从小到大的顺序去遍历scoreMap

      package main
      
      import "fmt"
      import "sort"
      import "math/rand"
      //map(映射)
      func main() {	
      	var scoreMap = make(map[string]int, 100)
      	//添加50个键值对
      	for i := 0; i < 50; i++ {
      		key := fmt.Sprintf("stu%02d", i)
      		value := rand.Intn(100) //0-99随机整数
      		scoreMap[key] = value
      	}
      	// for key, value := range scoreMap {
      	// 	fmt.Println(key, value)
      	// }
      	//按照key从小到大的顺序去遍历scoreMap
      	//1.先取出所有的key,存放到切片中
      	keys := make([]string, 0, 100)
      	for k := range scoreMap {
      		keys = append(keys, k)
      	}
      	//2.对key做排序
      	sort.Strings(keys) //keys是一个有序的切片
      	//3.按照排序后的key对应scoreMap排序
      	for _, key := range keys {
      		fmt.Println(key, scoreMap[key])
      	}
      }
      
      
    • 元素为map的切片

      package main
      
      import "fmt"
      
      //map(映射)
      func main() {
      	
      	//元素为map的切片
      	var mapSlice = make([]map[string]int, 8, 8) //只完成了切片的初始化,没有完成map的初始化
      	//还需要完成内部map的元素初始化
      	mapSlice[0] = make(map[string]int, 8) //完成切片第一个map初始化
      	mapSlice[0]["xjk"] = 100
      	fmt.Println(mapSlice)
      }
      
    • 值为切片类型的map

      package main
      
      import "fmt"
      
      //map(映射)
      func main() {
      	//值为切片的map
      	var sliceMap = make(map[string][]int, 8) //只完成了map的初始化
      	v, ok := sliceMap["中国"]
      	if ok {
      		fmt.Println(v)
      	} else {
      		//sliceMap中没有中国这个键
      		sliceMap["中国"] = make([]int, 8) //完成了对切片的初始化
      		sliceMap["中国"][0] = 100
      		sliceMap["中国"][1] = 200
      		sliceMap["中国"][2] = 300
      	}
      	fmt.Println(sliceMap)
      	//遍历sliceMap
      	for k, v := range sliceMap {
      		fmt.Println(k, v)
      	}
      
      }
      
    • 练习题:统计一个字符串中每个单词出现的次数

      package main
      
      import (
      	"fmt"
      	"strings"
      )
      
      //map(映射)
      func main() {
      
      	//统计一个字符串中每个单词出现次数
      	//"how do you do"中每个单词出现次数
      	temp := "how do you do"
      	//定义一个map[string]int
      	var wordCount = make(map[string]int, 10)
      	//字符串中都有哪些单词
      	words := strings.Split(temp, " ")
      	//遍历单词做统计
      	for _, word := range words {
      		v, ok := wordCount[word]
      		if ok {
      			wordCount[word] = v + 1
      		} else {
      			wordCount[word] = 1
      		}
      	}
      	for k, v := range wordCount {
      		fmt.Println(k, v)
      	}
         // Printf 格式化输出。
      
  • 相关阅读:
    [Python设计模式] 第21章 计划生育——单例模式
    [Python设计模式] 第20章 挨个买票——迭代器模式
    [Python设计模式] 第19章 分公司=部门?——组合模式
    [Python设计模式] 第18章 游戏角色备份——备忘录模式
    [Python设计模式] 第17章 程序中的翻译官——适配器模式
    [Python设计模式] 第16章 上班,干活,下班,加班——状态模式
    [Python设计模式] 第14章 老板来了——观察者模式
    [Python设计模式] 第13章 造小人——建造者模式
    [Python设计模式] 第12章 基金理财更省事——外观模式
    [Python设计模式] 第11章 迪米特法则——最少知识原则
  • 原文地址:https://www.cnblogs.com/xujunkai/p/12878455.html
Copyright © 2020-2023  润新知