Golang--复合数组类型（数组、切片）

Golang–复合数组类型

1 数组

1.1 定义数组

package main

import (
	"fmt"
)

func main() {
	//定义数组
	//数字类型
	var numb [10]int
	fmt.Printf("%T %v\n", numb, numb)
	//bool类型
	var t1 [5]bool
	fmt.Printf("%T %v\n", t1, t1)
	//字符串类型
	var t2 [3]string
	fmt.Printf("%T %q\n", t2, t2)
}

标准输出：

[10]int [0 0 0 0 0 0 0 0 0 0]
[5]bool [false false false false false]
[3]string ["" "" ""]

1.2 数组赋值

package main

import (
	"fmt"
)

func main() {
	//定义数组
	//数字类型
	var numb [10]int
	fmt.Printf("%T %v\n", numb, numb)

	//数组赋值
	numb = [10]int{1, 2, 3}
	fmt.Println(numb)
	//使用索引赋值
	numb = [10]int{0: 1, 9: 3}
	fmt.Println(numb)
	//推倒赋值，{}中的数量必须和之前定义的相同
	numb = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	fmt.Println(numb)
}

标准输出：

[10]int [0 0 0 0 0 0 0 0 0 0]
[1 2 3 0 0 0 0 0 0 0]
[1 0 0 0 0 0 0 0 0 3]
[1 2 3 4 5 6 7 8 9 10]

1.3 简短声明

package main

import (
	"fmt"
)

func main() {
	//定义数组
	//数字类型
	var numb [10]int
	fmt.Printf("%T %v\n", numb, numb)

	//简短声明
	//推倒数组
	numb2 := [...]int{2, 2, 2}
	fmt.Printf("%T %v\n", numb2, numb2)
	//使用索引赋值
	numb3 := [5]int{0: 1, 2: 3}
	fmt.Println(numb3)
}

标准输出：

[10]int [0 0 0 0 0 0 0 0 0 0]
[3]int [2 2 2]
[1 0 3 0 0]

1.4 数组操作（比较、修改元素、遍历元素）

package main

import (
	"fmt"
)

func main() {
	//定义数组
	//数字类型
	var numb [10]int
	fmt.Printf("%T %v\n", numb, numb)

	//数组操作
	numb4 := [...]int{1, 2, 3}
	numb5 := [...]int{1, 2, 3}
	numb6 := [...]int{1, 2, 4}
	fmt.Println(numb4 == numb5)
	fmt.Println(numb4 == numb6)
	//获取数组长度
	fmt.Println(len(numb6))
	//索引0, 1, 2, 3 ... len(array) - 1
	fmt.Println(numb6[0])
	//使用索引获取和修改数组元素
	numb6[0] = 100
	fmt.Println(numb4)
	//遍历索引元素
	for i := 0 ; i < len(numb4) ; i++{
		fmt.Println(numb4[i])
	}
}

标准输出：

[10]int [0 0 0 0 0 0 0 0 0 0]
true
false
3
1
[1 2 3]
1
2
3

1.5 多维数组

package main

import (
	"fmt"
)

func main() {
	//多维数组
	//定义多维数组
	var numb7 [2][2]int
	fmt.Println(numb7)
	//对多维数组赋值
	numb7[1] = [2]int{2,3}
	fmt.Println(numb7)
	//对多维数组中的数组的某个值赋值
	numb7[1][1] = 2
	fmt.Println(numb7)
	//简短声明多维数组
	numb8 := [3][2]int{{3,2},{1,0}}
	fmt.Println(numb8)
}

标准输出：

[[0 0] [0 0]]
[[0 0] [2 3]]
[[0 0] [2 2]]
[[3 2] [1 0] [0 0]]

2 切片

2.1 定义

• 切片是长度可变的数组（具有相同数据类型的数据项组成的一组长度可变的序列），切片由三部分组成：

• 指针：指向切片第一个元素指向的数组元素的地址
• 长度：切片元素的数量
• 容量：切片开始到结束位置元素的数量

