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 */ | |
通过初始化值 确定数组行的数目 | 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])
}
}
}