1，Array(数组)
数组是同一种类型元素的集合。在go语言中，数组从生命时就确定，使用时可以修改数组成员，但是数组的 大小不可变化：
语法：var 变量名 [元素数量]类型
var a [10]int
注意：[5]int 和 [10]int是不同的类型，数组的长度必须是常量，不能是变量，长度是数组类型的一部分
数组的初始化：
// 方法一：可以指定数组元素的值
func main() { var testArray [3]int //数组会初始化为int类型的零值 var numArray = [3]int{1, 2} //使用指定的初始值完成初始化 var cityArray = [3]string{"北京", "上海", "深圳"} //使用指定的初始值完成初始化 fmt.Println(testArray) //[0 0 0] fmt.Println(numArray) //[1 2 0] fmt.Println(cityArray) //[北京 上海 深圳] }
// 方法二:可以让编译器根据初始值的个数自行推断数组的长度
func main() {
var testArray [3]int
var numArray = [...]int{1, 2}
var cityArray = [...]string{"北京", "上海", "深圳"}
fmt.Println(testArray) //[0 0 0]
fmt.Println(numArray) //[1 2]
fmt.Printf("type of numArray:%T
", numArray) //type of numArray:[2]int 根据元素的个数判断数组的长度
fmt.Println(cityArray) //[北京 上海 深圳]
fmt.Printf("type of cityArray:%T
", cityArray) //type of cityArray:[3]string
}
// 方法三：可以使用指定索引值的方式来出示化数组
func main() {
a := [...]int{1: 1, 3: 5}
fmt.Println(a) // [0 1 0 5]
fmt.Printf("type of a:%T
", a) //type of a:[4]int
} 数组的遍历：
func main() {
var a = [...]string{"北京", "上海", "深圳"}
// 方法1：for循环遍历
for i := 0; i < len(a); i++ {
fmt.Println(a[i])
}
//方法2：for循环遍历
i := 0
for i < len(a) {
fmt.Println(a[i])
}
// 方法3：for range遍历
for index, value := range a {
fmt.Println(index, value)
}
}
2,多维数组
Go语言是支持多维数组的，我们这里以二维数组为例：
// 二维数组的定义
func main() { a := [3][2]string{ {"北京", "上海"}, {"广州", "深圳"}, {"成都", "重庆"}, } fmt.Println(a) //[[北京 上海] [广州 深圳] [成都 重庆]] fmt.Println(a[2][1]) //支持索引取值:重庆 }
// 二维数组的遍历
func main() {
a := [3][2]string{
{"北京", "上海"},
{"广州", "深圳"},
{"成都", "重庆"},
}
for _, v1 := range a { //循环遍历两次拿到值
for _, v2 := range v1 {
fmt.Printf("%s ", v2)
}
fmt.Println()
}
}
// 注意注意注意：多维数组只有第一层可以使用...来让编译器推导数组长度
//支持的写法
a := [...][2]string{
{"北京", "上海"},
{"广州", "深圳"},
{"成都", "重庆"},
}
//不支持多维数组的内层使用...
b := [3][...]string{
{"北京", "上海"},
{"广州", "深圳"},
{"成都", "重庆"},
}数组是值类型
数组是值类型，赋值和传参会复制整个数组，因此改变副本的值，不会改变本身的值
func modifyArray(x [3]int) {
x[0] = 100
}
func modifyArray2(x [3][2]int) {
x[2][0] = 100
}
func main() {
a := [3]int{10, 20, 30}
modifyArray(a) //在modify中修改的是a的副本x
fmt.Println(a) //[10 20 30]
b := [3][2]int{
{1, 1},
{1, 1},
{1, 1},
}
modifyArray2(b) //在modify中修改的是b的副本x
fmt.Println(b) //[[1 1] [1 1] [1 1]]
}
注意：1，数组支持“==”，“！=”操作符，因为内存总是被初始化过的
2， [n]*T 表示数组指针，实质是一个指针，指向的是一个数组
*[n]T 表示指针数组，实质是一个数组，只是这个数组中存在的所有元素是指针变量
import "fmt"
func main(){
x,y := 1, 2
var arr = [...]int{5:2}
//数组指针
var pf *[6]int = &arr
//指针数组
pfArr := [...]*int{&x,&y}
fmt.Println(pf) // &【000002】 结果是一个指向数组的指针
fmt.Println(pfArr) // [0x02580a08 0x327831a88] 结果是全市指针的数组
}