Golang 数组

和 C 语言一样，Go 语言中也有数组的概念，Go语言中的数组也是用于保存一组相同类型的数据

和 C 语言一样，Go 语言中的数组也分为一维数组和多维数组

一维数组

格式：var arr [元素个数]数据类型

• 和 C 语言中数组不同，Go 语言中数组定义之后就有默认的初始值
• 默认初始值就是保存数据类型的默认值（零值）

package main
import "fmt"
func main() {
    // 1.定义一个数组
    var arr [3]int
    // 2.打印数组
    fmt.Println(arr) //[0 0 0]

    // 1.定义一个数组
    var arr [3]bool
    // 2.打印数组
    fmt.Println(arr) //[false false  false]
}

和C语言一样，Go 语言中的数组也提供了好几种初始化方式

package main
import "fmt"
func main() {
  	// 1.定义的同时完全初始化
  	var arr1 [3]int = [3]int{1, 3, 5}
  	// 2.打印数组
  	fmt.Println(arr1) // [1 3 5]

  	// 1.定义的同时部分初始化
  	var arr4 [3]int = [3]int{8, 9}
  	// 2.打印数组
  	fmt.Println(arr4) // [8 9 0]

  	// 1.定义的同时指定元素初始化
  	var arr5 [3]int = [3]int{0:8, 2:9}
  	// 2.打印数组
  	fmt.Println(arr5) // [8 0 9]

  	// 1.先定义再逐个初始化
  	var arr3 [3]int
  	arr3[0] = 1
  	arr3[1] = 2
  	arr3[2] = 3
  	// 2.打印数组
  	fmt.Println(arr3) // [1 2 3]
}

和C语言中的数组不同，Go语言中数组除了可以定义的同时初始化以外，还可以先定义再一次性初始化

package main
import "fmt"
func main() {
  	// 1.先定义再一次性初始化
  	var arr2 [3]int
  	arr2 = [3]int{2, 4, 6}
  	// 2.打印数组
  	fmt.Println(arr2) // [2 4 6]
}

和C语言一样，Go语言中如果定义数组的同时初始化，那么元素个数可以省略，但是必须使用 ... 来替代

• ... 会根据初始化元素个数自动确定数组长度

package main
import "fmt"
func main() {
  // 1.定义的同时完全初始化
  var arr1  = [...]int{1, 3, 5}
  // 2.打印数组
  fmt.Println(arr1) // [1 3 5]

  // 1.定义的同时指定元素初始化
  var arr2  = [...]int{6:5}
  // 2.打印数组
  fmt.Println(arr2) // [0 0 0 0 0 0 5]
}

Go 语言中数组的访问和使用方式和C语言一样都是通过数组名称[索引]的方式

package main
import "fmt"
func main() {
	arr := [...]int{1, 3, 5}
	// 使用数组, 往数组中存放数据
	arr[1] = 666
	// 访问数组, 从数组中获取数据
	fmt.Println(arr[0])
	fmt.Println(arr[1])
	fmt.Println(arr[2])
}

遍历数组

• Go 语言中提供了两种遍历数组的方式，一种是通过传统 for 循环遍历，一种是通过 for...range 循环遍历

package main
import "fmt"
func main() {
	arr := [...]int{1, 3, 5}
	// 传统for循环遍历
	for i:=0; i<len(arr); i++{
		fmt.Println(i, arr[i])
	}
	// for...range循环遍历
	for i, v := range arr{
		fmt.Println(i, v)
	}
}

数组注意点

• Go 语言中 数组长度 也是 数据类型的一部分

package main
import "fmt"
func main() {
    var arr1 [3]int
    var arr2 [3]int
    //var arr3 [2]int
    fmt.Println(arr1 == arr2) // true
    //fmt.Println(arr1 == arr3) // 编译报错, 不是相同类型不能比较
}

如果元素类型支持 ==、!= 操作时，那么数组也支持此操作

package main
import "fmt"
func main() {
    var arr1 [3]int = [3]int{1, 3, 5}
    var arr2 [3]int = [3]int{1, 3, 5}
    var arr3 [3]int = [3]int{2, 4, 6}
    // 首先会判断`数据类型`是否相同,如果相同会依次取出数组中`对应索引的元素`进行比较, 
    // 如果所有元素都相同返回true,否则返回false
    fmt.Println(arr1 == arr2) // true
    fmt.Println(arr1 == arr3) // false
 }

Go 语言中的数组是值类型，赋值和传参时会复制整个数组

package main
import "fmt"
func main() {
  var arr1 [3]int = [3]int{1, 3, 5}
  var arr2 [3]int = arr1
  arr2[0] = 666
  fmt.Println(arr1) // [1 3 5]
  fmt.Println(arr2) // [666 3 5]
 }

二维数组

用法和C语言数组一样，只是创建的格式不同

格式：[行数][列数]类型

  package main
  import "fmt"
  func main() {
	// 创建一个两行三列数组
	arr := [2][3]int{
		{1, 2, 3},
		{4, 5, 6}, //注意: 数组换行需要以逗号结尾
	}
	fmt.Println(arr)// [[1 2 3] [4 5 6]]
   }

创建多维数组时只允许第一维度使用...

格式：[...][列数]类型

package main
  import "fmt"
  func main() {
	// 创建一个两行三列数组
	arr := [...][3]int{
		{1, 2, 3},
		{4, 5, 6},
	}
	fmt.Println(arr)// [[1 2 3] [4 5 6]]
   }