Golang 数组 切片 字典 基本知识点

数组

数组的声明

var arrayName [arraySize]dataType
eg:
var array1 [5]int

在声明数组时，必须指定数组名，数组长度和数组元素的类型。

数组的初始化

当数组定义好以后，如果没有给数组元素指定值，则所有元素被自动初始化为类型所对应的零值

var array1 [5]int
// [0 0 0 0 0]

变量的类型零值

在Go语言中，当一个变量被定义为某一种类型后，Go语言会自动初始化其值为零（Zero Value）

零值并不等于空值，而是当变量被声明为某种类型后的默认值

规律：

1. 数值类型的默认值为0
2. 布尔类型的默认值为false
3. 字符串类型会初始化为空字符串
4. 其他类型为nil,表示没有分配内存地址，使用前必须人为分配内存地址

（1）在定义数组时对数组元素赋初值

var array1 = [5]int{0, 1, 2, 3, 4}
// [0 1 2 3 4]

注意：花括号中的元素个数不得超过arraySize

（2）可以只给一部分元素赋初值

var array1 = [5]int{0, 1, 2}
// [0 1 2 0 0]

注意：未赋值的默认初始化为类型零值

（3）可以由初始化列表决定数组长度

var array1 = [...]int{0, 1, 2, 4, 5, 6}
// [0 1 2 4 5 6]

注意：

• 该例中数组长度为 ··· 标识符，表示没有指定数组长度，数组长度由初始化列表决定

• ··· 标识符不可省略，否则将变成后文将要讲的切片

（4）按照下标初始化元素

var array1 = [5]int{0: 5, 4: 5}
// [5 0 0 0 5]

数组元素的访问和遍历

访问

数组元素按照下标进行访问，下标从0开始，可以是整型常量或者整型表达式

var array1 = [8]int{1, 2, 3, 4, 5, 6, 7, 8}
fmt.Println(array1[0], array1[6], array1[2*3])
// 1 7 7

遍历

（1）for语句

var array1 = [8]int{1, 2, 3, 4, 5, 6, 7, 8}
for i := 0; i < 8; i++ {
fmt.Printf("%d ", array1[i])
}
// 1 2 3 4 5 6 7 8

（2）for range语句

var array1 = [3]int{1, 2, 3}
for i, v := range array1 {
fmt.Printf("index is %d, value is %d.\n", i, v)
}
// index is 0, value is 1.
// index is 1, value is 2.
// index is 2, value is 3.

range 具有两个返回值，第一个返回值i是数组元素的下标，第二个返回值v是数组元素的值

二维数组

var array2 = [3][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}, {}} // 三行四列
fmt.Println(array2)
// [[1 2 3 4] [5 6 7 8] [0 0 0 0]]

切片

切片（slice）是数组的一个引用，它会生成一个指向数组的指针，并通过切片长度关联到底层数组部分或者全部元素。

切片中的元素是可以动态增加，删除的，所以切片通常被用来实现变长数组。

切片的数据结构原型定义如下（

Go/src/runtime/slice.go

type slice struct {
array unsafe.Pointer    // 指向被引用的底层数组的指针
len   int               // 切片中元素的个数
cap   int               // 切片分配的存储空间
}

切片的声明与创建

（1）直接创建切片

var slice1 = []int{1, 2, 3, 4}
fmt.Println(slice1, len(slice1), cap(slice1))
// [1 2 3 4] 4 4

（2）基于底层数组创建切片

在创建切片时，可以基于一个底层数组，切片可以只使用数组的一部分元素，或者所有元素

var slice1 []int  // 注意和数组的区别
// 当一个切片定义好以后，如果还没有被初始化，默认值为nil
fmt.Println(slice1, len(slice1), cap(slice1))
// 使用len()获取切片的长度，使用cap()获取切片的容量
// [] 0 0

// 使用slice1 = array1[start:end]引用底层数组来初始化切片
// 即切片引用数组元素由array1[start]到array2[end],但不包括array1[end]
// start默认值为0，end默认值为len(array1)
var array1 = [5]int{1, 2, 3, 4, 5}
slice1 = array1[:]
fmt.Println(slice1, len(slice1), cap(slice1))
// [1 2 3 4 5] 5 5

var slice2 []int
slice2 = array1[1:4]
fmt.Println(slice2, len(slice2), cap(slice2))
// [2 3 4] 3 4

（3）使用make函数创建切片

var sliceName = make(sliceType,len,cap)
// 使用make()函数创建切片时，可以指定切片的元素个数，并且为切片元素预留存储空间
// 在后文切片的操作部分，我们会讲解指定（预估）切片容量的好处
eg:
var slice1 = make([]int, 3, 5)  // 切片的元素个数为3，切片的容量为5
fmt.Println(slice1, len(slice1), cap(slice1))
// [0 0 0] 3 5

切片元素的访问和遍历

这个和数组元素的访问以及遍历是一样的

切片的内置操作

（1）len()

获取切片中元素的个数

（2）cap()

获取切片的容量大小

（3）append()

• 使用append()函数向切片尾部添加新元素，这些元素保存到底层数组

• append()并不会影响原来切片的属性，它返回变更后新的切片对象

