golang学习笔记系列之复杂数据类型

复杂数据类型

数组

数组是相同数据类型的一组数据的集合，数组一旦定义长度不能修改，数组 可以通过索引来访问元素。

数组的定义

var array_name [SIZE]TYPE
1

• array_name：数组名
• SIZE：数组的大小
• TYPE：数组中数据的类型

type Student struct {
	Name string
	num  int
}
// 数组的定义
var arr_int [10]int
fmt.Printf("arr_int: %v\n", arr_int)
var arr_str [10]Student
fmt.Printf("arr_str: %v\n", arr_str)
1
2
3
4
5
6
7
8
9

运行结果

arr_int: [0 0 0 0 0 0 0 0 0 0]
arr_str: [{ 0} { 0} { 0} { 0} { 0} { 0} { 0} { 0} { 0} { 0}]
1
2

数组的初始化

初始化就是给数组的元素赋初值，没有初始化的数组，默认元素都是零值（数值型的默认值是0，布尔型的默认值所示false，字符串型的默认值是空字符）。

//给数组赋初始值
	var arr_int_init = [10]int{1, 2, 3}
	fmt.Printf("arr_int_init: %v\n", arr_int_init)

	//给指定位置赋初始值
	var arr_float_init = [10]float64{0: 100.0, 3: 200.0}
	fmt.Printf("arr_float_init: %v\n", arr_float_init)

	//使用...不指定数组的大小,根据初始值来判断数组的大小
	var arr_string_init = [...]string{"hello", "world"}
	fmt.Printf("arr_string_init: %v\n", arr_string_init)
1
2
3
4
5
6
7
8
9
10
11

运行结果

arr_int_init: [1 2 3 0 0 0 0 0 0 0]
arr_float_init: [100 0 0 200 0 0 0 0 0 0]
arr_string_init: [hello world]
1
2
3

数组的访问

可以通过索引的方式来访问数组。数组的最大下标为数组的长度减一，最小为0，大于这个值会发生数组越界。

package main

import "fmt"

