Arrays（数组）

类型 [n]T 表示拥有 n 个 T 类型的值的数组.

表达式：var a [10]int

会将变量 a 声明为拥有 10 个整数的数组.

数组的长度是其类型的一部分，因此无法调整数组的大小。这似乎是限制性的

package main

import "fmt"

func main() {
	var a [2]string
	a[0] = "Hello"
	a[1] = "World"
	fmt.Println(a[0], a[1])
	fmt.Println(a)

	primes := [6]int{2, 3, 5, 7, 11, 13}
	fmt.Println(primes)
}

Slices（切片）

数组具有固定大小； 而切片则为数组元素提供动态大小的、灵活的视角。

切片的零值是 nil 一个 nil 切片的长度和容量为 0，并且没有底层数组。切片可以包含任何类型，包括其他切片。

切片不存储任何数据，它只是描述底层数组的一部分，更改切片的元素会修改其底层数组的相应元素，共享相同底层数组的其他切片将看到这些更改。

在实践中，切片比数组更常见。

类型 []T 表示一个元素类型为 T 的切片。通过指定两个索引（下限和上限）来形成切片，并用冒号分隔。

a[low : high]

这将选择一个包含第一个元素但不包括最后一个元素的半开范围.

以下表达式创建一个包含 a 的 1 到 3 元素的切片.

a[1:4]

package main

import "fmt"

func main() {
	primes := [6]int{2, 3, 5, 7, 11, 13}

	var s []int = primes[1:4]
	fmt.Println(s)
}

我认为从表现上显示：和Java中的subString()类似，只是Java中subString()方法是针对字符串进行截取，而Go中的切片是针对数组进行截取。

Slice literals（切片字面量）

切片字面量就像没有长度的数组字面量。这是一个数组字面量:

[3]bool{true, true, false}

这将创建与上面相同的数组，然后构建一个引用它的切片

[]bool{true, true, false}

package main

import "fmt"

func main() {
	q := []int{2, 3, 5, 7, 11, 13}
	fmt.Println(q)

	r := []bool{true, false, true, true, false, true}
	fmt.Println(r)

	s := []struct {
		i int
		b bool
	}{
		{2, true},
		{3, false},
		{5, true},
		{7, true},
		{11, false},
		{13, true},
	}
	fmt.Println(s)
}

切片默认值

切片时，可以省略上限或下限以使用它们的默认值。

下限默认为零，上限默认为切片长度。

对于数组

var a [10]int

这些切片表达式是等价的:

a[0:10]
a[:10]
a[0:]
a[:]

package main

import "fmt"

func main() {
	s := []int{2, 3, 5, 7, 11, 13}

	s = s[1:4]
	fmt.Println(s)

	s = s[:2]
	fmt.Println(s)

	s = s[1:]
	fmt.Println(s)
}

切片长度和容量

切片同时具有 长度 和 容量 .

切片的长度是它包含的元素数.

切片的容量是底层数组中元素的数量，从切片中的第一个元素开始计数.

切片 s 的长度和容量可通过表达式 len(s) 和 cap(s) 来获取.

如果切片具有足够的容量，则可以通过重新切片来延长切片的长度。

用 make 创建切片

可以使用内置 make 函数创建切片；这是创建动态大小数组的方式.

make 函数分配一个归零数组并返回一个引用该数组的切片:

a := make([]int, 5)  // len(a)=5

要指定容量，请将第三个参数传递给 make:

b := make([]int, 0, 5) // len(b)=0, cap(b)=5

b = b[:cap(b)] // len(b)=5, cap(b)=5
b = b[1:]      // len(b)=4, cap(b)=4

切片追加元素

将新元素附加到切片是很常见的，因此 Go 提供了一个内置 append 函数。

func append(s []T, vs ...T) []T

append 的第一个参数 s 是一个元素类型为T 的切片，其余类型为 T 的值将会追加到该切片的末尾.

append 的结果是一个包含原切片所有元素加上新添加元素的切片.

如果 s 的底层数组太小而无法容纳所有给定值，则将分配一个更大的数组。返回的切片将指向新分配的数组。

package main

import "fmt"

func main() {
	var s []int
	printSlice(s)

	// append works on nil slices.
	s = append(s, 0)
	printSlice(s)

	// The slice grows as needed.
	s = append(s, 1)
	printSlice(s)

	// We can add more than one element at a time.
	s = append(s, 2, 3, 4)
	printSlice(s)
}

func printSlice(s []int) {
	fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
}

Range

for 循环的 range 形式可遍历切片或映射.

