数组：同一种数据类型的集合，go中，数组在声明时就必须确定、使用时可以修改数组中元素、但数组大小，即数组长度不可变；
定义语法：
// 定义一个长度为3，元素数据类型为int的数组
var a [3]int
// 语法
var 数组变量名 [数组的长度]数组中元素类型
数组中，数组长度必须是常量，并长度属于数组类型的一部分，长度不同的数组，属于不同的数据类型，如[5]int 和[10]int属于不同类型；
var a [4]int
var b [6]int
a = b // 不可以将b赋值给不属于同类型的a
数组，可以通过下标访问，下标从0开始，最后一个下标，len-1，访问越界时，会触发访问越界，panic；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
package main
import "fmt"
func main() {
// 数组定义法1
var array1 [3]int // 数组定义时，没指定元素值时，默认值为该类型的默认值，int是0，bool是false
var array2 = [3]int{1, 2} // 第三个元素补0
var cityArray = [3]string{"北京", "上海", "杭州"}
fmt.Println(array1)
fmt.Println(array2)
fmt.Println(cityArray)
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\05_array>go run main.go
[0 0 0]
[1 2 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
25
26
27
28
29
30
31
32
33
34
35
36
|
package main
import "fmt"
func main() {
// 数组定义法1
var array1 [3]int
var array2 = [3]int{1, 2}
var cityArray = [3]string{"北京", "上海", "杭州"}
fmt.Println(array1)
fmt.Println(array2)
fmt.Println(cityArray)
// 数组定义法2，根据数组元素个数，推断数组长度，
var array3 [2]bool
var array4 = [...]int{1,2,3,4,5}
var array5 = [...]string{"你好","杭州"}
fmt.Println(array3)
fmt.Printf("type of array4:%T", array4)
fmt.Println(array4)
fmt.Printf("type of array5:%T", array5)
fmt.Println(array5)
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\05_array>go run main.go
[0 0 0]
[1 2 0]
[北京 上海 杭州]
[false false]
type of array4:[5]int[1 2 3 4 5]
type of array5:[2]string[你好 杭州]
|
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
|
package main
import "fmt"
func main() {
// 数组定义法1
var array1 [3]int
var array2 = [3]int{1, 2}
var cityArray = [3]string{"北京", "上海", "杭州"}
fmt.Println(array1)
fmt.Println(array2)
fmt.Println(cityArray)
// 数组定义法2，根据数组元素个数，推断数组长度，
var array3 [2]bool
var array4 = [...]int{1,2,3,4,5}
var array5 = [...]string{"你好","杭州"}
fmt.Println(array3)
fmt.Printf("type of array4:%T", array4)
fmt.Println(array4)
fmt.Printf("type of array5:%T", array5)
fmt.Println(array5)
// 数组定义3，指定索引初始化数组中特定索引的值
a := [...]int{1:1,3:5}
fmt.Println(a)
fmt.Printf("type of a: %T\n", a)
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\05_array>go run main.go r\05_array>
[0 0 0]
[1 2 0]
[北京 上海 杭州]
[false false]
type of array4:[5]int[1 2 3 4 5]
type of array5:[2]string[你好 杭州]
[0 1 0 5]
type of a: [4]int
|
数组遍历有2种方式，
- for结合len，根据数组长度遍历
- for range，直接遍历数组
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
|
package main
import "fmt"
func main() {
// 数组遍历
a := [...]int{1, 3, 4, 7, 9}
for i := 0; i < len(a); i++ {
fmt.Println(a[i])
} // for结合len遍历
for index, value := range a {
fmt.Printf("%v: %v\n", index, value)
}// for range 遍历
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\05_array>go run main.go
1
3
4
7
9
0: 1
1: 3
2: 4
3: 7
4: 9
|
go支持多维数组，即数组中的元素类型是数组，数组嵌套数组
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package main
import "fmt"
func main() {
// 多维数组
a := [3][2]string {
{"haha","xixi"},
{"gogo","java"},
{"python","C"},
}
fmt.Println(a)
fmt.Printf(a[2][1])
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\05_array>go run main.go
[[haha xixi] [gogo java] [python C]]
C
|
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
|
package main
import "fmt"
func main() {
// 多维数组
a := [3][2]string{
{"haha", "xixi"},
{"gogo", "java"},
{"python", "C"},
}
// 多维数组遍历
for _, v1 := range a {
for _, v2 := range v1 {
fmt.Printf("%s\t", v2)
}
fmt.Println()
}
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\05_array>go run main.go
haha xixi
gogo java
python C
|
注：多维数组，只有最外层支持编译器推导数组长度
// 多维数组
a := [...][2]string{
{"haha", "xixi"},
{"gogo", "java"},
{"python", "C"},
}
数组是值类型、赋值和传参会复制整个数组，因此改变副本的值，不会改变本身的值！
与之相对的，是引用类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
package main
import "fmt"
func modifyArray(x [3]int) {
x[0] = 666
fmt.Println(x)
}
func main() {
// 数组是值类型
a := [3]int{1,2,3}
modifyArray(a)
fmt.Println(a)
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\05_array>go run main.go
[666 2 3]
[1 2 3]
// 可以看到，修改时，只是修改了数组的副本，
|
ps:
- 数组，支持== != 操作符，因为内存总是被初始化过的；
- [n]*T 表示指针数组，*[n]T表示数组指针
-
求数组[1, 3, 5, 7, 8]所有元素的和
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
package main
import "fmt"
func main() {
a := [...]int{1,3,5,7,8}
sum := 0
for _,v := range a {
sum += v
}
fmt.Println(sum)
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\05_array>go run main.go
24
|
-
找出数组中和为指定值的两个元素的下标，比如从数组[1, 3, 5, 7, 8]中找出和为8的两个元素的下标分别为(0,3)和(1,2)。
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
|
package main
import "fmt"
func main() {
a := [...]int{1, 3, 5, 7, 8}
sum := 0
for _, v := range a {
sum += v
}
fmt.Println(sum)
for i := 0; i < len(a); i++ {
for j := i + 1; j < len(a); j++ {
if a[i]+a[j] == 8 {
fmt.Printf("(%v,%v)", i, j)
}
}
}
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\05_array>go run main.go
24
(0,3)(1,2)
|