声明数组
var cards [10] int
//声明一个下标长度为10的数组
var cards = [5]int{10,2,5,7,50}
cards := [5]int{10,2,5,7,50}
//声明的同时赋值数组
cards := [...]int{10,2,5,7,50}
//如果数组长度不确定，可以使用...代替数组的长度，编译器会根据元素个数自行推断数组的长度
cards := [...]int{1: 2, 3: 6, 5: 6}
//如果设置了数组的长度,还可以通过指定下标来初始化元素,结果为[0,2,0,6,0,6]
fmt.Println(cards[0])
//根据下标打印数组中的值
冒泡排序
冒泡排序法是一种最简单的交换类排序方法，它是通过相邻数据的交换逐步将无序列表排列为有序列表。
冒泡排序的基本原理是重复地循环遍历要排序的元素列，依次比较两个相邻的元素，如果顺序（如从小到大或者首字母从 Z 到 A）错误就把两个元素的位置交换过来，直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
冒泡排序的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同气泡最终会上浮到顶端一样，故名“冒泡排序”。
package main
import "fmt"
func main() {
var (
num = [...]int{57, 76, 65, 43, 75, 89, 78}
t = len(num)
)
fmt.Println("没排序之前:\n", num)
for i := 0; i < t; i++ {
fmt.Println("第", i+1, "次冒泡")
for j := 0; j < t; j++ {
if num[i] < num[j] {
sum := num[i]
num[i] = num[j]
num[j] = sum
}
}
fmt.Println("排序之后.", num)
}
fmt.Println("从小到大排序依次为:\n", num)
}
运行结果
没排序之前:
[57 76 65 43 75 89 78]
第 1 次冒泡
排序之后. [89 57 65 43 75 76 78]
第 2 次冒泡
排序之后. [57 89 65 43 75 76 78]
第 3 次冒泡
排序之后. [57 65 89 43 75 76 78]
第 4 次冒泡
排序之后. [43 57 65 89 75 76 78]
第 5 次冒泡
排序之后. [43 57 65 75 89 76 78]
第 6 次冒泡
排序之后. [43 57 65 75 76 89 78]
第 7 次冒泡
排序之后. [43 57 65 75 76 78 89]
从小到大排序依次为:
[43 57 65 75 76 78 89]
多维数组
声明方式
var cards [下标][下标的下标]...[下标的下标的下标] int
var cards [2][2]int
cards := [][]int{}
获取数组长度
len(cards)
//cards是要获取长度的数组
数组之make切片
可以说Go 语言切片是对数组的抽象。
Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go 中提供了一种灵活，功能强悍的内置类型切片("动态数组")，与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。
创建/生成切片的几种方式
//1、声明切片
var cards []int
cards := []int{}
//创建有3个值的切片
//cap是底层的长度由于当切片长度大于底层数组长度时，go会重新申请一个新的底层数组来存储数据，相当于cap*2
slice := make([]type, len, cap)
var cards []int = make([]int, 3)
var cards []int = make([]int, 0, 0)
//创建含有1，2，3的切片
var cards []int = []int{1, 2, 3}
fmt.Println(s4)
s5 := []int{1, 2, 3}
fmt.Println(s5)
// 5.从数组切片
arr := [5]int{1, 2, 3, 4, 5}
// 6、前包后不包
var s6 []int
s6 = arr[1:4]
fmt.Println(s6)
将值添加到切片末尾
cards := append(cards, "lisi")
cards := append(cards, "lisi", "liliu", "liqi")
//append用于向切片中添加元素，可以用于将一个值追加到一个切片的末尾。`append()` 函数会根据需要对切片进行扩容，以便能够放下新添加的元素。
将数组截取到切片
cards := [5]int{1, 2, 3, 4, 5}
var s6 []int
//前包后不包
s6 = cards[1:4]
fmt.Println(s6)
//结果为[2 3 4]
| 操作 | 含义 |
|---|---|
| s[n] | 切片s中索引位置为n的项 |
| s[:] | 从切片s 的索引位置0到len(s)-1处所获得的切片 |
| s[low:] | 从切片s的索引位置low到len(s)-1处所获得的切片 |
| s[:high] | 从切片s的索引位置0到 high 处所获得的切片，len=high |
| s[low:high] | 从切片s的索引位置low到 high 处所获得的切片，len=high-low |
| s[low: high:max] | 从切片s的索引位置low到high 处所获得的切片，len=high-low，cap=max-low |
| len(s) | 切片s的长度，总是<=cap(s) |
| cap(s) | 切片s的容量，总是>=len(s) |
字典类型map
var cards map[string]int
cards := map[string]string{"name":"zhangsan","address":"nanjing"}
var cards = map[string]string{
"name": "zhangsan",
"address": "nanjing",
}
var doMap = make(map[string]int, 100)//创建一个有100个值的切片
//创建一个字典：map表示字典类型，string名字类型，int是值的内容
fmt.Println(cards["name"])
//可以打印一下看一下效果
根据下标从map数组中删除
delete(cards,"name")
//cards是数组，"name"是下标
安全的给map添加值和删除值
var cards = sync.Map{}
//sync.Map{}是 Go 语言中创建一个线程安全的 map 变量 `cards` 的语法。它使用了 Go 语言的内置包 `sync` 中的 `Map` 类型。`sync.Map` 可以被多个 goroutine 安全地并发访问和修改，不需要使用额外的锁机制。可以将其作为一个并发安全的 key-value 数据库，用于多个 goroutine 之间共享数据。
cards.Store(key, n)
//Store用于在 map 中存储一个键值对，其中 `key` 表示键，`n` 表示值。这个方法会将键值对写入 map 中，如果 map 中已经存在该键，则会将其对应的值进行更新。`m.Store()` 方法是并发安全的，可以用在多个 goroutine 中同时对 map 进行操作。
value, _ := cards.Load(key)
//取出cards[key]并存放到value中
fmt.Println(key,value)