当在切片上进行ranging时，每次迭代都会返回两个值。第一个是索引，第二个是该索引中元素的副本。可以通过赋值给 _ 来跳过索引或值.

for i, _ := range pow
for _, value := range pow

如果只需要索引，则可以省略第二个变量。

for i := range pow

package main

import "fmt"

func main() {
	pow := make([]int, 10)
	for i := range pow {
		pow[i] = 1 << uint(i) // == 2**i
	}
	for _, value := range pow {
		fmt.Printf("%d\n", value)
	}
}

Map

Map 是一种无序的键值对的集合。通过 key 来快速检索数据，key 类似于索引，指向数据的值。

map将键映射到值。map的零值是 nil 

nil map 没有键，也不能添加键。

make 函数返回给定类型的map，该map已初始化并可供使用

Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，遍历 Map 时返回的键值对的顺序是不确定的。

定义 Map

可以使用内建函数 make 或使用 map 关键字来定义 Map:

/* 使用 make 函数 */
map_variable := make(map[KeyType]ValueType, initialCapacity)

Map字面量类似于结构字面量，但需要键。如果顶级类型只是一个类型名称，则可以从字面量的元素中省略它.

package main

import "fmt"

type Vertex struct {
	Lat, Long float64
}

var m map[string]Vertex

var m2 = map[string]Vertex{
	"Bell Labs": Vertex{
		40.68433, -74.39967,
	},
	"Google": {
		37.42202, -122.08408,
	},
}

func main() {
	m = make(map[string]Vertex)
	m["Bell Labs"] = Vertex{
		40.68433, -74.39967,
	}
	fmt.Println(m["Bell Labs"])
	
	var m = map[string]int64{}
	fmt.Println(m)
	m["aa"] = 1
	m["bb"] = 2
	m["bb"] = 3
	fmt.Println(m)
	fmt.Println(m2)
}

map 容量

和数组不同，map 可以根据新增的 key-value 动态的伸缩，因此它不存在固定长度或者最大限制，但是也可以选择标明 map 的初始容量 capacity

格式：make(map[keytype]valuetype, cap)

当 map 增长到容量上限的时候，如果再增加新的 key-value，map 的大小会自动加 1，所以出于性能的考虑，对于大的 map 或者会快速扩张的 map，即使只是大概知道容量，也最好先标明。

修改 Maps

• 在 map m 中插入或更新元素： m[key] = elem
• 检索一个元素：elem = m[key] 如果 key 不在map中，则 elem 是map元素类型的零值。
• 删除一个元素：delete(m, key)
• 通过双赋值检测某个键是否存在：elem, ok = m[key]如果 key 在 m 中，ok 为 true ；否则，ok 为 false

注意: 如果 elem 或 ok 尚未声明，您可以使用简短的声明形式：elem, ok := m[key]

用切片作为 map 的值

既然一个 key 只能对应一个 value，而 value 又是一个原始类型，那么如果一个 key 要对应多个值怎么办？例如，当我们要处理 unix 机器上的所有进程，以父进程（pid 为整形）作为 key，所有的子进程（以所有子进程的 pid 组成的切片）作为 value。通过将 value 定义为 []int 类型或者其他类型的切片，就可以优雅的解决这个问题，示例代码如下所示：

mp1 := make(map[int][]int)mp2 := make(map[int]*[]int)

Map 的长度

// 获取 Map 的长度
len := len(m)

遍历map

map 的遍历过程使用 for range 循环完成，代码如下：

scene := make(map[string]int)
scene["route"] = 66
scene["brazil"] = 4
scene["china"] = 960
for k, v := range scene {
    fmt.Println(k, v)
}

