三、容器：存储和组织数据的方式

3.1数组--固定大小的连续空间

数组是一段固定长度的连续内存区域。（特性完全同C语言）
Go中数组从声明时就确定，使用时可以修改数组成员，但是数组大小不可变化。

• 声明

  表达式:var name [n]T

  n 是数组的元素数量。可以是表达式，但需在编译期计算出结果。
  T 可以是任意基本类型，包括为T数组本身。类型为数组本身时，可以实现多维数组。

• 数组初始化

  参考: var team = [3]string{"a","b","c"}
  另: var team = [...]string{"a","b","c"}
  "..." 表示让编译器确定数组大小。

• 遍历数组

  var team = [3]string{"a","b","c"}
  for k,v := range team{
      fmt.Println(k,v)
  }
  

3.2切片（slice）--动态非配大小的连续空间

Go语言中切片的内部结构包含地址、大小和容量。一般用于快速地操作一块数据集合。切片是一段连续的内存区域，可以是数组，也可以是切片本身。

• 生成新的切片

  从数组生成切片

  var a = [5] int {1,2,3,4,5}  
  //切片操作
  a[1:2]
  //区间
  a[2:4]
  //中间到尾部
  a[2:]
  //头到中间
  a[:4]
  //完全一致
  a[:]
  //重置切片，清空拥有的元素
  a[0:0]
  

• 声明切片

表达式: var name []T
T代表切片元素的类型，可以是int、float、bool、map、slice等

```
var strSlice = []string
var intSlice = []int
var numListEmpty = []int{}
//表达式 strSlice == nil 值为true
//表达式 intSlice == nil 值为true
//表达式 numListEmpty == nil 值为false
```

未初始化的切片，默认值为nil。
空切片已经被分配内存，所以不为nil。

• 使用make()函数构造切片

make()用于动态地创建一个切片。
格式: make([]T , size , cap)
T是元素类型，size是为这个类型非配多少个元素，cap是预分配元素的数量，这个值设定后不影响size，只是能提前分配空间，降低多次分配空间造成的性能问题。

```
a := make([]int , 2)
b := make([]int , 2 , 10)
//设置cap，只是代表b的内部存储空间已经分配了10个，实际上只是用了2个元素。
```

• 使用 append() 函数为切片添加元素

当预设空间不能容纳足够多的元素时，切片会进行”扩容“，”扩容“会在调用 append 函数时发生。

    var car = []string
    
    //添加一个元素
    car = append(car,"car1")
    
    //添加多个元素
    car = append(car,"car2","car3","car4")
    
    //添加整个数组的元素 使用： list...
    list := []string{"car5","car6","car7","car8"}
    car = append(car,list...)

• 复制切片-- copy()

格式：copy(destSlice , srcSlice []T) int
srcSlice 为数据源切片，destSlice 为复制的目标，返回值是实际发生复制的元素个数。

• 删除切片中元素

Go语言没有对删除切片元素提供专门的语法或接口，需要根据切片本身的特性删除元素。

seq := []string{"1","2","3","4","5"}
index := 2
//去除index位置元素，拼接index前后两部分即可
seq := append(seq[:index],seq[index+1:]...)

注意：当业务需要大量、频繁地从一个切片中删除元素时，如果对性能要求较高，就需要反思是否需要更换其他的容器，如双链表等能快速从删除点删除元素。

3.3映射（map）-- KEY-VALUE

• 创建

表达式: map[KeyType] ValueType

//声明
scence := make(map[string]int)

//填充式声明
m := map[string]string{
    "w":"value1",
    "s":"value2",
    "d":"value3",
}

//存值
scence["route"] = 66

//取值
v := scence["route2"]

//判断是否存在，多取一个ok
v , ok := scence["route"]

• 遍历

使用for range 循环

//遍历键和值
for k , v := range scence{
    fmt.Println(k,v)
}
//遍历值
for _,v := range cence{}
//遍历键
for k := range scence{}

遍历输出元素与填充顺序无关，如需要特定顺序的遍历结果，正确做法是排序。

var scenceList []string
for k := range scence{
    scenceList = append(scenceList,k)
}
//排序，字符串升序排序
sort.Strings(scenceList)

• 删除 -- delete()

表达式： delete(map,k)

• 清空

Go并没有提供清空所有元素的函数，清空map的办法是重新make一个新的map。

• 并发map（sync.Map）

单纯的map在并发情况下，只读线程是安全的，同时读写线程不安全。
sync.Map特性：
1.无须初始化话，直接声明即可。
2.不能用map的方式进行取值等操作，使用Store(存储)、Load(获取)、Delete(删除)。
3.使用Range配合一个回调函数进行遍历，回调函数的返回值标识是否需要迭代遍历。

var scene sync.Map
//增加
scene.Store("key1","value1")
scene.Store("key2","value2")
scene.Store("key3","value3")
//取值
scene.Load("key2")
//删除
scene.Delete("key1")
//遍历
scene.Range(func(k,v interface bool{
    fmt.Println("interate:",k,v)
    return true;
}))

3.4列表（list）-- 快速增删的非连续空间的容器

列表是一种非连续存储的容器，由多个节点组成，节点通过一些变量记录彼此之间的关系，列表有多种实现方法，如单链表、双链表等。
Go语言中使用container/list包来实现列表，内部实现原理是双链表。能够高效地进行任意位置的元素插入和删除操作。

• 初始化

列表有两种初始换方式：New和声明，效果一致。
1.表达式： name := list.New()
2.表达式： var name = list.list
与map和slice不同的是，列表并没有元素类型的限制。

• 插入元素

双链表支持从队列前或后方插入元素，分别是PushFront 和 PushBack.
两个方法都会返回一个 *list.Element 结构。

l := list.New()
l.PushFront("1")
l.PushBack(2)

列表插入元素的方法：

• 删除元素

删除元素需要使用， *list.Element 结构。

l := list.New()
l.PushBack("1")
l.PushFront("2")

element := l.PushBack("3")

l.InsertAfert("4",element)
l.InserBefore("5",element)

l.Remove(element)

• 遍历列表

使用Front() 获取头元素，使用Next()获取列表写一个元素。

for i := l.Front() ; i != nil ; i = i.Next(){}