指定元素位置进行初始化数组

数组是一种数据结构，可以放入一组类型相同的元素。

数组有一个特定的容量，而且不能增长或者收缩。

示例声明数组

 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]

指定元素位置进行 初始化数组

指定元素位置进行初始化数组