Golang与数组

1. 数组概述

Go语言中 字符串 数组 切片 这三种数据类型在底层原始数据有着相同的内存结构,在上层因为语法的限制而有着不同的行为表象.

数组是用来存放同一类型数据的并且具有固定长度的连续内存区域,使用时可以修改数组成员,但是不能改变数组的长度.数组是一种数据类型,在Go语言是中数组是值类型.

• 数组的长度是固定的
• 数组中的元素类型一定是一致的
• 数组长度是数组类型的组成部分,故不同长度和元素类型的数组是不同的类型
• 理解数组是理解切片的基础
• Go语言中数组是值语义,一个数组变量表示整个数组

当需要详细规划程序所使用的内存时,数组类型非常有用, 使用数组值可以避免耗时费力的内存二次分配操作

package main

import "fmt"

func main() {
	var week = [8]string{"_", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}
	L := len(week)
	for i := 0; i < L; i++ {
        // 观察输出的各个数组元素的内存地址
		fmt.Println(&week[i])
	}
}

$ go run main.go
0xc000084000
0xc000084010
0xc000084020
0xc000084030
0xc000084040
0xc000084050
0xc000084060
0xc000084070

2. 数组声明

数组的声明写法如下 :

var 数组名 [数组长度]T

• 数组名 : 就是数组在使用的时候的变量名
• 数组长度 : 数组定义时,最多允许的存入数组的元素的数量,可以是一个表达式,在程序编译期计算的结果必须是一个整数,在使用前这个值是已经确定的
• T : 表示一种数据类型, 数组的类型可以是数组,这样就构成了多维数组
• 长度为0的数组在内存中不占用空间

package main

import "fmt"

const N  = 2
func main() {

	var nArr [3]int
	var sArr [7]string
	var fArr [10]float64
	var hArr [5][1]string
	var ageArr [N * 5]int
	fmt.Println(nArr)
	fmt.Println(sArr)
	fmt.Println(fArr)
	fmt.Println(hArr)
	fmt.Println(ageArr)
}

$ go run main.go
[0 0 0]
[      ]
[0 0 0 0 0 0 0 0 0 0]
[[] [] [] [] []]
[0 0 0 0 0 0 0 0 0 0]

3. 数组初始化

数组初始化就是给数组填充一些数据

方式1:

数组在声明是使用初始化列表进行元素设置

这种数组初始化,列表元素的个数可以比数组长度少,但是不能超过数组长度

package main

import "fmt"

func main() {
	var week = [8]string{"_", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}
	fmt.Println(week)

}

方式2:

在编译器编译的时候,由编译器根据数组元素个数自动设置数长度

[...] 方括号中的 ... 表示有Go编译器计算该值的元素数量并以此获取其长度

package main

import "fmt"

func main() {
	var workDay = [...]string{"Monday", "Tuesday", "Wednesday", "Thursday", "Friday"}
	fmt.Println(workDay)
    var nArr = [...]int{0:9,15:900}
	fmt.Println(nArr)
}

$ go run main.go
[Monday Tuesday Wednesday Thursday Friday]
[9 0 0 0 0 0 0 0 0 0 0 0 0 0 0 900]

方式3:

一般方法, 先声明,后定义

package main

import "fmt"

func main() {
	var NS  [3][1]string
	NS[0][0] = "aa"
	NS[1][0] = "bb"
	NS[2][0] = "cc"
	fmt.Println(NS)
}

4. 数组遍历

通常数组遍历就是访问数组中的每一个元素

方法一 for 循环遍历

package main

import "fmt"

func main() {
	var week = [8]string{"_", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}
	L := len(week)
	for i:=0; i<L;i++  {
		fmt.Println(i,"----",week[i])
	}
}

$ go run main.go
0 ---- _
1 ---- Monday
2 ---- Tuesday
3 ---- Wednesday
4 ---- Thursday
5 ---- Friday
6 ---- Saturday
7 ---- Sunday

方法二 for range 结构遍历

package main

import (
	"fmt"
)

func main() {
	var week = [8]string{"_", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}
    // k 表示数组下标 , v表示元素值
	for k,v := range week{
		fmt.Println(k,"===",v)
	}
}

$ go run main.go
0 === _
1 === Monday
2 === Tuesday
3 === Wednesday
4 === Thursday
5 === Friday
6 === Saturday
7 === Sunday

5. 数组使用说明

• 数组声明之后,没有初始化数组中的元素的值都是默认值
• 数组长度不能动态变化
• 数组的下标都是从0开始的
• 数组下标使用不能超过数组的长度否则数组越界,程序报错
• 数组属于值类型,默认是值传递,拷贝的副本,值修改相互不影响
• 在不同的函数之间,想修改原数组,可以使用引用传递

package main

import "fmt"

func modify(arr [8]string){
	arr[0] = "DEMO"
	fmt.Println(arr)
}
func main(){
	var week = [8]string{"_", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}
	modify(week)
	fmt.Println(week)
}

$go run main.go
[DEMO Monday Tuesday Wednesday Thursday Friday Saturday Sunday]
[_ Monday Tuesday Wednesday Thursday Friday Saturday Sunday]

引用传递

package main

import (
	"fmt"
)

func modify(arr [8]string){
	arr[0] = "DEMO"
	fmt.Println(arr)
}
func modifyCite(arr *[8]string){
	arr[1] = "星期一"
}
func main(){
	var week = [8]string{"_", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}
	modify(week)
	// 引用传递
	modifyCite(&week)
	fmt.Println(week)
}

$ go run main.go
[DEMO Monday Tuesday Wednesday Thursday Friday Saturday Sunday]
[_ 星期一 Tuesday Wednesday Thursday Friday Saturday Sunday]

练习Demo

package main

import (
	"fmt"
)

func main() {
	// 打印26字母
	var char [26]byte
	for i := 0; i < 26; i++ {
		char[i] = 'A' + byte(i)
	}
	for _, v := range char {
		fmt.Printf("%c\t", v)
	}
	//求一个数组中的最大值
	var n = [...]int{1, 9, -90, 88, 99, 8776, 23}
	maxIndex := 0
	maxValue := n[maxIndex]
	for k, v := range n {
		if v > maxValue {
			maxValue = v
			maxIndex = k
		}
	}
	fmt.Printf("\n数组n中最大值是%d,其下标是%d", maxValue, maxIndex)
	// 求出数组的平均值 数组元素值总和/ 元素个数
	L := len(n)
	sum := 0
	for i := 0; i < L; i++ {
		sum += n[i]
	}
	aver := float64(sum / L)
	fmt.Printf("\n数组n有%d个元素,平均值是%f", L, aver)
}

$ go run main.go
A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Y	Z	
数组n中最大值是8776,其下标是5
数组n有7个元素,平均值是1272.000000