Golang Map:引用類型,哈希表。一堆鍵值對的未排序集合。
鍵必須是支持相等運算符 ("=="、"!=") 類型, 如 number、string、 pointer、array、struct,以及對應的 interface。值可以是任意類型,沒有限制。
map聲明
聲明map的語法如下
~~~
var map變量名 map[key] value
其中:key為鍵類型,value為值類型
例如:value不僅可以是標注數據類型,也可以是自定義數據類型
~~~
~~~
package main
type personInfo struct {
ID string
Name string
Address string
}
var m1 map[string]int
var m2 map[string]personInfo
func main() {}
~~~
map初始化
直接初始化(創建)
~~~
package main
import (
"fmt"
)
var m1 map[string]float32 = map[string]float32{"C": 5, "Go": 4.5, "Python": 4.5, "C++": 2}
func main() {
m2 := map[string]float32{"C": 5, "Go": 4.5, "Python": 4.5, "C++": 2}
m3 := map[int]struct {
name string
age int
}{
1: {"user1", 10}, // 可省略元素類型。
2: {"user2", 20},
}
fmt.Printf("全局變量 map m1 : %v\n", m1)
fmt.Printf("局部變量 map m2 : %v\n", m2)
fmt.Printf("局部變量 map m3 : %v\n", m3)
}
~~~
輸出結果:
~~~
全局變量 map m1 : map[Python:4.5 C++:2 C:5 Go:4.5]
局部變量 map m2 : map[C++:2 C:5 Go:4.5 Python:4.5]
局部變量 map m3 : map[2:{user2 20} 1:{user1 10}]
注意:由m1,m2可以看出map是鍵值對的無序集合。
~~~
通過make初始化(創建)
Go語言提供的內置函數make()可以用于靈活地創建map。
預先給 make 函數一個合理元素數量參數,有助于提升性能。因為事先申請一大塊內存,可避免后續操作時頻繁擴張。
~~~
package main
import (
"fmt"
)
func main() {
// 創建了一個鍵類型為string,值類型為int的map
m1 := make(map[string]int)
// 也可以選擇是否在創建時指定該map的初始存儲能力,如創建了一個初始存儲能力為5的map
m2 := make(map[string]int, 5)
m1["a"] = 1
m2["b"] = 2
fmt.Printf("局部變量 map m1 : %v\n", m1)
fmt.Printf("局部變量 map m2 : %v\n", m2)
}
~~~
輸出結果:
~~~
局部變量 map m1 : map[a:1]
局部變量 map m2 : map[b:2]
~~~
map操作:
插入、更新、查找、刪除、判斷是否存在、求長度
~~~
package main
import (
"fmt"
)
func main() {
m := map[string]string{"key0": "value0", "key1": "value1"}
fmt.Printf("map m : %v\n", m)
//map插入
m["key2"] = "value2"
fmt.Printf("inserted map m : %v\n", m)
//map修改
m["key0"] = "hello world!"
fmt.Printf("updated map m : %v\n", m)
//map查找
val, ok := m["key0"]
if ok {
fmt.Printf("map's key0 is %v\n", val)
}
// 長度:獲取鍵值對數量。
len := len(m)
fmt.Printf("map's len is %v\n", len)
// cap 無效,error
// cap := cap(m) //invalid argument m (type map[string]string) for cap
// fmt.Printf("map's cap is %v\n", cap)
// 判斷 key 是否存在。
if val, ok = m["key"]; !ok {
fmt.Println("map's key is not existence")
}
// 刪除,如果 key 不存在,不會出錯。
if val, ok = m["key1"]; ok {
delete(m, "key1")
fmt.Printf("deleted key1 map m : %v\n", m)
}
}
~~~
輸出結果:
~~~
map m : map[key0:value0 key1:value1]
inserted map m : map[key0:value0 key1:value1 key2:value2]
updated map m : map[key0:hello world! key1:value1 key2:value2]
map's key0 is hello world!
map's len is 3
map's key is not existence
deleted key1 map m : map[key0:hello world! key2:value2]
~~~
map遍歷:
不能保證迭代返回次序,通常是隨機結果,具體和版本實現有關。
~~~
package main
import (
"fmt"
)
func main() {
m := make(map[int]int)
for i := 0; i < 10; i++ {
m[i] = i
}
fmt.Println(m)
fmt.Println(m)
for j := 0; j < 2; j++ {
fmt.Println("---------------------")
for k, v := range m {
fmt.Printf("key -> value : %v -> %v\n", k, v)
}
}
}
~~~
輸出結果:
~~~
map[6:6 8:8 2:2 1:1 3:3 4:4 5:5 7:7 9:9 0:0]
map[2:2 6:6 8:8 5:5 7:7 9:9 0:0 1:1 3:3 4:4]
---------------------
key -> value : 2 -> 2
key -> value : 6 -> 6
key -> value : 8 -> 8
key -> value : 9 -> 9
key -> value : 0 -> 0
key -> value : 1 -> 1
key -> value : 3 -> 3
key -> value : 4 -> 4
key -> value : 5 -> 5
key -> value : 7 -> 7
---------------------
key -> value : 8 -> 8
key -> value : 2 -> 2
key -> value : 6 -> 6
key -> value : 3 -> 3
key -> value : 4 -> 4
key -> value : 5 -> 5
key -> value : 7 -> 7
key -> value : 9 -> 9
key -> value : 0 -> 0
key -> value : 1 -> 1
~~~
slice與map操作(slice of map)
~~~
package main
import (
"fmt"
)
func main() {
items := make([]map[int]int, 5)
for i := 0; i < 5; i++ {
items[i] = make(map[int]int)
}
items[0][0] = 0
items[1][2] = 3
fmt.Println(items)
}
~~~
輸出結果:
~~~
[map[0:0] map[2:3] map[] map[] map[]]
~~~
map排序:
先獲取所有key,把key進行排序,再按照排序好的key,進行遍歷。
~~~
package main
import (
"fmt"
"sort"
)
func main() {
m := map[string]string{"q": "q", "w": "w", "e": "e", "r": "r", "t": "t", "y": "y"}
var slice []string
for k, _ := range m {
slice = append(slice, k)
}
fmt.Printf("clise string is : %v\n", slice)
sort.Strings(slice[:])
fmt.Printf("sorted slice string is : %v\n", slice)
for _, v := range slice {
fmt.Println(m[v])
}
}
~~~
輸出結果:
~~~
clise string is : [e r t y q w]
sorted slice string is : [e q r t w y]
e
q
r
t
w
y
~~~
map反轉:
初始化另外一個map,把key、value互換即可.
~~~
package main
import (
"fmt"
)
func main() {
m := map[int]string{1: "x", 2: "w", 3: "e", 4: "r", 5: "t", 6: "y"}
fmt.Println(m)
m_rev := make(map[string]int)
for k, v := range m {
m_rev[v] = k
}
fmt.Println(m_rev)
}
~~~
輸出結果:
~~~
map[3:e 4:r 5:t 6:y 1:x 2:w]
map[r:4 t:5 y:6 x:1 w:2 e:3]
~~~
從 map 中取回的是一個 value 臨時復制品,對其成員的修改是沒有任何意義的。
~~~
package main
import (
"fmt"
)
func main() {
m := map[int]string{1: "x", 2: "w"}
fmt.Println(m)
for k, v := range m {
m[k] = v + v //修改map的值
v = v + "copy" //臨時復制品,修改無效
}
fmt.Println(m)
}
~~~
輸出結果:
~~~
~~~
容器和結構體(map and struct)
~~~
語法比較:
map[type]struct
map[type]*struct
~~~
~~~
package main
import "fmt"
func main() {
type user struct{ name string }
/*
當 map 因擴張而重新哈希時,各鍵值項存儲位置都會發生改變。
因此,map 被設計成 not addressable。
類似 m[1].name 這種期望透過原 value 指針修改成員的行為自然會被禁 。
*/
m := map[int]user{ //
1: {"user1"},
}
// m[1].name = "Tom"
// ./main.go:16:12: cannot assign to struct field m[1].name in map
fmt.Println(m)
// 正確做法是完整替換 value 或使用指針。
u := m[1]
u.name = "Tom"
m[1] = u // 替換 value。
m2 := map[int]*user{
1: &user{"user1"},
}
m2[1].name = "Jack" // 返回的是指針復制品。透過指針修改原對象是允許的。
fmt.Println(m2)
}
~~~
輸出結果:
~~~
map[1:{user1}]
map[1:0xc42000e1e0]
~~~
可以在迭代時安全刪除鍵值。但如果期間有新增操作,那么就不知道會有什么意外了。
~~~
package main
import "fmt"
func main() {
for i := 0; i < 5; i++ {
m := map[int]string{
0: "a", 1: "a", 2: "a", 3: "a", 4: "a",
5: "a", 6: "a", 7: "a", 8: "a", 9: "a",
}
for k := range m {
m[k+k] = "x"
delete(m, k)
}
fmt.Println(m)
}
}
~~~
輸出:
//每次輸出都會變化
~~~
map[36:x 28:x 32:x 2:x 8:x 10:x 12:x]
map[12:x 6:x 16:x 28:x 4:x 10:x 72:x]
map[12:x 14:x 16:x 18:x 20:x]
map[18:x 10:x 14:x 4:x 6:x 16:x 24:x]
map[12:x 16:x 4:x 40:x 14:x 18:x]
~~~
- 序言
- 目錄
- 環境搭建
- Linux搭建golang環境
- Windows搭建golang環境
- Mac搭建golang環境
- Go 環境變量
- 編輯器
- vs code
- Mac 安裝vs code
- Windows 安裝vs code
- vim編輯器
- 介紹
- 1.Go語言的主要特征
- 2.golang內置類型和函數
- 3.init函數和main函數
- 4.包
- 1.工作空間
- 2.源文件
- 3.包結構
- 4.文檔
- 5.編寫 Hello World
- 6.Go語言 “ _ ”(下劃線)
- 7.運算符
- 8.命令
- 類型
- 1.變量
- 2.常量
- 3.基本類型
- 1.基本類型介紹
- 2.字符串String
- 3.數組Array
- 4.類型轉換
- 4.引用類型
- 1.引用類型介紹
- 2.切片Slice
- 3.容器Map
- 4.管道Channel
- 5.指針
- 6.自定義類型Struct
- 流程控制
- 1.條件語句(if)
- 2.條件語句 (switch)
- 3.條件語句 (select)
- 4.循環語句 (for)
- 5.循環語句 (range)
- 6.循環控制Goto、Break、Continue
- 函數
- 1.函數定義
- 2.參數
- 3.返回值
- 4.匿名函數
- 5.閉包、遞歸
- 6.延遲調用 (defer)
- 7.異常處理
- 8.單元測試
- 壓力測試
- 方法
- 1.方法定義
- 2.匿名字段
- 3.方法集
- 4.表達式
- 5.自定義error
- 接口
- 1.接口定義
- 2.執行機制
- 3.接口轉換
- 4.接口技巧
- 面向對象特性
- 并發
- 1.并發介紹
- 2.Goroutine
- 3.Chan
- 4.WaitGroup
- 5.Context
- 應用
- 反射reflection
- 1.獲取基本類型
- 2.獲取結構體
- 3.Elem反射操作基本類型
- 4.反射調用結構體方法
- 5.Elem反射操作結構體
- 6.Elem反射獲取tag
- 7.應用
- json協議
- 1.結構體轉json
- 2.map轉json
- 3.int轉json
- 4.slice轉json
- 5.json反序列化為結構體
- 6.json反序列化為map
- 終端讀取
- 1.鍵盤(控制臺)輸入fmt
- 2.命令行參數os.Args
- 3.命令行參數flag
- 文件操作
- 1.文件創建
- 2.文件寫入
- 3.文件讀取
- 4.文件刪除
- 5.壓縮文件讀寫
- 6.判斷文件或文件夾是否存在
- 7.從一個文件拷貝到另一個文件
- 8.寫入內容到Excel
- 9.日志(log)文件
- server服務
- 1.服務端
- 2.客戶端
- 3.tcp獲取網頁數據
- 4.http初識-瀏覽器訪問服務器
- 5.客戶端訪問服務器
- 6.訪問延遲處理
- 7.form表單提交
- web模板
- 1.渲染終端
- 2.渲染瀏覽器
- 3.渲染存儲文件
- 4.自定義io.Writer渲染
- 5.模板語法
- 時間處理
- 1.格式化
- 2.運行時間
- 3.定時器
- 鎖機制
- 互斥鎖
- 讀寫鎖
- 性能比較
- sync.Map
- 原子操作
- 1.原子增(減)值
- 2.比較并交換
- 3.導入、導出、交換
- 加密解密
- 1.md5
- 2.base64
- 3.sha
- 4.hmac
- 常用算法
- 1.冒泡排序
- 2.選擇排序
- 3.快速排序
- 4.插入排序
- 5.睡眠排序
- 限流器
- 日志包
- 日志框架logrus
- 隨機數驗證碼
- 生成指定位數的隨機數
- 生成圖形驗證碼
- 編碼格式轉換
- UTF-8與GBK
- 解決中文亂碼
- 設計模式
- 創建型模式
- 單例模式
- singleton.go
- singleton_test.go
- 抽象工廠模式
- abstractfactory.go
- abstractfactory_test.go
- 工廠方法模式
- factorymethod.go
- factorymethod_test.go
- 原型模式
- prototype.go
- prototype_test.go
- 生成器模式
- builder.go
- builder_test.go
- 結構型模式
- 適配器模式
- adapter.go
- adapter_test.go
- 橋接模式
- bridge.go
- bridge_test.go
- 合成/組合模式
- composite.go
- composite_test.go
- 裝飾模式
- decoretor.go
- decorator_test.go
- 外觀模式
- facade.go
- facade_test.go
- 享元模式
- flyweight.go
- flyweight_test.go
- 代理模式
- proxy.go
- proxy_test.go
- 行為型模式
- 職責鏈模式
- chainofresponsibility.go
- chainofresponsibility_test.go
- 命令模式
- command.go
- command_test.go
- 解釋器模式
- interpreter.go
- interperter_test.go
- 迭代器模式
- iterator.go
- iterator_test.go
- 中介者模式
- mediator.go
- mediator_test.go
- 備忘錄模式
- memento.go
- memento_test.go
- 觀察者模式
- observer.go
- observer_test.go
- 狀態模式
- state.go
- state_test.go
- 策略模式
- strategy.go
- strategy_test.go
- 模板模式
- templatemethod.go
- templatemethod_test.go
- 訪問者模式
- visitor.go
- visitor_test.go
- 數據庫操作
- golang操作MySQL
- 1.mysql使用
- 2.insert操作
- 3.select 操作
- 4.update 操作
- 5.delete 操作
- 6.MySQL事務
- golang操作Redis
- 1.redis介紹
- 2.golang鏈接redis
- 3.String類型 Set、Get操作
- 4.String 批量操作
- 5.設置過期時間
- 6.list隊列操作
- 7.Hash表
- 8.Redis連接池
- 其它Redis包
- go-redis/redis包
- 安裝介紹
- String 操作
- List操作
- Set操作
- Hash操作
- golang操作ETCD
- 1.etcd介紹
- 2.鏈接etcd
- 3.etcd存取
- 4.etcd監聽Watch
- golang操作kafka
- 1.kafka介紹
- 2.寫入kafka
- 3.kafka消費
- golang操作ElasticSearch
- 1.ElasticSearch介紹
- 2.kibana介紹
- 3.寫入ElasticSearch
- NSQ
- 安裝
- 生產者
- 消費者
- zookeeper
- 基本操作測試
- 簡單的分布式server
- Zookeeper命令行使用
- GORM
- gorm介紹
- gorm查詢
- gorm更新
- gorm刪除
- gorm錯誤處理
- gorm事務
- sql構建
- gorm 用法介紹
- Go操作memcached
- beego框架
- 1.beego框架環境搭建
- 2.參數配置
- 1.默認參數
- 2.自定義配置
- 3.config包使用
- 3.路由設置
- 1.自動匹配
- 2.固定路由
- 3.正則路由
- 4.注解路由
- 5.namespace
- 4.多種數據格式輸出
- 1.直接輸出字符串
- 2.模板數據輸出
- 3.json格式數據輸出
- 4.xml格式數據輸出
- 5.jsonp調用
- 5.模板處理
- 1.模板語法
- 2.基本函數
- 3.模板函數
- 6.請求處理
- 1.GET請求
- 2.POST請求
- 3.文件上傳
- 7.表單驗證
- 1.表單驗證
- 2.定制錯誤信息
- 3.struct tag 驗證
- 4.XSRF過濾
- 8.靜態文件處理
- 1.layout設計
- 9.日志處理
- 1.日志處理
- 2.logs 模塊
- 10.會話控制
- 1.會話控制
- 2.session 包使用
- 11.ORM 使用
- 1.鏈接數據庫
- 2. CRUD 操作
- 3.原生 SQL 操作
- 4.構造查詢
- 5.事務處理
- 6.自動建表
- 12.beego 驗證碼
- 1.驗證碼插件
- 2.驗證碼使用
- beego admin
- 1.admin安裝
- 2.admin開發
- beego 熱升級
- beego實現https
- gin框架
- 安裝使用
- 路由設置
- 模板處理
- 文件上傳
- gin框架中文文檔
- gin錯誤總結
- 項目
- 秒殺項目
- 日志收集
- 面試題
- 面試題一
- 面試題二
- 錯題集
- Go語言陷阱和常見錯誤
- 常見語法錯誤
- 初級
- 中級
- 高級
- Go高級應用
- goim
- goim 啟動流程
- goim 工作流程
- goim 結構體
- gopush
- gopush工作流程
- gopush啟動流程
- gopush業務流程
- gopush應用
- gopush新添功能
- gopush壓力測試
- 壓測注意事項
- rpc
- HTTP RPC
- TCP RPC
- JSON RPC
- 常見RPC開源框架
- pprof
- pprof介紹
- pprof應用
- 使用pprof及Go 程序的性能優化
- 封裝 websocket
- cgo
- Golang GC
- 查看程序運行過程中的GC信息
- 定位gc問題所在
- Go語言 demo
- 用Go語言計算一個人的年齡,生肖,星座
- 超簡易Go語言實現的留言板代碼
- 信號處理模塊,可用于在線加載配置,配置動態加載的信號為SIGHUP
- 陽歷和陰歷相互轉化的工具類 golang版本
- 錯誤總結
- 網絡編程
- 網絡編程http
- 網絡編程tcp
- Http請求
- Go語言必知的90個知識點
- 第三方庫應用
- cli應用
- Cobra
- 圖表庫
- go-echarts
- 開源IM
- im_service
- 機器學習庫
- Tensorflow
- 生成二維碼
- skip2/go-qrcode生成二維碼
- boombuler/barcode生成二維碼
- tuotoo/qrcode識別二維碼
- 日志庫
- 定時任務
- robfig/cron
- jasonlvhit/gocron
- 拼多多開放平臺 SDK
- Go編譯
- 跨平臺交叉編譯
- 一問一答
- 一問一答(一)
- 為什么 Go 標準庫中有些函數只有簽名,沒有函數體?
- Go開發的應用
- etcd
- k8s
- Caddy
- nsq
- Docker
- web框架