2.2 定义切片

package main

import (
	"fmt"
)

func main() {
	//定义一个数组
	var nums []int
	fmt.Printf("%T %v %t\n", nums, nums, nums == nil)
}

标准输出：

[]int [] true

2.3 切片的字面量

2.3.1 赋值

package main

import (
	"fmt"
)

func main() {
	//字面量
	nums = []int{1, 2, 3}
	fmt.Printf("%#v\n", nums)
	nums = []int{1, 2, 3, 4}
	fmt.Printf("%#v\n", nums)
}

标准输出：

[]int{1, 2, 3}
[]int{1, 2, 3, 4}

2.3.2 通过数组赋值

package main

import (
	"fmt"
)

func main() {
//数组切片赋值
	arrays := [4]int{1, 2, 3, 4}
	nums = arrays[1:4]
	fmt.Printf("%#v",nums )
}

标准输出：

[]int{2, 3, 4}

2.4 长度(len)和容量(cap)

package main

import (
	"fmt"
)

func main() {

	//数组切片赋值
	arrays := [4]int{1, 2, 3, 4}
	nums = arrays[1:4]
	fmt.Printf("%#v %d %d\n", nums, len(nums), cap(nums))

	//make函数
	nums = make([]int, 3)
	fmt.Printf("%#v %d %d\n", nums, len(nums), cap(nums))

	nums = make([]int, 3, 5)
	fmt.Printf("%#v %d %d\n", nums, len(nums), cap(nums))
}

标准输出：

[]int{2, 3, 4} 3 3
[]int{0, 0, 0} 3 3
[]int{0, 0, 0} 3 5

2.4.1 元素操作

package main

import (
	"fmt"
)

func main() {
//元素操作（增、删、改、查）
	nums = []int{1,3,4}
	fmt.Printf("%#v\n", nums)

	//增
	nums = append(nums, 9)
	fmt.Println(nums)
	fmt.Println("-----容量满了之后添加-----")
	nums = append(nums, 9)
	fmt.Printf("%p\n",&nums)
	//在容量满了后，会申请原内存空间2倍的内存空间，将原切片的内容复制到新的内存空间中，并在后面的内存空间中添加值
	//删

	//改
	nums[2] = 0
	fmt.Println(nums[2])
	//查
	fmt.Println(nums[0])
	fmt.Println(nums[1])

	//遍历切片
	for i := 0 ; i < len(nums) ; i++ {
		fmt.Println(i,nums[i])
	}
	for k,v := range nums {
		fmt.Println(k, v)
	}
	//切片操作
	fmt.Println(nums[0:3])
}

标准输出：

[]int{1, 3, 4}
[1 3 4 9]
-----容量满了之后添加-----
0x11004110
0
1
3
0 1
1 3
2 0
3 9
4 9
0 1
1 3
2 0
3 9
4 9
[1 3 0]

2.4.2 删除元素

package main

import (
	"fmt"
)

func main() {
//删
	//copy
	nums03 := []int{1,2,3}
	nums04 := []int{10,20,30,40}
	copy(nums04,nums03)
	//copy(原数组，要copy的目标数组）
	fmt.Println(nums03,nums04)
	nums04 = []int{10,20,30,40}
	copy(nums04,nums03)
	fmt.Println(nums03,nums04)
	//若原数组长度小于要copy的数组长度，只copy原数组长度

	//删除索引为0,和删除最后一个元素
	nums05 := []int{1,2,3,4,5}
	fmt.Println(nums05[1:])
	fmt.Println(nums05[0:len(nums05)-1])
	//删除中间元素
	nums06 := []int{1, 2, 3, 4, 5}
	copy(nums06[2:], nums06[3:])
	fmt.Println(nums06[:len(nums06)-1])
}

标准输出：

[1 2 3] [1 2 3 40]
[1 2 3] [1 2 3 40]
[2 3 4 5]
[1 2 3 4]
[1 2 4 5]

2.4.3 队列和堆栈

