GO语言之基础数据类型__数组

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\n", numArray)   //type of numArray:[2]int   根据元素的个数判断数组的长度
	fmt.Println(cityArray)                          //[北京 上海 深圳]
	fmt.Printf("type of cityArray:%T\n", 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\n", 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\t", 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]   结果是全市指针的数组
}