go基础语法之数组

go基础语法之数组

数组定义

数组:同一种数据类型的集合,go中,数组在声明时就必须确定、使用时可以修改数组中元素、但数组大小,即数组长度不可变;

定义语法:

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

// 语法
var 数组变量名 [数组的长度]数组中元素类型

数组中,数组长度必须是常量,并长度属于数组类型的一部分,长度不同的数组,属于不同的数据类型,如[5]int 和[10]int属于不同类型;

var a [4]int
var b [6]int
a = b // 不可以将b赋值给不属于同类型的a

数组,可以通过下标访问,下标从0开始,最后一个下标,len-1,访问越界时,会触发访问越界,panic;

数组初始化

方法1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
package main

import "fmt"

func main()  {
	// 数组定义法1

	var array1 [3]int // 数组定义时,没指定元素值时,默认值为该类型的默认值,int是0,bool是false
	var array2 = [3]int{1, 2} // 第三个元素补0

	var cityArray = [3]string{"北京", "上海", "杭州"}

	fmt.Println(array1)
	fmt.Println(array2)
	fmt.Println(cityArray)
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\05_array>go run main.go
[0 0 0]
[1 2 0]
[北京 上海 杭州]

方法2

 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
32
33
34
35
36
package main

import "fmt"

func main()  {
	// 数组定义法1

	var array1 [3]int
	var array2 = [3]int{1, 2}

	var cityArray = [3]string{"北京", "上海", "杭州"}

	fmt.Println(array1)
	fmt.Println(array2)
	fmt.Println(cityArray)

	// 数组定义法2,根据数组元素个数,推断数组长度,
	var array3 [2]bool
	var array4 = [...]int{1,2,3,4,5}
	var array5 = [...]string{"你好","杭州"}

	fmt.Println(array3)
	
	fmt.Printf("type of array4:%T", array4)
	fmt.Println(array4)
	
	fmt.Printf("type of array5:%T", array5)
	fmt.Println(array5)
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\05_array>go run main.go
[0 0 0]
[1 2 0]
[北京 上海 杭州]
[false false]
type of array4:[5]int[1 2 3 4 5]
type of array5:[2]string[你好 杭州]

方法3

 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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
package main

import "fmt"

func main()  {
	// 数组定义法1

	var array1 [3]int
	var array2 = [3]int{1, 2}

	var cityArray = [3]string{"北京", "上海", "杭州"}

	fmt.Println(array1)
	fmt.Println(array2)
	fmt.Println(cityArray)

	// 数组定义法2,根据数组元素个数,推断数组长度,
	var array3 [2]bool
	var array4 = [...]int{1,2,3,4,5}
	var array5 = [...]string{"你好","杭州"}

	fmt.Println(array3)
	
	fmt.Printf("type of array4:%T", array4)
	fmt.Println(array4)
	
	fmt.Printf("type of array5:%T", array5)
	fmt.Println(array5)

	// 数组定义3,指定索引初始化数组中特定索引的值

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


}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\05_array>go run main.go                            r\05_array>
[0 0 0]
[1 2 0]
[北京 上海 杭州]
[false false]
type of array4:[5]int[1 2 3 4 5]
type of array5:[2]string[你好 杭州]
[0 1 0 5]
type of a: [4]int

数组的遍历

数组遍历有2种方式,

  1. for结合len,根据数组长度遍历
  2. for range,直接遍历数组
 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
package main

import "fmt"

func main() {

	// 数组遍历

	a := [...]int{1, 3, 4, 7, 9}

	for i := 0; i < len(a); i++ {
		fmt.Println(a[i])
	} // for结合len遍历

	for index, value := range a {
		fmt.Printf("%v: %v\n", index, value)
	}// for range 遍历
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\05_array>go run main.go
1
3
4
7
9
0: 1
1: 3
2: 4
3: 7
4: 9

多维数组

go支持多维数组,即数组中的元素类型是数组,数组嵌套数组

二维数据定义

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
package main

import "fmt"

func main() {


	// 多维数组
	a := [3][2]string {
		{"haha","xixi"},
		{"gogo","java"},
		{"python","C"},
	}
	fmt.Println(a)
	fmt.Printf(a[2][1])
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\05_array>go run main.go
[[haha xixi] [gogo java] [python C]]
C

二维数据遍历

 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
package main

import "fmt"

func main() {

	// 多维数组
	a := [3][2]string{
		{"haha", "xixi"},
		{"gogo", "java"},
		{"python", "C"},
	}
	

	// 多维数组遍历

	for _, v1 := range a {
		for _, v2 := range v1 {
			fmt.Printf("%s\t", v2)
		}
		fmt.Println()
	}
}


D:\workstation\mycode\gocode\src\learngo\basic_grammar\05_array>go run main.go
haha    xixi
gogo    java
python  C

注:多维数组,只有最外层支持编译器推导数组长度

	// 多维数组
	a := [...][2]string{
		{"haha", "xixi"},
		{"gogo", "java"},
		{"python", "C"},
	}

数组是值类型

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

与之相对的,是引用类型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

import "fmt"
func modifyArray(x [3]int)  {
	x[0] = 666
    
    
    
	fmt.Println(x)
}
func main() { 

	// 数组是值类型


		a := [3]int{1,2,3}
		modifyArray(a)
		fmt.Println(a)
}    
D:\workstation\mycode\gocode\src\learngo\basic_grammar\05_array>go run main.go
[666 2 3]
[1 2 3]
// 可以看到,修改时,只是修改了数组的副本,

ps:

  • 数组,支持== != 操作符,因为内存总是被初始化过的;
  • [n]*T 表示指针数组,*[n]T表示数组指针

练习

  1. 求数组[1, 3, 5, 7, 8]所有元素的和

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    
    package main
       
    import "fmt"
       
       
    func main()  {
     a := [...]int{1,3,5,7,8}
     sum := 0
     for _,v := range a {
         sum += v
     }
       
     fmt.Println(sum)
    }
       
    D:\workstation\mycode\gocode\src\learngo\basic_grammar\05_array>go run main.go
    24
    
  2. 找出数组中和为指定值的两个元素的下标,比如从数组[1, 3, 5, 7, 8]中找出和为8的两个元素的下标分别为(0,3)(1,2)

     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
    
    package main
       
    import "fmt"
       
    func main() {
     a := [...]int{1, 3, 5, 7, 8}
     sum := 0
     for _, v := range a {
         sum += v
     }
       
     fmt.Println(sum)
       
     for i := 0; i < len(a); i++ {
         for j := i + 1; j < len(a); j++ {
             if a[i]+a[j] == 8 {
                 fmt.Printf("(%v,%v)", i, j)
             }
         }
     }
    }
       
    D:\workstation\mycode\gocode\src\learngo\basic_grammar\05_array>go run main.go
    24
    (0,3)(1,2)
    
updatedupdated2020-12-312020-12-31
加载评论