package main

import (
	"fmt"
)

func main() {
//队列和堆栈
	//队列：先进先出
	nums07 := []int {1,2,3,4,5,6}
	nums07 = nums07[1:]
	fmt.Println(nums07)
	//堆栈：先进后出
	nums07 = nums07[:len(nums07)-1]
	fmt.Println(nums07)
}

标准输出：

[2 3 4 5 6]
[2 3 4 5]

2.4.4 数组和切片

package main

import (
	"fmt"
)

func main() {
	//数组是值类型
	//切片赋值是值拷贝，会使用相同内存地址
	slice01 := []int{1,2,3,4}
	slice02 := slice01
	slice02[1] = 11
	fmt.Println(slice01,slice02)
	//数组赋值
	//数组是值类型，所有的值类型的赋值都是值传递
	array01 := [4]int{1,2,3,4}
	array02 := array01
	array02[1] = 11
	fmt.Println(array01,array02)

	//var nums []int  => nil slice
	//[]int{} => 空切片
}

标准输出：

[1 11 3 4] [1 11 3 4]
[1 2 3 4] [1 11 3 4]

3 sort排序

package main

import (
	"fmt"
	"sort"
)

func main() {
	numbs := []int{5,6,9,0}
	sort.Ints(numbs)
	fmt.Println(numbs)
	//数字切片排序
	names  := []string{"aa","11","g","eff"}
	sort.Strings(names)
	fmt.Println(names)
	//对字符串进行排序
	flouts := []float64{1.2,4.7,-1.1}
	sort.Float64s(flouts)
	fmt.Println(flouts)
}

标准输出：

[0 5 6 9]
[11 aa eff g]
[-1.1 1.2 4.7]

4 映射（map）

4.1 定义及初始化映射

package main

import "fmt"

func main()  {
	var scores map[string]int //nil映射。k是string类型，v是int类型
	//定义映射
	fmt.Printf("%T %#v\n", scores, scores)
	fmt.Println(scores == nil)
	scores = map[string]int{"A":10, "B":9}
	//初始化集合，并添加元素
	fmt.Println(scores)
	scores = make(map[string]int)
	//初始化为空集合
	fmt.Println(scores)
}

标准输出：

map[string]int map[string]int(nil)
true
map[A:10 B:9]
map[]

4.2map的操作（增 删 改 查）

4.2.1 查询

package main

import (
	"fmt"
)

func main()  {
	var scores map[string]int //nil映射。k是string类型，v是int类型
	//定义映射
	fmt.Printf("%T %#v\n", scores, scores)
	scores = map[string]int{"A":10, "B":9}
	fmt.Println(scores)
	//增  删  改  查
	fmt.Println(scores["A"])
	fmt.Println(scores["C"])
	//不存在时候打印0
	if v, ok := scores["B"] ; ok{
		fmt.Println(v)
	}
	if v, ok := scores["C"] ; ok{
		fmt.Println(v)
	}
	//判断是否存在key值，存在则打印

标准输出：

map[string]int map[string]int(nil)
map[A:10 B:9]
10
0
9

4.2.2 修改和添加

package main

import (
	"fmt"
)

func main()  {
	var scores map[string]int //nil映射。k是string类型，v是int类型
	//定义映射
	scores = map[string]int{"A":10, "B":9}
//修改和添加
	//若key存在则修改，不存在则添加
	scores["B"] = 10
	//修改已存在的值
	fmt.Println(scores["B"])
	scores["C"] = 9
	//不存在key会添加
	fmt.Println(scores["C"])
}

标准输出：

10
9

4.2.2删除、遍历和数组长度

package main

import (
	"fmt"
)

func main()  {
	//删除
	delete(scores,"C")
	fmt.Println(scores["C"])
	fmt.Println(scores)
	fmt.Println(len(scores))
	//遍历映射（映射是无序的）
	for k, v := range scores {
		fmt.Println(k, v)
	}

标准输出：

map[A:10 B:10]
2
A 10
B 10