一、数组 array
声明数组时，必须声明数组大小，声明后大小不可变，未赋值的空间默认值为数组存储类型的 0 值。
- 数组是值类型数据，相同空间大小的数组可以用
==来比较是否相同。
package main
import "fmt"
func main() {
var a1 = [2]int{1, 2}
var a2 = [2]int{1, 2}
fmt.Println(a1 == a2) // 输出：true
}
2.数组遍历
package main
import "fmt"
func main() {
// range 推荐
arr := [3]string{"aa", "bb", "cc"}
for index, v := range arr {
fmt.Printf("index:%d, value:%s\n", index, v)
}
// for
for i := 0; i < len(arr); i++ {
v := arr[i]
fmt.Printf("index:%d, value:%s\n", i, v)
}
}
3.数组追加元素
数组大小固定，所以只能指定元素操作。
package main
import (
"fmt"
)
func main() {
var arr = [5]int{1, 2}
arr[2] = 3
arr[3] = 4
fmt.Println(arr) // 输出：[1 4 3 4 0]
}
4.数组指针
package main
import (
"fmt"
)
func main() {
// 数组指针之间的赋值不会拷贝底层数组的值
var a1 = &[3]int{1, 2, 3} // 取数组地址
var a2 *[3]int // 定义一个数组指针
a2 = a1 // 使 a2 指向 a1 地址
a1[2] = 9
fmt.Println(*a1) // 输出:[1 2 9]
fmt.Println(*a2) // 输出:[1 2 9]
}
二、切片 slice
切片可以看作是一个可变长的数组，是一个引用类型。它包含三个数据：1.指向数组的指针，2.切片中的元素，3.切片的大小。
1.切片遍历
package main
import "fmt"
func main() {
sl := []int{1, 2, 3}
// range
for i, v := range sl {
fmt.Printf("index:%d, value:%d\n", i, v)
}
for i := 0; i < len(sl); i++ {
v := sl[i]
fmt.Printf("index:%d, value:%d\n", i, v)
}
}
2.插入、删除元素
只要内存足够，切片可以追加任意个元素。
package main
import "fmt"
func main() {
// 切片末尾追加元素
sl := make([]int, 0)
sl = append(sl, 1)
sl = append(sl, 2, 3)
fmt.Println(sl) // 输出：[1 2 3]
// 在索引位置 i 插入元素 x：s = append(s[:i], append([]T{x}, s[i:]...)...)
// 在索引位置 1 插入元素 4：
sl = append(sl[:1], append([]int{4}, sl[1:]...)...)
fmt.Println(sl) // 输出：[1 4 2 3]
// 在索引位置 i 插入长度为 j 的切片：s = append(s[:i], append(make([]T, j), s[i:]...)...)
// 在索引位置 2 插入长度为 3 的切片：
var sl1 = []int{11, 22, 33}
sl = append(sl[:2], append(sl1, sl[2:]...)...)
fmt.Println(sl) // 输出：[1 4 11 22 33 2 3]
// 删除索引位置 i 上元素：s = append(s[:i], s[i+1:]...)
// 删除索引位置 1 上的元素：
sl = append(sl[:1], sl[1+1:]...)
fmt.Println(sl) // 输出：[1 11 22 33 2 3]
// 删除索引位置 i 到 j 上的元素，杀出元素不包括索引 j 上的元素：s = append(s[:i],s[j:]...)
// 删除索引位置 2 到 4 上的元素：
sl = append(sl[:2], sl[4:]...)
fmt.Println(sl) // 输出：[1 11 2 3]
// 复制切片，将 a 切片上的元素拷贝到 b 切片上：copy(b, a)
// 如果切片长度不等，a 长度大于 b 则拷贝len(b) 长度个 a 切片中的元素给 b
// 如果 a 长度小于 b 则拷贝 a 中元素到 b 中，b 中超出的元素部分保持原值不变
var a, b []int
a = []int{1, 2, 3, 4}
b = []int{11, 22}
copy(b, a)
fmt.Println(b) // 输出：[1,2]
c := make([]int, 5)
c = []int{11, 22, 33, 44, 55}
copy(c, a)
fmt.Println(c) // 输出：[1 2 3 4 55]
}
3.排序
Go 语言 sort 包提供了 sort.Ints() 、sort.Float64s() 和 sort.Strings() 函数，都是从小到大排序：
package main
import (
"fmt"
"sort"
)
func main() {
intList := []int{5, 3, 2, 1, 4}
float64List := []float64{5.1, 1.2, 2.34, 4.22, 3.12}
stringList := []string{`a`, `e`, `d`, `c`, `b`}
// 正序，从小到大排序
sort.Ints(intList)
sort.Float64s(float64List)
sort.Strings(stringList)
fmt.Println(intList) // 输出：[1 2 3 4 5]
fmt.Println(float64List) // 输出：[1.2 2.34 3.12 4.22 5.1]
fmt.Println(stringList) // 输出：[a b c d e]
// 倒叙，从大到小排序
sort.Sort(sort.Reverse(sort.IntSlice(intList)))
sort.Sort(sort.Reverse(sort.Float64Slice(float64List)))
sort.Sort(sort.Reverse(sort.StringSlice(stringList)))
fmt.Println(intList) // 输出：[5 4 3 2 1]
fmt.Println(float64List) // 输出：[5.1 4.22 3.12 2.34 1.2]
fmt.Println(stringList) // 输出：[e d c b a]
}
三、字典 map
字典操作：
package main
import "fmt"
func main() {
m := make(map[string]int, 2)
// 插入元素
m["a"] = 11
m["b"] = 22
// 遍历 map
for index, v := range m {
fmt.Printf("index:%s v%d:\n", index, v)
}
// 删除 map 中数据
delete(m, "a")
fmt.Println(m) // 输出：map[b:22]
}
