1.定义

要点
数组是具有固定长度且拥有零个或多个相同数据类型元素的序列。
默认情况下, 数组的每个元素都被初始化为元素类型对应的零值。

数组定义后长度不能变化。
数组的长度是数组类型的一部分。
数组是值类型, 赋值和传参会复制整个数组。因此改变副本的值，不会改变本身的值。

  1. var 数组变量名 [元素数量]T
  3. var a[3] int    // 长度为3，元素类型为整型的数组
  4. var b[4] int    // 长度为4，元素类型为整型的数组
  5. // a = b  这个是不可以的，a和b是不同的数据类型

2.初始化

一个新数组中的元素初始值为元素类型的零值。
方法一
使用数组字面量根据根据一组值来初始化一个数组。

  1. func main() {
  2.     var testArray [3]int                        //数组会初始化为int类型的零值
  3.     var numArray = [3]int{1, 2}                 //使用指定的初始值完成初始化
  4.     var cityArray = [3]string{"北京", "上海", "深圳"} //使用指定的初始值完成初始化
  5.     fmt.Println(testArray)                      //[0 0 0]
  6.     fmt.Println(numArray)                       //[1 2 0]
  7.     fmt.Println(cityArray)                      //[北京 上海 深圳]
  8. }

方法二
使用 “…” 代替数组声明时的元素数量, 数组的长度由初始化数组的元素个数定义。

  1. func main() {
  2.     var testArray [3]int
  3.     var numArray = [...]int{1, 2}
  4.     var cityArray = [...]string{"北京", "上海", "深圳"}
  5.     fmt.Println(testArray)                          //[0 0 0]
  6.     fmt.Println(numArray)                           //[1 2]
  7.     fmt.Printf("type of numArray:%T\n", numArray)   //type of numArray:[2]int
  8.     fmt.Println(cityArray)                          //[北京 上海 深圳]
  9.     fmt.Printf("type of cityArray:%T\n", cityArray) //type of cityArray:[3]string
  10. }

方法三
使用指定索引值的方式来初始化数组

  1. func main() {
  2.     a := [...]int{1: 1, 3: 5}
  3.     fmt.Println(a)                  // [0 1 0 5]
  4.     fmt.Printf("type of a:%T\n", a) //type of a:[4]int
  5. }

多维数组

多维数组只有第一层可以使用

  1. func main() {
  2.     a := [3][2]string{
  3.         {"a", "b"},
  4.         {"c", "d"},
  5.         {"e", "f"},
  6.     }
  8.     // 多维数组只有第一层可以使用
  9.     b := [...][2]string{
  10.         {"a", "b"},
  11.         {"c", "d"},
  12.         {"e", "f"},
  13.     }
  15.     /* 
  16.     不支持多维数组的内层使用
  17.     c := [3][...]string{
  18.         {"a", "b"},
  19.         {"c", "d"},
  20.         {"e", "f"},
  21.     }
  22.     */
  24.     for _, v1 := range a {
  25.         for _, v2 := range v1 {
  26.             fmt.Printf("%v\t", v2)
  27.         }
  28.         fmt.Println()
  29.     }
  30. }


3.赋值

Golang 中数组是值类型, 数组可以用于赋值操作。变量名代表整个数组, 同类型的数组可以赋值给另一个数组。

  1. func main() {
  2.     var a = [3]int{1, 2, 3}
  3.     fmt.Printf("a||%#v||%p||\n", a, &a)        // a||[3]int{1, 2, 3}||0xc000016120
  5.     var b [3]int
  6.     b = a
  7.     fmt.Printf("b||%#v||%p||\n", b, &b)        // b||[3]int{1, 2, 3}||0xc000016180
  8.     fmt.Printf("a = b||%t", a==b)            // a = b||true
  9. }

4.遍历

  1. func main() {
  2.     var a = [3]string{"a", "b", "c"}
  3.     fmt.Println("方法一:")
  4.     for i:=0; i<len(a); i++ {
  5.         fmt.Printf("index=%d||value=%v\n", i, a[i])
  6.     }
  7.     fmt.Println("方法二:")
  8.     for i, v := range a {
  9.         fmt.Printf("index=%d||value=%v\n", i, v)
  10.     }
  11. }