1 数组定义

// 格式
var  数组变量名  [元素数量]元素数据类型

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

注意：数组长度也是数组类型的判断依据（比如[5]int和[10]int是不同的类型）

2 访问数组元素

可以通过下标进行访问，下标是从0开始，若下标超过有效范围会触发panic

3 初始化数组

• 不赋值则会给默认值（比如int默认值是0）
• 赋值必须要有=号 🟩
• 不完全赋值的，按下标排序，没分配到的的仍然为默认值

package main

import "fmt"

func main() {
   var test1 [3]int
   var test2 = [3]int{5, 6}
   var test3 = [3]string{"bei", "shang", "guang"}
   fmt.Println(test1)
   fmt.Println(test2)
   fmt.Println(test3)
}


// [0 0 0]
// [5 6 0]
// [bei shang guang]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4 自动识别元素数量 [...]

func main() {    
    var test [3]int
    var num = [...]int{1, 2}
    var city = [...]string{"beijing", "shanghai", "shenzhen"}
    fmt.Println(test)
    fmt.Println(num)
    fmt.Printf("type of num:%T\n", num)
    fmt.Println(city)
    fmt.Printf("type of city:%T\n", city)
}
1
2
3
4
5
6
7
8
9
10

5 多维数组

指定元素个数

[3][2] 表示这个数组有3个元素，元素也是数组，每个 元素数组 又包括2个元素

func main() {
   a := [3][2]string{
      {"冰箱", "电脑"},
      {"苹果", "香蕉"},
      {"草坤子", "猪八子"},
   }
   fmt.Println(a)
}
1
2
3
4
5
6
7
8

不指定个数

注意：省略个数 只能省略第一层的（也就是数组a 的元素个数）

func main() {
   a := [...][2]string{
      {"111", "2g2"},
      {"222", "p2p"},
   }
   b := [...][2]string{
      {"cao", "sss"},
      {"asdf", "qwer"},
      {"q", "t"},
   }
   fmt.Println(a)
   fmt.Println(b)
   fmt.Printf("type a :%T\n", a)
   fmt.Printf("type b :%T\n", b)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

6 网站习题

https://www.liwenzhou.com/posts/Go/05_array/#autoid-1-5-0

从数组[1, 3, 5, 7, 8]中找出和为8的两个元素的下标分别为(0,3)和(1,2)

func main() {
   a := [...]int{1, 3, 5, 7, 8}
   for x, y := range a {
      for i := 1; i <= len(a)-1-x; i++ {
         if y+a[i+x] == 8 {
            fmt.Printf("(%d,%d) ", x, i+x)
         }
      }
   }
}
1
2
3
4
5
6
7
8
9
10

=

=

=

数组遍历详解

遍历一个二维数组

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


//解析：
range a 返回的是index和对应的值
因此 _, v1 := range a 相当于忽略index，将键值赋值给 v1

外层第一轮循环 v1={"北京", "上海"}
然后进入内层 for _, v2 := range v1
同理 range v1 返回的是index和对应的值
_, v2 := range v1 相当于把{"北京", "上海"}里面的值依次赋值给 v2
然后打印v2

// 注1
\t 是制表符，使输出内容等间距对齐

// 注2
最后的 fmt.Println() 是打印一个换行，外层每循环一次就换行
如果没有这一句，输出就都在同一行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

=

=

数组相关语句格式

定义

// var  数组变量名  [元素数量]元素数据类型

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

定义并初始化

var test2 = [3]int{5, 6}   // [5 6 0]
var test3 = [3]string{"bei", "shang", "guang"}
1
2

定义时自动识别元素数量

var num = [...]int{1, 2}   // [1 2]
var city = [...]string{"beijing", "shanghai", "shenzhen"}
1
2

定义多维数组

a := [3][2]string{
      {"冰箱", "电脑"},
      {"苹果", "香蕉"},
      {"草坤子", "猪八子"},
   }
1
2
3
4
5

定义多维数组自动识别元素数量

   a := [...][2]string{
      {"111", "2g2"},
      {"222", "p2p"},
   }

   b := [...][2]string{
      {"cao", "sss"},
      {"asdf", "qwer"},
      {"q", "t"},
   }
1
2
3
4
5
6
7
8
9
10