05-Go语言之数组

内容目录

• 数组
• 多维数组

内容详细

数组（Array）

• 数组是同一种数据类型元素的集合。 在Go语言中，数组从声明时就确定，使用时可以修改数组成员，但是数组大小不可变化。

  // 定义一个长度为3元素类型为int的数组a
  var a [3]int
  

• 方式一：直接定义长度和类型

• 方式二：使用...来定义长度，让编译器判断有多少初始值，再给变量赋值

• 方式三：根据索引值初始化

  func arrayDemo() {
  	// 声明
  	var a [6]string	// 定义一个长度为5的int类型数组
  	var b [10]int	// 定义一个长度为10的int类型数组
      var ret [6]bool	// 定义一个长度为6的bool类型数组
  	// 初始化
  	a = [6]string{"我","爱","你","中","国"}
  	b = [10]int{1,2,3,4,5,6}
      ret = [6]bool{false,true,}
  	fmt.Println(a)	// [我 爱 你 中 国 ] 元素不够用空值代替
  	fmt.Println(b)	// [1 2 3 4 5 6 0 0 0 0] 元素不够的用0补充
      fmt.Println(ret) // [false,true,false,false,false,false,] 元素不够的用false补充
  	// 方式一：直接定义长度和类型
  	var c = [3]string{"wo","ai","ni"}
  	fmt.Println(c)	// ["wo","ai","ni"]
  	// 方式二：...表示让编译器判断有多少初始值，再给变量赋值
  	var d = [...]int{1,2,5,8,9,6,11,22,44,55}
  	fmt.Println(d)	// [1,2,5,8,9,6,11,22,44,55]
  	// 方式三：根据索引值初始化
  	var e [20]int
  	e = [20]int{19:1}	// 参数19表示下标位，1表示下标位19的值为1
  	fmt.Println(e)	// [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1]
  }
  

遍历数组

• 使用for循环有两种方法遍历数组

  func arrayDemo() {
  	var a = [...]string{"北京", "上海", "深圳"}
  	// 方法1：for循环遍历
  	for i := 0; i < len(a); i++ {
  		fmt.Println(a[i])
  	}
  
  	// 方法2：for range遍历
  	for index, value := range a {
  		fmt.Println(index, value)
  	}
  }
  

多维数组

• Go语言是支持多维数组的，相当于数组中嵌套数组

• 注意： 多维数组只有第一层可以使用...来让编译器推导数组长度。

  // 二维数组的定义：
  func main() {
  	a := [3][2]string{
  		{"北京", "上海"},
  		{"广州", "深圳"},
  		{"成都", "重庆"},
  	}
  	fmt.Println(a) //[[北京 上海] [广州 深圳] [成都 重庆]]
  	fmt.Println(a[2][1]) //支持索引取值:重庆
  }
  
  // 多维数组只有第一层才可使用...
  a := [...][2]string{
  	{"北京", "上海"},
  	{"广州", "深圳"},
  	{"成都", "重庆"},
  }
  

遍历多维数组

• 同样适用for循环遍历

  func main() {
  	a := [...][2]string{
  		{"北京", "上海"},
  		{"广州", "深圳"},
  		{"成都", "重庆"},
  	}
  	for _, v1 := range a {
  		for _, v2 := range v1 {
  			fmt.Printf("%s\t", v2)
  		}
  		fmt.Println()
  	}
  }
  // 结果：
  北京	上海	
  广州	深圳	
  成都	重庆	
  

数组是值类型

• 数组是值类型，赋值和传参会复制整个数组。因此改变副本的值，不会改变本身的值。

  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, 2},
  		{3, 4},
  		{5, 6},
  	}
  	modifyArray2(b) //在modify中修改的是b的副本x
  	fmt.Println(b)  //[[1 2] [3 4] [5 6]]
  }
  

  注意：

  1. 数组支持 “==“、”!=” 操作符，因为内存总是被初始化过的。
  2. [n]*T表示指针数组，*[n]T表示数组指针 。