go语言的map就相当于python的dict
1、map的初始化
//创建map
//k的类型是int，v的类型是string
var test25_1 map[int]string
fmt.Println(test25_1)
//map[]
fmt.Println(test25_1 == nil)
//true
test25_2 := map[int]string{}
test25_3 := make(map[int]string)
fmt.Println(test25_2)
//map[]
fmt.Println(test25_3)
//map[]
//初始化一个有容量的map
test25_4 := make(map[int]string,10)
fmt.Println(test25_4)
//map[]
//初始化map
2、map的初始化
//定义的同时初始化
var test25_5 map[int] string = map[int]string{1:"test1",2:"test2"}
fmt.Println(test25_5)
//map[1:test1 2:test2]
//自动推倒类型
var test25_6 = map[int]string{3:"test3",4:"test4"}
fmt.Println(test25_6)
//map[3:test3 4:test4]
3、map的键值操作，增和改
//键值操作 //修改 test25_6[3] = "test333" fmt.Println(test25_6) //map[3:test333 4:test4] //增加 test25_6[5] = "test5" fmt.Println(test25_6) //map[3:test333 4:test4 5:test5]
4、map的遍历操作
//map的遍历操作
for k,v := range test25_6{
fmt.Printf("k值为%d,v值为%s
",k,v)
}
//k值为5,v值为test5
//k值为3,v值为test333
//k值为4,v值为test
for k:= range test25_6{
fmt.Printf("k值为%d,v值为%s
",k,test25_6[k])
}
//k值为3,v值为test333
//k值为4,v值为test4
//k值为5,v值为test5
5、判断map是否存在某个k
//判断某个k对应的v是否存在 //value为k对应的值，ok为是否存在 value,ok := test25_6[3] fmt.Println(value,ok) //test333 true value1,ok1 := test25_6[7] fmt.Println(value1,ok1) //false
6、删除map中的某个k
fmt.Println(test25_6) //map[3:test333 4:test4 5:test5] delete(test25_6,3) fmt.Println(test25_6) //map[4:test4 5:test5]
Go 语言Map(集合)
Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。
Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。
定义 Map
可以使用内建函数 make 也可以使用 map 关键字来定义 Map:
/* 声明变量，默认 map 是 nil */ var map_variable map[key_data_type]value_data_type /* 使用 make 函数 */ map_variable := make(map[key_data_type]value_data_type)
如果不初始化 map，那么就会创建一个 nil map。nil map 不能用来存放键值对
实例
下面实例演示了创建和使用map:
package main
import "fmt"
func main() {
var countryCapitalMap map[string]string /*创建集合 */
countryCapitalMap = make(map[string]string)
/* map插入key - value对,各个国家对应的首都 */
countryCapitalMap [ "France" ] = "巴黎"
countryCapitalMap [ "Italy" ] = "罗马"
countryCapitalMap [ "Japan" ] = "东京"
countryCapitalMap [ "India " ] = "新德里"
/*使用键输出地图值 */
for country := range countryCapitalMap {
fmt.Println(country, "首都是", countryCapitalMap [country])
}
/*查看元素在集合中是否存在 */
capital, ok := countryCapitalMap [ "American" ] /*如果确定是真实的,则存在,否则不存在 */
/*fmt.Println(capital) */
/*fmt.Println(ok) */
if (ok) {
fmt.Println("American 的首都是", capital)
} else {
fmt.Println("American 的首都不存在")
}
}
以上实例运行结果为：
France 首都是 巴黎 Italy 首都是 罗马 Japan 首都是 东京 India 首都是 新德里 American 的首都不存在
delete() 函数
delete() 函数用于删除集合的元素, 参数为 map 和其对应的 key。实例如下：
package main
import "fmt"
func main() {
/* 创建map */
countryCapitalMap := map[string]string{"France": "Paris", "Italy": "Rome", "Japan": "Tokyo", "India": "New delhi"}
fmt.Println("原始地图")
/* 打印地图 */
for country := range countryCapitalMap {
fmt.Println(country, "首都是", countryCapitalMap [ country ])
}
/*删除元素*/ delete(countryCapitalMap, "France")
fmt.Println("法国条目被删除")
fmt.Println("删除元素后地图")
/*打印地图*/
for country := range countryCapitalMap {
fmt.Println(country, "首都是", countryCapitalMap [ country ])
}
}
以上实例运行结果为：
原始地图 India 首都是 New delhi France 首都是 Paris Italy 首都是 Rome Japan 首都是 Tokyo 法国条目被删除 删除元素后地图 Italy 首都是 Rome Japan 首都是 Tokyo India 首都是 New delhi
基于 go 实现简单 HashMap，暂未做 key 值的校验。
package main
import (
"fmt"
)
type HashMap struct {
key string
value string
hashCode int
next *HashMap
}
var table [16](*HashMap)
func initTable() {
for i := range table{
table[i] = &HashMap{"","",i,nil}
}
}
func getInstance() [16](*HashMap){
if(table[0] == nil){
initTable()
}
return table
}
func genHashCode(k string) int{
if len(k) == 0{
return 0
}
var hashCode int = 0
var lastIndex int = len(k) - 1
for i := range k {
if i == lastIndex {
hashCode += int(k[i])
break
}
hashCode += (hashCode + int(k[i]))*31
}
return hashCode
}
func indexTable(hashCode int) int{
return hashCode%16
}
func indexNode(hashCode int) int {
return hashCode>>4
}
func put(k string, v string) string {
var hashCode = genHashCode(k)
var thisNode = HashMap{k,v,hashCode,nil}
var tableIndex = indexTable(hashCode)
var nodeIndex = indexNode(hashCode)
var headPtr [16](*HashMap) = getInstance()
var headNode = headPtr[tableIndex]
if (*headNode).key == "" {
*headNode = thisNode
return ""
}
var lastNode *HashMap = headNode
var nextNode *HashMap = (*headNode).next
for nextNode != nil && (indexNode((*nextNode).hashCode) < nodeIndex){
lastNode = nextNode
nextNode = (*nextNode).next
}
if (*lastNode).hashCode == thisNode.hashCode {
var oldValue string = lastNode.value
lastNode.value = thisNode.value
return oldValue
}
if lastNode.hashCode < thisNode.hashCode {
lastNode.next = &thisNode
}
if nextNode != nil {
thisNode.next = nextNode
}
return ""
}
func get(k string) string {
var hashCode = genHashCode(k)
var tableIndex = indexTable(hashCode)
var headPtr [16](*HashMap) = getInstance()
var node *HashMap = headPtr[tableIndex]
if (*node).key == k{
return (*node).value
}
for (*node).next != nil {
if k == (*node).key {
return (*node).value
}
node = (*node).next
}
return ""
}
//examples
func main() {
getInstance()
put("a","a_put")
put("b","b_put")
fmt.Println(get("a"))
fmt.Println(get("b"))
put("p","p_put")
fmt.Println(get("p"))
}