func main() {

	var arr_int = [10]int{1, 2, 3, 4, 5, 6}

	//访问第一个元素
	fmt.Printf("arr_int[0]: %v\n", arr_int[0])

	//访问第3个元素
	fmt.Printf("arr_int[2]: %v\n", arr_int[2])

	//访问最后一个元素
	fmt.Printf("arr_int[len(arr_int)-1]: %v\n", arr_int[len(arr_int)-1])

	//for遍历数组
	for i := 0; i < len(arr_int); i++ {

		fmt.Printf("a[%v]=%v \n", i, arr_int[i])

	}
	print("#########################################\n")
	//for range遍历数组
	for i, v := range arr_int {
		fmt.Printf("a[%v]=%v \n", i, v)

	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

运行结果

arr_int[0]: 1
arr_int[2]: 3
arr_int[len(arr_int)-1]: 0
a[0]=1 
a[1]=2 
a[2]=3 
a[3]=4 
a[4]=5 
a[5]=6 
a[6]=0 
a[7]=0 
a[8]=0 
a[9]=0 
#########################################
a[0]=1 
a[1]=2 
a[2]=3 
a[3]=4 
a[4]=5 
a[5]=6 
a[6]=0 
a[7]=0 
a[8]=0 
a[9]=0 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

切片

和数组类似，切片也是一组相同数据类型的数据的集合，但与数组不一样的是，切片的长度是可变的。对于数组来说，当我们对要保存的元素的个数不确定时，如果申请太小的数组，可能就不够用；如果申请太大的数组，可能就造成了不必要的浪费。鉴于这个原因，就有了切片，我们可以把切片理解为可变长度的数组，其实它底层就是使用数组实现的，只不过增加了一个自动扩容功能。

切片的定义

语法1

var slice_name []TYPE
1

• slice_name：切片名
• TYPE：切片类型

语法2

//使用make函数定义切片时，会同时将切片初始化
slice_name := make([]TYPE,SIZE)
1
2

• slice_name：切片名
• TYPE：切片中元素的类型
• SIZE：初始化切片的大小

package main

import "fmt"

func main() {

	//切片的定义
	var s1 []int
	s1 = append(s1, 1)
	fmt.Printf("s1: %v\n", s1)

	//make定义切片的同时会将其初始化
	s2 := make([]string, 10)
	fmt.Printf("s2: %v\n", s2)

	//访问切片中的元素
	fmt.Printf("s1[0]: %v\n", s1[0])

	//在切片的末尾添加元素
	s1 = append(s1, 2)
	fmt.Printf("s1: %v\n", s1)
	//修改切片中的元素
	s1[0] = 100
	fmt.Printf("s1: %v\n", s1)

	//获取切片的大小
	fmt.Printf("len(s1): %v\n", len(s1))

	fmt.Printf("cap(s1): %v\n", cap(s1))

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

运行结果

s1: [1]
s2: [         ]
s1[0]: 1
s1: [1 2]
s1: [100 2]
len(s1): 2
cap(s1): 2
1
2
3
4
5
6
7

切片的初始化

package main

import "fmt"

func main() {

	//切片的初始化
	//方法一
	var s1 = []int{1, 2, 3}
	fmt.Printf("s1: %v\n", s1)

	//方法二：make
	s2 := make([]int, 10)
	fmt.Printf("s2: %v\n", s2)

	//方法三：借助数组
	arr := [3]int{1, 2, 3}
	s3 := arr[:]
	fmt.Printf("s3: %v\n", s3)

	//切片/数组/字符串的切片操作： s[a:b] 左闭右开 于python不一样的是，go语言中不能修改步长，步长只能是1
	s4 := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	fmt.Printf("s4[1:9]: %v\n", s4[1:3])
    
    //访问操作和遍历操作同数组
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

运行结果

s1: [1 2 3]
s2: [0 0 0 0 0 0 0 0 0 0]
s3: [1 2 3]
s4[1:9]: [2 3]
1
2
3
4

切片的crud操作

package main

import (
	"fmt"
)

func main() {

	s := []int{1, 2, 3, 4, 5}

	//add
	s = append(s, 1)
	fmt.Printf("s: %v\n", s)

	//delete：删除索引为index的元素
	index := 2
	s = append(s[:index], s[index+1:]...)
	fmt.Printf("s: %v\n", s)

	//update
	s[4] = 6
	fmt.Printf("s: %v\n", s)

	//query
	target := 5
	for i, v := range s {
		if v == target {
			println("找到了！", i)
			break
		}

	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

运行结果

s: [1 2 3 4 5 1]
s: [1 2 4 5 1]
s: [1 2 4 5 6]
找到了！ 3
1
2
3
4

map

map是一种key:value键值对的数据结构。map内部实现是hash表。map最重要的一点是通过key能够快速的检索出数据。

map的定义

var m[K_TYPE]V_TYPE
1

• m：map名
• K_TYPE：key的类型
• V_TYPE：value的类型

package main

import (
	"fmt"
)

func main() {

	//map的定义
	//方法一
	var m1 map[string]string
	fmt.Printf("m1: %v\n", m1)

	//方法二
	m2 := make(map[string]string)
	fmt.Printf("m2: %v\n", m2)

	//map的初始化
	var m3 = map[string]string{
		"name": "Tom",
		"age":  "18",
	}
	fmt.Printf("m3: %v\n", m3)

	//增加/修改map
	m3["num"] = "1234"
	m3["age"] = "20"
	fmt.Printf("m3: %v\n", m3)

	//根据k获取v
	fmt.Printf("m3[\"name\"]: %v\n", m3["name"])

	//判断某个k是否存在  v,ok=m[k]--->如果k存在，ok为true，否则为false
	v, ok := m3["name"]
	if ok {
		print(v)
	}

	//删除某个k
	delete(m3, "age")
	fmt.Printf("m3: %v\n", m3)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

运行结果

m1: map[]
m2: map[]
m3: map[age:18 name:TOm]
m3: map[age:20 name:TOm num:1234]
m3["name"]: TOm
TOmm3: map[name:TOm num:1234]
1
2
3
4
5
6

map的遍历

通过for range对map进行遍历。

package main

import "fmt"

func main() {

	var m = map[string]string{
		"name": "Tom",
		"age":  "18",
		"num":  "1234",
	}

	//for range遍历
	//1.只拿到key
	for k := range m {
		fmt.Printf("k: %v v: %v\n", k, m[k])
	}

	//2.同时拿到k和v
	for k, v := range m {
		fmt.Printf("k: %v v: %v\n", k, v)
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

运行结果

k: name v: Tom
k: age v: 18
k: num v: 1234
k: num v: 1234
k: name v: Tom
k: age v: 18
1
2
3
4
5
6

同步更新于个人博客系统：golang学习笔记系列之复杂数据类型