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]   结果是全市指针的数组
}