2.1.指定长度的数组
func test20() {
var array1 = [5]int{1, 2, 3, 4, 5}
for i := 0; i < len(array1); i++ {
println(array1[i])
}
println("------")
array2 := [5]int{5, 4, 3, 2, 1}
for i := 0; i < len(array2); i++ {
println(array2[i])
}
}
结果：
1
2
3
4
5
------
5
4
3
2
1
2.2.自动计算长度的数组
func test20() {
array3 := [...]int{5, 4, 3, 2, 1}
for i := 0; i < len(array3); i++ {
println(array3[i])
}
}
结果：
5
4
3
2
1
2.3.指定索引的值的数组
func test20() {
array4 := [...]int{2: 5, 4: 7}
for i := 0; i < len(array4); i++ {
println(array4[i])
}
}
结果：
0
0
5
0
7
说明：指定索引为2 和4的值， 其他未指定值的索引，默认为0。
2.4.二维数组
func test20() {
array5 := [3][2]int{{1, 2}, {3, 4}, {5, 6}}
for i := 0; i < len(array5); i++ {
var item_array = array5[i]
for j := 0; j < len(item_array); j++ {
println(array5[i][j])
}
}
}
结果：
1
2
3
4
5
6
说明：第一个数是指整个数组的最大长度为3, 里面数组的最大长度为2。
2.5.多维数组
func test20() {
array6 := [3][2][3]int{{{1, 2, 3}, {4, 5, 6}}, {{7, 8, 9}, {10, 11, 12}}, {{13, 14, 15}, {16, 17, 18}}}
for i := 0; i < len(array6); i++ {
for j := 0; j < len(array6[i]); j++ {
for k := 0; k < len(array6[i][j]); k++ {
println(array6[i][j][k])
}
}
}
}
结果：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2.6.数组作为函数形参
2.6.1.指定长度的数组
package main
import (
"fmt"
)
func main() {
array7 := [3]int{1, 2, 3}
test21(array7)
}
func test21(array7 [3]int) {
for i := 0; i < len(array7); i++ {
println(array7[i])
}
}
1
2
3
2.6.2.未指定长度的数组
package main
import (
"fmt"
)
func main() {
array8 := []int{1, 2, 3, 4}
test22(array8)
}
func test22(array8 []int) {
for i := 0; i < len(array8); i++ {
println(array8[i])
}
}
结果：
1
2
3
4
2.7.数组作形参：指针数组
2.7.1.指定数组长度
package main
import (
"fmt"
)
func main() {
array9 := [6]int{6, 5, 4, 3, 2, 1}
test23V1(array9)
fmt.Println("no point value: ", array9)
test23V2(&array9) //指针传参， 使用&
fmt.Println("point value: ", array9)
}
func test23V1(array9 [6]int) {
for i := 0; i < len(array9); i++ {
array9[i] = array9[i] * 3
}
}
func test23V2(array9 *[6]int) { //指针传参， 作为ie形参的时候使用*， 并在调用的时候， 使用括号包括起来
for i := 0; i < len(*array9); i++ {
(*array9)[i] = (*array9)[i] * 3
}
}
结果：
no point value: [6 5 4 3 2 1]
point value: [18 15 12 9 6 3]
说明：
当指定数组长度之后，不使用指针传参的， 则原始的数组数据未发生变化， 使用指针传参， 原始数组数据发生改变
2.7.2.未指定数组长度
package main
import (
"fmt"
)
func main() {
array10 := []int{6, 5, 4, 3, 2, 1}
test23V3(array10)
fmt.Println("no point value: ", array10)
test23V4(&array10) //指针传参， 使用&
fmt.Println("point value: ", array10)
}
func test23V3(array10 []int) {
for i := 0; i < len(array10); i++ {
array10[i] = array10[i] * 3
}
}
func test23V4(array10 *[]int) { //指针传参， 作为ie形参的时候使用*， 并在调用的时候， 使用括号包括起来
for i := 0; i < len(*array10); i++ {
(*array10)[i] = (*array10)[i] * 3
}
}
结果：
no point value: [18 15 12 9 6 3]
point value: [54 45 36 27 18 9]
说明：
当未指定数组长度之后，不管使不使用指针传参的， 原始数组的数据都发生改变。
2.8.数组的截取
func test29() {
a := []int{1, 2, 3, 4, 5, 6}
b := a[1:3]
fmt.Printf("b value is %d\n", b)
}
结果：
b value is [2 3]
2.9.数组的追加
func test30() {
a := []int{1}
b := append(a, 2, 3, 4)
fmt.Printf("b value is %d\n", b)
}
结果：
b value is [1 2 3 4]
2.10.数组的拷贝
func test31() {
a := []int{1， 2, 3, 4}
var b = make([]int, len(a), (cap(a))*2)
copy(b, a)
fmt.Printf("a value is %, b value is %d %d\n", a, b)
}
结果：
a value is [1 2 3 4], b value is [1 2 3 4]
2.11.数组的range遍历
func test32() {
a := []int{1, 2, 3, 4, 5}
for index, value := range a {
fmt.Printf("index is %d, value is %d\n", index, value)
}
print("--------------------------\n")
for index := range a {
fmt.Printf("index is %d\n", index)
}
print(("--------------------------\n"))
for _, value := range a {
fmt.Printf("value is %d\n", value)
}
}
结果：
index is 0, value is 1
index is 1, value is 2
index is 2, value is 3
index is 3, value is 4
index is 4, value is 5
--------------------------
index is 0
index is 1
index is 2
index is 3
index is 4
--------------------------
value is 1
value is 2
value is 3
value is 4
value is 5