1.数组
1.1数组介绍
数组是同一种数据类型元素的集合。
在Go语言中，数组从声明时就确定，使用时可以修改数组成员，但是数组大小不可变化。
基本语法：
//定义一个长度为3，元素类型为int的数组a
var a [3]int1.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]]
}
来源：51CTO
作者：DevOperater
链接：https://blog.51cto.com/10983441/2457699