go语言渐入佳境[12]-array

数组声明与定义

1
2
3
4
//声明三种方式
var arr [3]int
var arr2 = [4]int{1,2,3,4}
arr4 :=[...] int{2,3,4}

打印数组

1
fmt.Println(arr4)

数组类型

1
fmt.Printf("类型arr3: %T,类型arr4: %T\n",arr3,arr4)

数组长度与下标

1
2
fmt.Println("arr3的长度为:",len(arr3))
fmt.Println("arr3的下标为2:",arr3[2])

##遍历数组两种方式

1
2
3
4
5
6
7
8
9
10
//遍历数组
for i:=0;i<len(arr3);i++{
fmt.Println(arr3[i])
}
//遍历数组2

for _,value:=range arr3{

fmt.Println(value)
}

冒泡排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//冒泡排序

func array(){

arr :=[10]int{1,3,2,4,9,2,6,5,4,8}
fmt.Println("一开始:",arr)



for i:=0;i<len(arr)-1;i++{

for j:=0;j<len(arr)-1-i;j++{

if(arr[j] >arr[j+1]){
temp:=arr[j]
arr[j] = arr[j+1]
arr[j+1] = temp
}
fmt.Println(arr)
}
}
fmt.Println("结束:",arr)
}

二维数组

1
2
3
4
5
6
7
8
9
10
11
func twoarray(){

a :=[3][3]int{{1,2,3},{4,5,6},{7,8,9}}
for i:=0;i<len(a);i++{

for j:=0;j<len(a[0]);j++{
fmt.Printf("a[%d][%d]=%d\n",i,j,a[i][j])
}
}

}

全部例子代码

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
package main

import "fmt"

//声明
var arr [3]int
var arr2 = [4]int{1,2,3,4}


func main(){
arr3 := [4]float64{1,2,3,4}
fmt.Println(arr3)

arr4 :=[...] int{2,3,4}

fmt.Println(arr4)

fmt.Printf("类型arr3: %T,类型arr4: %T\n",arr3,arr4)

fmt.Println("arr3的长度为:",len(arr3))
fmt.Println("arr3的下标为2:",arr3[2])

//遍历数组
for i:=0;i<len(arr3);i++{
fmt.Println(arr3[i])
}
//遍历数组2

for _,value:=range arr3{

fmt.Println(value)
}

array()
twoarray()
}

//冒泡排序

func array(){

arr :=[10]int{1,3,2,4,9,2,6,5,4,8}
fmt.Println("一开始:",arr)



for i:=0;i<len(arr)-1;i++{

for j:=0;j<len(arr)-1-i;j++{

if(arr[j] >arr[j+1]){
temp:=arr[j]
arr[j] = arr[j+1]
arr[j+1] = temp
}
fmt.Println(arr)
}
}
fmt.Println("结束:",arr)
}

func twoarray(){

a :=[3][3]int{{1,2,3},{4,5,6},{7,8,9}}
for i:=0;i<len(a);i++{

for j:=0;j<len(a[0]);j++{
fmt.Printf("a[%d][%d]=%d\n",i,j,a[i][j])
}
}

}

数组是一个由固定长度的特定类型元素组成的序列,一个数组可以由零个或多个元素组成。因为数组的长度是固定的,因此在Go语言中很少直接使用数组。和数组对应的类型是Slice(切片),它是可以增长和收缩动态序列,slice功能也更灵活,但是要理解slice工作原理的话需要先理解数组。
数组的每个元素可以通过索引下标来访问,索引下标的范围是从0开始到数组长度减1的位置。内置的len函数将返回数组中元素的个数。

1
2
3
4
5
6
7
8
9
10
11
12
13
var a [3]int             // array of 3 integers
fmt.Println(a[0]) // print the first element
fmt.Println(a[len(a)-1]) // print the last element, a[2]

// Print the indices and elements.
for i, v := range a {
fmt.Printf("%d %d\n", i, v)
}

// Print the elements only.
for _, v := range a {
fmt.Printf("%d\n", v)
}

默认情况下,数组的每个元素都被初始化为元素类型对应的零值,对于数字类型来说就是0。我们也可以使用数组字面值语法用一组值来初始化数组:
var q [3]int = [3]int{1, 2, 3}
var r [3]int = [3]int{1, 2}
fmt.Println(r[2]) // “0”
在数组字面值中,如果在数组的长度位置出现的是“…”省略号,则表示数组的长度是根据初始化值的个数来计算。因此,上面q数组的定义可以简化为
q := […]int{1, 2, 3}
fmt.Printf("%T\n", q) // “[3]int”
数组的长度是数组类型的一个组成部分,因此[3]int和[4]int是两种不同的数组类型。数组的长度必须是常量表达式,因为数组的长度需要在编译阶段确定。
q := [3]int{1, 2, 3}
q = [4]int{1, 2, 3, 4} // compile error: cannot assign [4]int to [3]int
我们将会发现,数组、slice、map和结构体字面值的写法都很相似。上面的形式是直接提供顺序初始化值序列,但是也可以指定一个索引和对应值列表的方式初始化,就像下面这样:
type Currency int