var slice1 = make([]int, 3, 5)
fmt.Println(slice1, len(slice1), cap(slice1))  // [0 0 0] 3 5
slice2 := append(slice1, 1) // 返回一个新的切片对象
fmt.Println(slice1, len(slice1), cap(slice1))   // slice1没有发生发生变化
// [0 0 0] 3 5
fmt.Println(slice2, len(slice2), cap(slice2))  // [0 0 0 1] 4 5
slice2 = append(slice2, 2)  // 将新的切片对象重新赋值给slice2
fmt.Println(slice2, len(slice2), cap(slice2))  // [0 0 0 1 2] 5 5

注意：

• 与数组相比，切片多了一个容量的概念，即切片中元素的个数和分配的存储空间是两个不同的值

• 如果在append后，没有超过切片的容量大小，哪么容量不会发生变化

• 如果append后，超过了容量大小，则底层会重新分配一块“够大”的内存，具体的扩容机制可以在

  Go\src\runtime\slice.go

  文件中的

  growslice

  函数中看到

• 正如前面我们在使用make()函数创建切片时，如果我们能够预计出合理的容量大小（太大浪费内存空间，太小会不断的扩容），哪么我们在进行切片的append时，可能不会发生扩容，也就避免了切片元素的复制，减少了开销。

（4）copy()

// The copy built-in function copies elements from a source slice into a
// destination slice. (As a special case, it also will copy bytes from a
// stri
576
ng to a slice of bytes.) The source and destination may overlap. Copy
// returns the number of elements copied, which will be the minimum of
// len(src) and len(dst).
func copy(dst, src []Type) int

var slice1 = []int{1, 2, 3, 4, 5, 6}
var slice2 = make([]int, 3, 5)
num := copy(slice2, slice1)
fmt.Println(slice1)  // [1 2 3 4 5 6]
fmt.Println(slice2)  // [1 2 3]
fmt.Println(num)  // 3

字典

Map是一种特殊的数据结构，由一对无序的数据项组成，被称为键值对（Key-value Pair）

字典的声明

var mapName map[keyType]valueType
eg:
var map1 map[string]int
// 字典声明好后必须经过初始化或者创建才能使用
// 未初始化或创建的字典值为nil

字典的初始化和创建

（1）使用

{}

var map1 map[string]int
map1["egg"] = 1  // 对字典没有初始化就尝试增加数据，编译时就会报错
panic: assignment to entry in nil map

var map1 = map[string]int{} // ！！！使用{}来初始化map，也就意味着系统给map1分配了存储空间
map1["apple"] = 2  // 使用=向map中添加元素
fmt.Println(map1)  // map[apple:2]

var map1 =
aec
map[string]int{"microsoft":0}  //在初始化的时候就指定key-value元素

（2）使用

make()

var map1 = make(map[string]int)  // 如下引用所示，我们可以指定map的长度，也可以省略
// 注意：make创建map是不可指定cap属性，当然cap()函数也不可用于map类型
map1["egg"] = 1
fmt.Println(map1) // map[egg:1]

//  Map: An empty map is allocated with enough space to hold the
// specified number of elements. The size may be omitted, in which case
// a small starting size is allocated.
func make(t Type, size ...IntegerType) Type

字典的访问和遍历

（1）通过key来访问Value

var map1 = map[string]int{"Microsoft": 0}
map1["egg"] = 1
map1["apple"] = 2
fmt.Println(map1)        // map[Microsoft:0 apple:2 egg:1]
// 通过Key来访问value
fmt.Println(map1["egg"]) // 1

（2）字典项查找

v,ok := mapName[Key]
// 如果查找的key值存在，则将key对应的value值赋予v,ok为true
// 如果查找的key值不存在，则将v为0，ok为false
eg:
if _, ok := map1["agg"]; ok == false {
map1["agg"] = 666
}
fmt.Println(map1) // map[Microsoft:0 agg:666 apple:2 egg:1]

（3）使用for,range遍历

for k, v := range map1 {
fmt.Printf("key is %s,value is %d.\n", k, v)
}
// key is Microsoft,value is 0.
// key is egg,value is 1.
// key is apple,value is 2.
// key is agg,value is 666.

注意：map是无序的，所以遍历的结果也是无序的。

字典的内置操作

（1）len()

获取字典元素的个数

（2）delete（）

// The delete built-in function deletes the element with the specified key
// (m[key]) from the map. If m is nil or there is no such element, delete
// is a no-op.
func delete(m map[Type]Type1, key Type)

var map1 = map[string]int{"Microsoft": 0}
map1["egg"] = 1
map1["apple"] = 2
fmt.Println(map1) // map[Microsoft:0 apple:2 egg:1]

delete(map1, "egg") // key存在于map1中
fmt.Println(map1)   // map[Microsoft:0 apple:2]

delete(map1, "none") // key不存在于map1中,没有任何作用，不会panic
fmt.Println(map1)    // map[Microsoft:0 apple:2]

var map2 map[string]int
delete(map2, "nil") // map2为nil，也没有任何作用,不会panic
fmt.Println(map2)   // map[]
总结
小结
本文简述了Go语言中最基本，最常用的三种数据结构的基本知识点，在掌握基础后，我们可以针对自己的兴趣点，去深入的研究底层的知识。
参考资料
《Go语言程序设计》王鹏 编著 清华大学出版社