go语言之map

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\n",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\n",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"))
}