#### 一、Map具有集合的属性，使用的是哈希表，必须可以比较相等的类型才能作为map的key，即slice,map,function这些内置类型是不能作为key的，struct类型在不包含以上字段的时候，是可以作为key的。
#### 二、作为数据结构，满足增删查改：
```
package basic
import (
"fmt"
"log"
)
func main() {
basicMap := make(map[int]string)
fmt.Println("Basic map trive:")
basicMap = map[int]string{
1: "Ace",
2: "Luffy",
3: "Iilidan",
4: "Sean",
5: "Chan",
}
//验证map的无序性
/*for i := 0; i < 10; i++ {
mapPrint(basicMap)
fmt.Println()
}*/
mapPrint(basicMap)
//Add element into map
fmt.Println()
addElement2Map(basicMap, 6, "Qin")
fmt.Println("Add Element to slice")
mapPrint(basicMap)
//如果存在元素增加
fmt.Println("If elemnt exist")
fmt.Println()
addElement2Map(basicMap, 5, "Burning")
mapPrint(basicMap)
fmt.Println()
//Delete element
fmt.Println("Delete element:")
if deleteElement(basicMap, 3) {
mapPrint(basicMap)
} else {
log.Fatal("Delete element fail")
}
fmt.Println()
//Change element
fmt.Println("Change element:")
if !changeElement(basicMap, 5, "Tang") {
log.Fatal("Change element fail")
}
mapPrint(basicMap)
fmt.Println()
}
func mapPrint(m map[int]string) {
for k, v := range m {
fmt.Print(k, "\t", v, "\t")
}
}
func findElement(m map[int]string, i int) bool {
if _, ok := m[i]; !ok {
return false
}
return true
}
func addElement2Map(m map[int]string, k int, v string) {
if !findElement(m, k) {
m[k] = v
}
}
func deleteElement(m map[int]string, k int) bool {
if findElement(m, k) {
delete(m, k)
return true
}
return false
}
func changeElement(m map[int]string, k int, v string) bool {
if !findElement(m, k) {
return false
}
m[k] = v
return true
}
```
#### 三、因为map具有无序性，有的时候我们需要对map进行排序，对map的排序又分为对key的排序和对value的排序：
##### （一）如果遇到的map.key是int的（或可排序的类型），我们直接取出map.key存到一个slice中，对slice进行sort，然后通过key-->查找value即可
```
package main
import (
"fmt"
"sort"
)
func main() {
m := make(map[int]string)
m[0] = "a"
m[1] = "b"
m[2] = "c"
m[3] = "d"
m[4] = "e"
m[5] = "f"
m[6] = "g"
fmt.Println("\t排序之前")
fmt.Printf("\tkey\tvalue\n")
for k, v := range m {
fmt.Printf("\t%d\t%s\n", k, v)
}
var keys []int
for k:=range m {
keys=append(keys,k)
}
sort.Ints(keys)
fmt.Println("\t排序之后")
fmt.Printf("\tkey\tvalue\n")
for k:= range keys{
fmt.Printf("\t%d\t%s\n", k, m[k])
}
}
```
##### （二）对value的排序较key的排序难一点，因为排序的思路不能利用value-->key的查找方式，想到的第一种方法是再创建一个map，并把原map的key和value颠倒后存入，这样做会有一个bug：map.key是唯一的，但是value不是唯一的，我们存入的时候原来的数据就必定会出现“覆盖”的情况，故此法行不通。调换一下思路：既然map有唯一性，那我们利用一个没有唯一性的数据结构struct来存入就行了，然后再对value进行排序，取值的时候就抛弃了原map，利用struct来取值
```
package main
import (
"fmt"
"sort"
)
func main() {
m := make(map[string]int)
m["a"] = 100
m["b"] = 95
m["c"] = 98
m["d"] = 94
m["e"] = 99
m["f"] = 91
m["g"] = 86
m["h"] = 93
m["i"] = 70
fmt.Printf("排序前\n")
for k, v := range m {
fmt.Printf("\t%s\t%d\n", k, v)
}
type kv struct {
key string
value int
}
var temp []kv
for k,v := range m{
temp = append(temp,kv{k,v})
}
sort.Slice(temp, func(i, j int) bool {
return temp[i].value>=temp[j].value //升序排序
})
fmt.Printf("排序后\n")
for _,kv := range temp {
fmt.Printf("\t%s\t%d\n",kv.key,kv.value)
}
}
```
**这里有一段关键的代码**
```
sort.Slice(temp, func(i, j int) bool {
return temp[i].value>=temp[j].value
})
```
明显看出，这是一个内置的函数，包含在sort包中
```
\\源码
func Slice(slice interface{}, less func(i, j int) bool) {
rv := reflect.ValueOf(slice)
swap := reflect.Swapper(slice)
length := rv.Len()
quickSort_func(lessSwap{less, swap}, 0, length, maxDepth(length))
}
```
Slice sorts the provided slice given the provided less function.The sort is not guaranteed to be stable. For a stable sort, use SliceStable. The function panics if the provided interface is not a slice.Slice
对给定较少函数的给定片进行排序。这种排序并不能保证是稳定的。对于稳定的排序，使用SliceStable。如果所提供的接口不是片，函数就会崩溃。
#### 二、map例题“寻找最长字串”
**题目描述**：在给定的字符串中找出最大不重复的字串，例如：abcabc最大不重复字串是3即abc，[题目来源](https://leetcode.com/problems/longest-substring-without-repeating-characters/description//)
**解题描述：**
在一个map中lastOccurred，以字母作为key（唯一性），以key存在的最后一个字母的位置作为value，对于每一个字母x可能存在:
a.lastOccurred中不存在x，即lastOccurred[x] = 0
b.lastOccurred[x]的value小于start，即lastOccurred[x] < start
c.lastOccurred[x]的value大于等于start，即lastOccurred[x] <= start
**a,b两种情况我们不需要做处理操作，对于c情况，我们就需要更新start**
1.lastOccurred[x]不存在或者<start-->无需操作
2.lastOccurred[x]>=start -->更新start
3.更新lastOccurred[x],更新maxLength
有疑问加站长微信联系（非本文作者））
