数组是一种数据结构，可以放入一组类型相同的元素。
数组有一个特定的容量，而且不能增长或者收缩。
示例 声明数组
package main
import (
"fmt"
"reflect"
)
func main() {
var intArray [5]int
var strArray [5]string
fmt.Println(reflect.ValueOf(intArray).Kind())
fmt.Println(reflect.ValueOf(strArray).Kind())
}
赋值和访问
使用索引需要，对数组进行访问和赋值
下面代码示例
package main
import "fmt"
func main() {
var theArray [3]string
theArray[0] = "India" // Assign a value to the first element
theArray[1] = "Canada" // Assign a value to the second element
theArray[2] = "X" // Assign a value to the third element
fmt.Println(theArray[0]) // Access the first element value
fmt.Println(theArray[1]) // Access the second element valu
fmt.Println(theArray[2]) // Access the third element valu
}
用字面值在数组初始化时赋值
初始化的值在 类型后面，用打括号括起来，各个值之间用逗号分隔。
package main
import "fmt"
func main() {
x := [5]int{10, 20, 30, 40, 50} // Intialized with values
var y [5]int = [5]int{10, 20, 30} // 部分赋值，后面的赋零值
fmt.Println(x)
fmt.Println(y)
} 输出
[10 20 30 40 50]
[10 20 30 0 0]
使用省略号声明数组
可以用省略号代替 数组的长度，编译器会自动根据后面初始化值的数量，来判定数组的长度。
package main
import (
"fmt"
"reflect"
)
func main() {
x := [...]int{10, 20, 30}
fmt.Println(reflect.ValueOf(x).Kind())
fmt.Println(len(x))
} 输出
array
3
指定元素位置进行 初始化数组
使用索引值和冒号，可以在初始化时，指定特定位置的元素进行初始化。
package main
import "fmt"
func main() {
x := [5]int{1: 10, 3: 30}
fmt.Println(x)
} 输出
[0 10 0 30 0]
循环遍历数组
下面展示，几种遍历数组的方法，使用for循环。
package main
import "fmt"
func main() {
intArray := [5]int{10, 20, 30, 40, 50}
fmt.Println("\n---------------Example 1--------------------\n")
for i := 0; i < len(intArray); i++ {
fmt.Println(intArray[i])
}
fmt.Println("\n---------------Example 2--------------------\n")
for index, element := range intArray {
fmt.Println(index, "=>", element)
}
fmt.Println("\n---------------Example 3--------------------\n")
for _, value := range intArray {
fmt.Println(value)
}
j := 0
fmt.Println("\n---------------Example 4--------------------\n")
for range intArray {
fmt.Println(intArray[j])
j++
}
}
复制数组
数组可以按照值复制，也可以只复制引用。
strArray2 := strArray1 这种赋值，是复制了一份新的值。两个数组是隔离的，改动互相不会影响。
strArray3 := &strArray1 这种赋值，明显是取地址，因此，两个变量，指向的是同一个具体的数组。修改其中一个，会在两个变量都表现出来。
package main
import "fmt"
func main() {
strArray1 := [3]string{"Japan", "Australia", "Germany"}
strArray2 := strArray1 // data is passed by value
strArray3 := &strArray1 // data is passed by refrence
fmt.Printf("strArray1: %v\n", strArray1)
fmt.Printf("strArray2: %v\n", strArray2)
strArray1[0] = "Canada"
fmt.Printf("strArray1: %v\n", strArray1)
fmt.Printf("strArray2: %v\n", strArray2)
fmt.Printf("*strArray3: %v\n", *strArray3)
} 输出
strArray1: [Japan Australia Germany]
strArray2: [Japan Australia Germany]
strArray1: [Canada Australia Germany]
strArray2: [Japan Australia Germany]
*strArray3: [Canada Australia Germany]
检查元素是否存在数组中
检查元素是否在数组中，下面itemExists这个方法中，用到了反射reflect。
package main
import (
"fmt"
"reflect"
)
func main() {
strArray := [5]string{"India", "Canada", "Japan", "Germany", "Italy"}
fmt.Println(itemExists(strArray, "Canada"))
fmt.Println(itemExists(strArray, "Africa"))
}
func itemExists(arrayType interface{}, item interface{}) bool {
arr := reflect.ValueOf(arrayType)
if arr.Kind() != reflect.Array {
panic("Invalid data-type")
}
for i := 0; i < arr.Len(); i++ {
if arr.Index(i).Interface() == item {
return true
}
}
return false
}
截取数组的一部分
在方括号中，使用冒号，可以截取数组的一部分。
package main
import "fmt"
func main() {
countries := [...]string{"India", "Canada", "Japan", "Germany", "Italy"}
fmt.Printf("Countries: %v\n", countries)
fmt.Printf(":2 %v\n", countries[:2])
fmt.Printf("1:3 %v\n", countries[1:3])
fmt.Printf("2: %v\n", countries[2:])
fmt.Printf("2:5 %v\n", countries[2:5])
fmt.Printf("0:3 %v\n", countries[0:3])
fmt.Printf("Last element: %v\n", countries[len(countries)-1])
fmt.Printf("All elements: %v\n", countries[0:len(countries)])
fmt.Println(countries[:])
fmt.Println(countries[0:])
fmt.Println(countries[0:len(countries)])
fmt.Printf("Last two elements: %v\n", countries[len(countries)-2:len(countries)])
} 输出
2: [Japan Germany Italy]
2:5 [Japan Germany Italy]
0:3 [India Canada Japan]
Last element: Italy
All elements: [India Canada Japan Germany Italy]
[India Canada Japan Germany Italy]
[India Canada Japan Germany Italy]
[India Canada Japan Germany Italy]
Last two elements: [Germany Italy]
