Go语言10-复合类型-数组

1.数组额定义和基本要素

a.数组是一系列已编号，长度固定的同一类型数据项序列。

b.数组中包含的每个数据被称为数组元素，元素类型可以为整形、字符型或者自定义类型。

c.数组长度可以为一个常量或常量表达式，可以通过内置函数len()或者cap()得到数组长度(元素数量)。

2.数组的声明

var 数组变量名 [数组长度]数组元素类型

a.需要指定元素类型及元素个数

b.数组长度必须是常数，必须是大于等于0的整数

c.数组长度是类型的组成部分，即不同长度的数组类型不同。

3.数组的初始化

初始化方式	示例
先声明，再初始化	var a [3]int a=[3]int{1,2,3}
声明的同时初始化	var a [3]int = [3]int{1,2,3}
	var a = [3]int{1,2,3}//类型推导，自判断类型
赋值操作符:=	a := [3]int{1, 2,3}
	a := [...]int{1, 2, 3}//通过初始化值确定数组长度
	a := [5]int{2: 100, 4: 200}、、通过索引号初始化元素

4.数组元素编号及数组元素的获取和修改

4.1数组元素和编号

                                        First Element

Numbers[0]

Numbers[0]

Numbers[0]

Numbers[0]

......

Numbers[0]

4.2 数组元素的获取和修改

数组名[索引值]

package main

import "fmt"

func main() {
	var a [3]int = [3]int{1, 2, 3}
	fmt.Println("a = ", a)
	for i := 0; i < 3; i++ {
		fmt.Printf("a[%d] = %d\n", i, a[i])
	}
	a[1] = 100
	fmt.Println("a = ", a)
	b := [5]int{2: 100, 4: 200}
	fmt.Println("b = ", b)
	for j := 0; j < 5; j++ {
		fmt.Printf("b[%d] = %d\n", j, b[j])
	}
	b[1] = 1
	fmt.Println("b = ", b)
}

5.数组之间的比较和赋值

5.1数组之间的比较

数值之间可以使用“==”或“!=”进行比较，但不可以使用“<"或">"

两个数组相等需要同时满足两个条件：数组长度相等、数组对应的位置的元素的值相等

package main

import "fmt"

func main() {
	a := [3]int{1, 2, 3}
	b := [...]int{1, 2, 3}
	c := [3]int{2, 1, 3}
	d := [3]int{1, 2}
	fmt.Println(a == b, a == c, a == d)
}

5.2数组之间的赋值

两个数组之间赋值需要满足两个条件：数组长度相等，数组元素类型相同。

package main

import "fmt"

func main() {
	a := [3]int{1, 2, 3}
	var b [3]int
	b = a
	fmt.Println(b)
}

6.指针数组和数组指针

6.1指针数组

指针数组，即存放指针变量的数组。其本质是一个数组，数组元素是指针。

var ptr [5]*int

package main

import "fmt"

func main() {
	a := [3]int{1, 2, 3}
	b := [3]*int{&a[0], &a[1], &a[2]}
	fmt.Println(b)
}

6.2数组指针

数组指针即数组的指针。本质是一个指针，指向一个数组的首地址。

var ptr *[5]int

package main

import "fmt"

func main() {
	a := [...]int{1, 2, 3}
	/*定义数组指针*/
	var p *[3]int
	p = &a
	fmt.Printf("p=%p\n", p)
	fmt.Println("&a[0]=", &a[0])
	fmt.Println("&a[1]=", &a[1])
	fmt.Println("&a[2]=", &a[2])
	fmt.Println("*p=", *p, "a=", a)
	/*再数组指针这个变量钱加*可以获得该数组，再对该数组进行遍历*/
	for index, value := range *p {
		fmt.Println(index, ":", value)
	}
	/*对数组指针遍历，也可以获得数组的index和value*/
	for index, value := range p {
		fmt.Println(index, ":", value)
	}
}

7.数组作为函数参数

7.1值传递

实参为数组，形参是与实参同一类型的数组。

package main

import "fmt"

//自定义函数，完成对数组其中一个元素的修改
func modify(array1 [5]int) {
	array1[0] = 10
	fmt.Println("array1 = ", array1)
}

func main() {
	//定义并初始化一个数组
	array := [5]int{1, 2, 3, 4, 5}
	fmt.Println("调用前：array = ", array)
	//调用自定义函数
	modify(array)
	fmt.Println("调用后：array = ", array)
}

7.2 引用传递

实参是”&数组变量名“，形参必须是相应的数组指针(两个数组是同一类型)

package main

import "fmt"

//自定义函数，形参为数组指针
func modify(array1 *[5]int) {
	//方式1：直接对数组的第一个元素进行修改
	array1[0] = 10
	//方式2：对数组指针执行的数组的第一个元素进行修改
	(*array1)[1] = 100
	fmt.Println("*array1 = ", *array1)
}
func main() {
	//定义并初始化一个数组
	array := [5]int{1, 2, 3, 4, 5}
	fmt.Println("调用前array = ", array)
	//调用自定义函数，实参为数组的首地址
	modify(&array)
	fmt.Println("调用后array = ", array)
}

8.二维数组

8.1声明格式

二维数组本质上是由一维数组组成的。二维数组定义方式：var arrayName [ x ][ y ]variable_type

8.2 数组元素访问

二维数组中的元素通过指定坐标来访问，访问格式：arrayName[ i ][ j ]，i为行索引，j为列索引

二维数组示意图：

8.3二维数组初始化

方式	示例
一般初始化	a := [3][4]int{{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}}
	a := [3][4]int{  {0, 1, 2, 3} , /*第一行索引号为0 */ {4, 5, 6, 7} , /*第二行索引号为1 */ {8, 9, 10, 11} /*第三行索引号为2 */ }
通过初始化值 确定数组行的数目	b := [...][2]int{ //第一维可以根据行数确定值，第二位不能用... {10, 11}, {20, 21}, {30, 31},{40, 41}, //独立成行时，最后一个，不能省略 }
	b := [...][2]int{ //右大括号和初始化数据在同一行 {10, 11}, {20, 21}, {30, 31},{40, 41}}
	b := [...][2]int{{10, 11}, {20, 21}, {30, 31},{40, 41}}//左右大括号同行
通过索引号初始化	c := [4][2]int{1: {20, 21}, 3: {40, 41}}   //[[0 0] [20 21] [0 0] [40 41]]

 

 

package main

import "fmt"

func main() {
	a := [4][2]int{
		{1, 2}, {3, 4}, {5, 6}, {7, 8},
	}
	//循环嵌套语句，访问二维数组的每个元素
	for i := 0; i < 4; i++ {
		for j := 0; j < 2; j++ {
			fmt.Printf("a[%d][%d] = %d\n", i, j, a[i][j])
		}
	}
}