1.數組
1.1數組介紹
數組是同一種數據類型元素的集合。
在Go語言中，數組從聲明時就確定，使用時可以修改數組成員，但是數組大小不可變化。
基本語法：
//定義一個長度爲3，元素類型爲int的數組a
var a [3]int
1.2數組定義
var 數組變量名 [元素數量]T
var a [5]int
1.數組的長度必須是常量，
2.並且長度是數組類型的一部分。一旦定義，長度不能改變。
3.[5]int 和[10]int是不同的類型
var a [3]int
var b [4]int
a = b //不可以這樣做，因爲此時a和b是不同的類型
數組可以通過下標進行訪問，下標是從0開始，最後一個元素下標是len-1,訪問越界（下標在合法範圍外），會觸發訪問越界，會panic。
package main
import "fmt"
func main() {
var a =[2]int{1}
var b =[4]int{1,2,3,4}
fmt.Printf("%T\n",a) //[2]int
fmt.Printf("%T\n",b) //[4]int
fmt.Printf("%#v\n",b[0]) //1
fmt.Printf("%#v\n",b[6]) //invalid array index 6 (out of bounds for 4-element array)
}
1.3數組初始化
1.3.1方式一
初始化數組時，可以使用初始化列表來設置數組元素的值。
package main
import "fmt"
func main() {
var intArray [3]int
var numArray = [5]int{1,2,3,4}
var cityArray = [4]string{"北京","上海"}
fmt.Printf("%#v\n",intArray)
fmt.Printf("%#v\n",numArray)
fmt.Printf("%#v\n",cityArray)
}
結果：
[3]int{0, 0, 0}
[5]int{1, 2, 3, 4, 0}
[4]string{"北京", "上海", "", ""}
1.3.2方式二
按照上買呢的方法，每次都要確保提供的初始值和數組長度一致，一般情況下，我們可以讓編譯器根據初始值的個數，自行推斷數組的長度。
package main
import "fmt"
func main() {
var intArray [3]int
var numArray = [...]int{1,2,3,4}
var cityArray = [...]string{"北京","上海"}
fmt.Printf("%#v----%T\n",intArray,intArray)
fmt.Printf("%#v----%T\n",numArray,numArray)
fmt.Printf("%#v----%T\n",cityArray,cityArray)
}
結果：
[3]int{0, 0, 0}----[3]int
[4]int{1, 2, 3, 4}----[4]int
[2]string{"北京", "上海"}----[2]string
1.3.3方式三
可以使用指定索引值的方式來初始化數組
package main
import "fmt"
func main() {
var intArray =[...]int{1:1,3:5}
fmt.Printf("%#v----%T",intArray,intArray)
}
結果：
[4]int{0, 1, 0, 5}----[4]int
1.4數組的遍歷
package main
import "fmt"
func main() {
var stringArray =[...]string{"北京","上海","深圳"}
//方法一：for循環遍歷
for i:=0;i<len(stringArray);i++{
fmt.Println(stringArray[i])
}
//方法二：for range遍歷
for index,value := range stringArray{
fmt.Println(index,value)
}
}
結果：
北京
上海
深圳
0 北京
1 上海
2 深圳
1.5多維數組
1.5.1二維數組的定義
package main
import "fmt"
func main() {
a:=[3][2]string{
{"北京","上海"},
{"北京1","上海1"},
{"北京2","上海2"},
}
fmt.Println(a)
fmt.Printf("%#v\n",a)
fmt.Println(a[2][1])
}
結果：
[[北京 上海] [北京1 上海1] [北京2 上海2]]
[3][2]string{[2]string{"北京", "上海"}, [2]string{"北京1", "上海1"}, [2]string{"北京2", "上海2"}}
上海2
1.5.2二維數組的遍歷
package main
import "fmt"
func main() {
a:=[3][2]string{
{"北京","上海"},
{"北京1","上海1"},
{"北京2","上海2"},
}
for _,v1 := range a{
for _,v2:= range v1{
fmt.Printf("%s\n",v2)
}
}
}
結果：
北京
上海
北京1
上海1
北京2
上海2
1.5.3多維數組只有第一層可以使用...讓編譯器推導數組的長度
多維數組，只有第一層可以使用...來讓編譯器推導數組長度。
//支持的寫法
a := [...][2]string{
{"北京", "上海"},
{"廣州", "深圳"},
{"成都", "重慶"},
}
//不支持多維數組的內層使用...
b := [3][...]string{
{"北京", "上海"},
{"廣州", "深圳"},
{"成都", "重慶"},
}
1.6數組是值類型
數組是值類型，賦值和傳參會複製整個數組。因此改變副本的值，不會改變本身的值。
package main
import "fmt"
func modifyArray(x [3]int){
x[0]=100
fmt.Printf("modifyArray-x--%#v\n",x)
}
func modifyArray2(x [3][2]int){
x[2][0]=100
fmt.Printf("modifyArray2-x--%#v\n",x)
}
func main() {
a := [3]int{1,2,3}
modifyArray(a)
fmt.Printf("main-a--%#v\n",a)
b := [3][2]int{
{1,2},
{3,4},
}
modifyArray2(b)
fmt.Printf("main-b--%#v\n",b)
}
結果：
modifyArray-x--[3]int{100, 2, 3}
main-a--[3]int{1, 2, 3}
modifyArray2-x--[3][2]int{[2]int{1, 2}, [2]int{3, 4}, [2]int{100, 0}}
main-b--[3][2]int{[2]int{1, 2}, [2]int{3, 4}, [2]int{0, 0}}
注意：
1.數組支持"=="、"!="操作符，因爲內存總是被初始化過的。
2.[n]*T表示指針數組，*[n]T表示數組指針。
1.7練習
1.求數組[1, 3, 5, 7, 8]所有元素的和
package main
import "fmt"
func sumArray(x [5]int)(sum int){
sum = 0
for _,v := range x{
sum+=v
}
return sum
}
func main() {
a := [5]int{1,3,5,7,8}
sum := sumArray(a)
fmt.Println(sum)
}
結果：
24
2.找出數組中和爲指定值的兩個元素的下標，比如從數組[1, 3, 5, 7, 8]中找出和爲8的兩個元素的下標分別爲(0,3)和(1,2)。
package main
import "fmt"
func sumArray(x [5]int)(result [][2]int){
for index1,value1 := range x{
for index2,value2 := range x{
if index1==index2{
continue
}
if value1+value2==8{
result = append(result,[2]int{index1,index2})
}
}
}
//因爲[[0 3] [1 2] [2 1] [3 0]]，有重複的，所以取一半
return result[0:len(result)/2]
}
func main() {
a := [5]int{1,3,5,7,8}
result := sumArray(a)
fmt.Printf("%v",result) //[[0 3] [1 2]]
}
