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 个元素
