go容器介绍

1. 数组

  数组是一个由固定长度的特定类型元素组成的序列，一个数组可以由零个或多个元素组成，数组的长度是固定的。

• 数组的初始化

 var 数组变量名 [元素数量]Type
 // 定义三个整数的数组
 var a [3]int             

 var array_name [size1][size2]...[sizen] array_type
 // 声明一个二维整型数组，两个维度的长度分别是 4 和 2
 var array [4][2]int

• 数组间的比较
    不同于Java，go中可以直接用“==”进行比较，两个数组相等的条件是数组的长度以及数组中的每一个元素都相等

a := [2]int{1, 2}
b := [...]int{1, 2}
c := [2]int{1, 3}
fmt.Println(a == b, a == c, b == c) // "true false false"

• 数组的遍历

var team [3]string
team[0] = "hammer"
team[1] = "soldier"
team[2] = "mum"

for k, v := range team {
    fmt.Println(k, v)
}

2. 切片

  切片简单来讲就是对一段连续内存地址片段的引用。go语言支持切片作为一种数据类型，可以定义一段切片或者从数组、切片中截取一段切片。

• 生成切片
  （1）声明式

var name []Type
// int 类型的切片
var arr []int

  （2）make关键字

make([]Type, size, cap)
// int 类型切片，其中有5个元素，共有10个元素的预留空间
make([]int, 5, 10)

  其中Type是指切片的元素类型，size是指为这个类型分配多少个元素，cap是预分配的空间，合理设置cap，可以降低多次分配空间造成的性能问题。

  （2) 从现有数组或者切片中截取

// slice：表示目标切片对象；左闭右开
slice [开始位置 : 结束位置]  

// 从整型数组中截取一个切片
a  := [3]int{1, 2, 3}
fmt.Println(a, a[1:2])  // 运行结果：[1 2 3]  [2]

• 切面 *** 作

  （1）添加元素

var a []int
// 使用 append 函数返回新切片的特性
a = append(a, 1) // 追加1个元素
a = append(a, 1, 2, 3) // 追加多个元素, 手写解包方式
a = append(a, []int{1,2,3}...) // 追加一个切片, 切片需要解包
a = append([]int{-3,-2,-1}, a...) // 在开头添加1个切片

  （2）切片拷贝

copy( destSlice, srcSlice []T) int

slice1 := []int{1, 2, 3, 4, 5}
slice2 := []int{5, 4, 3}
copy(slice2, slice1) // 只会复制slice1的前3个元素到slice2中
copy(slice1, slice2) // 只会复制slice2的3个元素到slice1的前3个位置

  （3）删除元素

a = []int{1, 2, 3}
// 切片中删除元素的本质是从切片中进行切片
a = a[N:] // 删除开头N个元素
a = a[:len(a)-N] // 删除尾部N个元素
a = append(a[:i], a[i+N:]...) // 删除中间N个元素

• 多维切片

var sliceName [][]...[]sliceType  // 是几维切片就有几个[]

//声明一个二维切片
var slice [][]int
//为二维切片赋值
slice = [][]int{{10}, {100, 200}}

3. Map

  Go语言中 map 是一种特殊的数据结构，一种元素对（pair）的无序集合，pair 对应一个 key（索引）和一个 value（值），所以这个结构也称为关联数组或字典，这是一种能够快速寻找值的理想结构，给定 key，就可以迅速找到对应的 value。

• 初始化

  （1）声明map类型

var mapname map[keytype]valuetype

  （2）分配内存

var mapLit map[string]int
// 方式一
mapLit = map[string]int{"one": 1, "two": 2}
// 方式二
mapLit = make(map[string]int, 5) //初始化分配5个kv空间

• k-v值的增删查

var mapLit map[string]int
mapLit = map[string]int{"one": 1, "two": 2}

mapLit["key"] = 1 // 存值
v, ok := mapLit["key"] // 取值，通过bool类型的变量ok可以判断出k-v是否存在
delete(mapLit, "key") // 通过关键字delete进行删除k-v

• map的遍历

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

4. List

  List数据结构的内部实现原理是双链表，列表能够高效地进行任意位置的元素插入和删除 *** 作。

• 初始化

变量名 := list.New()
var 变量名 list.List

• 链表 *** 作

package main

import "container/list"

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

• 链表遍历

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

5. Ring

  Ring 类型实现的是一个循环链表，也就是我们俗称的环，这个链表是首尾相连的。它和链表List最大的区别在于 Ring在初始化的时候需要指定长度，而且长度一旦确定之后就不能进行修改了。

• 初始化

ring := ring.New(3) // 指定一个长度为3的ring

• 赋值和遍历

func main() {
    ring := ring.New(3)

    for i := 1; i <= 3; i++ {
        ring.Value = i
        ring = ring.Next()
    }

    // 计算 1+2+3
    s := 0
    ring.Do(func(p interface{}){
        s += p.(int)
    })
    fmt.Println("sum is", s)
}

• 主要方法

  func New(n int) *Ring  // 初始化环
  func (r *Ring) Do(f func(interface{}))  // 循环环进行 *** 作
  func (r *Ring) Len() int // 环长度
  func (r *Ring) Link(s *Ring) *Ring // 连接两个环
  func (r *Ring) Move(n int) *Ring // 指针从当前元素开始向后移动或者向前（n 可以为负数）
  func (r *Ring) Next() *Ring // 当前元素的下个元素
  func (r *Ring) Prev() *Ring // 当前元素的上个元素
  func (r *Ring) Unlink(n int) *Ring // 从当前元素开始，删除 n 个元素