const (
USD Currency = iota // 美元
EUR // 歐元
GBP // 英鎊
RMB // 人民幣
)

symbol := […]string{USD: “$”, EUR: “€”, GBP: “£”, RMB: “¥”}

fmt.Println(RMB, symbol[RMB]) // “3 ¥”
在这种形式的数组字面值形式中,初始化索引的顺序是无关紧要的,而且没用到的索引可以省略,和前面提到的规则一样,未指定初始值的元素将用零值初始化。例如,
r := […]int{99: -1}
定义了一个含有100个元素的数组r,最后一个元素被初始化为-1,其它元素都是用0初始化。
如果一个数组的元素类型是可以相互比较的,那么数组类型也是可以相互比较的,这时候我们可以直接通过==比较运算符来比较两个数组,只有当两个数组的所有元素都是相等的时候数组才是相等的。不相等比较运算符!=遵循同样的规则。
a := [2]int{1, 2}
b := […]int{1, 2}
c := [2]int{1, 3}
fmt.Println(a == b, a == c, b == c) // “true false false”
d := [3]int{1, 2}
fmt.Println(a == d) // compile error: cannot compare [2]int == [3]int
作为一个眞实的例子,crypto/sha256包的Sum256函数对一个任意的字节slice类型的数据生成一个对应的消息摘要。消息摘要有256bit大小,因此对应[32]byte数组类型。如果两个消息摘要是相同的,那么可以认为两个消息本身也是相同(译注:理论上有HASH码碰撞的情况,但是实际应用可以基本忽略);如果消息摘要不同,那么消息本身必然也是不同的。下面的例子用SHA256算法分别生成“x”和“X”两个信息的摘要:

1
2
3
4
5
6
7
8
9
10
11
12
13

import "crypto/sha256"

func main() {
c1 := sha256.Sum256([]byte("x"))
c2 := sha256.Sum256([]byte("X"))
fmt.Printf("%x\n%x\n%t\n%T\n", c1, c2, c1 == c2, c1)
// Output:
// 2d711642b726b04401627ca9fbac32f5c8530fb1903cc4db02258717921a4881
// 4b68ab3847feda7d6c62c1fbcbeebfa35eab7351ed5e78f4ddadea5df64b8015
// false
// [32]uint8
}

上面例子中,两个消息虽然只有一个字符的差异,但是生成的消息摘要则几乎有一半的bit位是不相同的。需要注意Printf函数的%x副词参数,它用于指定以十六进制的格式打印数组或slice全部的元素,%t副词参数是用于打印布尔型数据,%T副词参数是用于显示一个值对应的数据类型。
当调用一个函数的时候,函数的每个调用参数将会被赋值给函数内部的参数变量,所以函数参数变量接收的是一个复制的副本,并不是原始调用的变量。因为函数参数传递的机制导致传递大的数组类型将是低效的,并且对数组参数的任何的修改都是发生在复制的数组上,并不能直接修改调用时原始的数组变量。在这个方面,Go语言对待数组的方式和其它很多编程语言不同,其它编程语言可能会隐式地将数组作为引用或指针对象传入被调用的函数。
当然,我们可以显式地传入一个数组指针,那样的话函数通过指针对数组的任何修改都可以直接反馈到调用者。下面的函数用于给[32]byte类型的数组清零:

1
2
3
4
5
6
7
8
9
func zero(ptr *[32]byte) {
for i := range ptr {
ptr[i] = 0
}
}
//其实数组字面值[32]byte{}就可以生成一个32字节的数组。而且每个数组的元素都是零值初始化,也就是0。因此,我们可以将上面的zero函数写的更简洁一点:
func zero(ptr *[32]byte) {
*ptr = [32]byte{}
}

虽然通过指针来传递数组参数是高效的,而且也允许在函数内部修改数组的值,但是数组依然是僵化的类型,因为数组的类型包含了僵化的长度信息。上面的zero函数并不能接收指向[16]byte类型数组的指针,而且也没有任何添加或删除数组元素的方法。由于这些原因,除了像SHA256这类需要处理特定大小数组的特例外,数组依然很少用作函数参数;相反,我们一般使用slice来替代数组。