遍历对于Go语言的很多对象来说都是差不多的，直接使用 for range 语法即可，遍历时，可以同时获得键和值，如只遍历值，可以使用的形式：for _, v := range scene {

将不需要的键使用，改为匿名变量形式。

for k := range scene {

排序map

sort.Strings 的作用是对传入的字符串切片进行字符串字符的升序排列

map删除key和value

使用 delete() 函数从 map 中删除键值对：delete(map, 键)

清空 map 中的所有元素

Go语言中并没有为 map 提供任何清空所有元素的函数、方法，清空 map 的唯一办法就是重新 make 一个新的 map，不用担心垃圾回收的效率，Go语言中的并行垃圾回收效率比写一个清空函数要高效的多。

sync.Map（在并发环境中使用的map）

Go语言中的 map 在并发情况下，只读是线程安全的，同时读写是线程不安全的。

需要并发读写时，一般的做法是加锁，但这样性能并不高，Go语言在 1.9 版本中提供了一种效率较高的并发安全的 sync.Map，sync.Map 和 map 不同，不是以语言原生形态提供，而是在 sync 包下的特殊结构。

sync.Map 有以下特性：

• 无须初始化，直接声明即可。
• sync.Map 不能使用 map 的方式进行取值和设置等操作，而是使用 sync.Map 的方法进行调用，Store 表示存储，Load 表示获取，Delete 表示删除。
• 使用 Range 配合一个回调函数进行遍历操作，通过回调函数返回内部遍历出来的值，Range 参数中回调函数的返回值在需要继续迭代遍历时，返回 true，终止迭代遍历时，返回 false。

package main
import (
      "fmt"
      "sync"
)
func main() {
    var scene sync.Map
    // 将键值对保存到sync.Map
    scene.Store("greece", 97)
    scene.Store("london", 100)
    scene.Store("egypt", 200)
    // 从sync.Map中根据键取值
    fmt.Println(scene.Load("london"))
    // 根据键删除对应的键值对
    scene.Delete("london")
    // 遍历所有sync.Map中的键值对
    scene.Range(func(k, v interface{}) bool {
        fmt.Println("iterate:", k, v)
        return true
    })
}

sync.Map 没有提供获取 map 数量的方法，替代方法是在获取 sync.Map 时遍历自行计算数量，sync.Map 为了保证并发安全有一些性能损失，因此在非并发情况下，使用 map 相比使用 sync.Map 会有更好的性能。

list（列表）

列表是一种非连续的存储容器，由多个节点组成，节点通过一些变量记录彼此之间的关系，列表有多种实现方法，如单链表、双链表等。

列表的原理可以这样理解：假设 A、B、C 三个人都有电话号码，如果 A 把号码告诉给 B，B 把号码告诉给 C，这个过程就建立了一个单链表结构，如下图所示。

如果在这个基础上，再从 C 开始将自己的号码告诉给自己所知道号码的主人，这样就形成了双链表结构，如下图所示。

那么如果需要获得所有人的号码，只需要从 A 或者 C 开始，要求他们将自己的号码发出来，然后再通知下一个人如此循环，这样就构成了一个列表遍历的过程。

如果 B 换号码了，他需要通知 A 和 C，将自己的号码移除，这个过程就是列表元素的删除操作，如下图所示。

在Go语言中，列表使用 container/list 包来实现，内部的实现原理是双链表，列表能够高效地进行任意位置的元素插入和删除操作。

初始化列表

list 的初始化有两种方法：分别是使用 New() 函数和 var 关键字声明，两种方法的初始化效果都是一致的。

• 通过 container/list 包的 New() 函数初始化 list

  变量名 := list.New()

• 通过 var 关键字声明初始化 list

  var 变量名 list.List

列表与切片和 map 不同的是，列表并没有具体元素类型的限制，因此，列表的元素可以是任意类型，这既带来了便利，也引来一些问题，例如给列表中放入了一个 interface{} 类型的值，取出值后，如果要将 interface{} 转换为其他类型将会发生宕机。

列表中插入元素

双链表支持从队列前方或后方插入元素，分别对应的方法是 PushFront 和 PushBack。

这两个方法都会返回一个 *list.Element 结构，如果在以后的使用中需要删除插入的元素，则只能通过 *list.Element 配合 Remove() 方法进行删除，这种方法可以让删除更加效率化，同时也是双链表特性之一。下面代码展示如何给 list 添加元素：

l := list.New()l.PushBack("fist")l.PushFront(67)

列表中删除元素

列表插入函数的返回值会提供一个 *list.Element 结构，这个结构记录着列表元素的值以及与其他节点之间的关系等信息，从列表中删除元素时，需要用到这个结构进行快速删除。列表操作元素：

package main
import "container/list"
func main() {
    l := list.New()
    // 尾部添加
    l.PushBack("canon")
    // 头部添加
    l.PushFront(67)
    // 尾部添加后保存元素句柄
    element := l.PushBack("fist")
    // 在fist之后添加high
    l.InsertAfter("high", element)
    // 在fist之前添加noon
    l.InsertBefore("noon", element)
    // 使用
    l.Remove(element)
}

遍历列表

遍历双链表需要配合 Front() 函数获取头元素，遍历时只要元素不为空就可以继续进行，每一次遍历都会调用元素的 Next() 函数，代码如下所示。

l := list.New()
// 尾部添加
l.PushBack("canon")
// 头部添加
l.PushFront(67)
for i := l.Front(); i != nil; i = i.Next() {
    fmt.Println(i.Value)
}