1、Array(数组)

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

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

1.1、数组定义：

var 数组变量名 [元素数量]T

比如：var a [5]int， 数组的长度必须是常量，并且长度是数组类型的一部分。一旦定义，长度不能变。 [5]int和[10]int是不同的类型。

var a [3]int
var b [4]int
a = b       //此时a和b是不同的类型，不允许赋值

数组可以通过下标进行访问，下标是从0开始，最后一个元素下标是：len-1，访问越界（下标在合法范围之外），则触发访问越界，会panic。

1.2、数组的初始化

数组的初始化也有很多方式。

方法一

初始化数组时可以使用初始化列表来设置数组元素的值。

package main

import "fmt"

func main() {
	var a [5]int                        //数组会初始化为int类型的零值
	var b = [5]int{1, 2, 3}             //使用指定的初始值完成初始化
	var c = [3]string{"北京", "上海", "广州"} //使用指定的初始值完成初始化
	fmt.Println(a)                      //[0 0 0 0 0]
	fmt.Println(b)                      //[1 2 3 0 0]
	fmt.Println(c)                      //[北京 上海 广州]
}

方法二

上述的方法每次都要确保提供的初始值和数组长度一致，一般情况下可以让编译器根据初始值的个数自行推断数组的长度,然后给变量赋值类型，例如：

package main

import "fmt"

func main() {
	var a [3]int
	var b = [...]int{1, 2, 3, 4}
	var c = [...]string{"北京", "上海", "广州"}
	fmt.Println(a)                  //[0 0 0]
	fmt.Println(b)                  //[1 2 3 4]
	fmt.Printf("type of b:%T\n", b) //type of b:[4]int
	fmt.Println(c)                  //[北京 上海 广州]
	fmt.Printf("type of c:%T\n", c) //type of c:[3]string
}

方法三

我们还可以使用指定索引值的方式来初始化数组，例如:

package main

import "fmt"

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

1.3、数组的遍历(两种方法)

方法1：for循环遍历

package main

import "fmt"

func main() {
	var a = [...]string{"北京", "上海", "广州"}
	for i := 0; i < len(a); i++ {
		fmt.Println(a[i])
	}
}
>>>
北京
上海
广州

方法2：for range遍历

package main

import "fmt"

func main() {
	var a = [...]string{"北京", "上海", "广州"}
	for index, value := range a {
		fmt.Println(index, value)
	}
}
>>>
0 北京
1 上海
2 广州

1.4、多维数组

Go语言是支持多维数组的，以二维数组为例（数组中又嵌套数组）。

二维数组的定义

package main

import "fmt"

func main() {
	a := [3][2]int{
		{1, 2},
		{3, 4},
		{5, 6},
	}
	fmt.Println(a)       //[[1 2] [3 4] [5 6]]
	fmt.Println(a[2][1]) //支持索引取值:6
}

注意:多维数组除了第一层其它层都不能使用...

二维数组的遍历

法一：

package main

import "fmt"

func main() {
	a := [3][2]int{
		{1, 2},
		{3, 4},
		{5, 6},
	}
	for _, v1 := range a {
		for _, v2 := range v1 {
			fmt.Printf("%d\t", v2)
		}
		fmt.Println()
	}
}
>>>
1       2
3       4
5       6

法二：

func main() {
	a := [...][2]int{
		{1, 2},
		{3, 4},
		{5, 6},
	}
	for i := 0; i < len(a); i++ {
		for j := 0; j < len(a[i]); j++ {
			fmt.Printf("%d\t", a[i][j])
		}
		fmt.Println()
	}
}
>>>
1       2
3       4
5       6

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

例如：

//支持
a := [...][2]int{
    {1, 2},
    {3, 4},
    {5, 6},
}
//不支持多维数组的内层使用...
a := [3][...]int{
    {1, 2},
    {3, 4},
    {5, 6},
}

1.5、数组是值类型

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

package main

import "fmt"

func testArry1(c [3]int) {
	c[0] = 100
	fmt.Println(c)       //[100 20 30]
}

func testArry2(d [3][2]int) {
	d[2][0] = 100
	fmt.Println(d)       //[[1 2] [3 4] [100 6]]
}
func main() {
	a := [3]int{10, 20, 30}
	testArry1(a)         //在testArry1中修改的是新拷贝的数组c
	fmt.Println(a)       //[10 20 30]
	b := [3][2]int{
		{1, 2},
		{3, 4},
		{5, 6},
	}
	testArry2(b)         //在testArry2中修改的是新拷贝的数组d
	fmt.Println(b)       //[[1 2] [3 4] [5 6]]
}

注意：

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

练习题

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

package main

import "fmt"

func main() {
	a := [...]int{1, 3, 5, 7, 8}
	sum := 0
	for _, v := range a {
		sum += v
	}
	fmt.Println(sum)
}
>>>24

2、找出数组中和为指定值的两个元素的下标，比如从数组[1, 3, 5, 7, 8]中找出和为8的两个元素的下标分别为(0,3)和(1,2)。

法一：

func main() {
	a := [...]int{1, 3, 5, 7, 8}
	for index1, value1 := range a {
		total := 8 - value1
		for index2, value2 := range a {
			if value2 == total {
				fmt.Printf("和为8的两个元素的下标为:(%d %d)\n", index1, index2)
			}
		}
	}
}
>>>
和为8的两个元素的下标为:(0 3)
和为8的两个元素的下标为:(1 2)
和为8的两个元素的下标为:(2 1)
和为8的两个元素的下标为:(3 0)

法二：

func main() {
	a := [...]int{1, 3, 5, 7, 8}
	for i := 0; i < len(a); i++ {
		for j := i + 1; j < len(a); j++ {
			if a[i]+a[j] == 8 {
				fmt.Printf("和为8的两个元素的下标为:(%d, %d)\n", i, j)
			}
		}
	}
}
>>>
和为8的两个元素的下标为:(0, 3)
和为8的两个元素的下标为:(1, 2)