数组，可以存放多个相同类型数据的一种特殊的数据类型
一、基本语法及案例演示
语法格式
var 变量名称 [空间大小]数据类型
//我们在创建数组的时候会指定这个数据的空间有多大
//如:
//var hens [6]float64
//定义一个hens的数组, 空间大小位6,允许存放6个float64的值案例
假设有一个养鸡场有6只鸡，他们的体重分别是 3kg，5kg，1kg，3.4kg，2kg，50kg
那这6只鸡 的总体重是多少？平均体重是多少？
package main
import (
"fmt"
)
func main(){
var hens [6]float64 //定义一个数组,空间大小为6
hens[0] = 3.0 //和其他语法的列表相似,hens[索引位],空间大小是6
hens[1] = 5.0 //索引位是0-5
hens[2] = 1.0
hens[3] = 3.4
hens[4] = 2.0
hens[5] = 50.0
totalWeight2 := 0.0 //定义变量接收总体重
for i := 0; i < len(hens); i++ { //循环遍历 将所有体重相加
totalWeight2 += hens[i]
}
avgWeight2 := fmt.Sprintf("%.2f", totalWeight2 / len(hens))
//fmt.Sprintf 将计算的值接收
//"%.2f"中的2表示精度 保留小数点后两位
//len 获取数组的长度
fmt.Printf("totalWeight2=%v avgWeight2=%v",totalWeight2, avgWeight2)
}
1、 数组的默认值
和前面所有的数据类型一样，数组定义后也是有默认值的，数组内数据的默认值取决于值的类型
package main
import (
"fmt"
)
func main() {
var intArr [3]int //比如这里是一个int的数组,int类型变量的默认值是0
fmt.Println(intArr)
}返回
[0 0 0]2、 数组的地址可以通过数组名来获取
package main
import (
"fmt"
)
func main() {
var intArr [3]int
fmt.Printf("intArr的内存地址=%p",&intArr) //也是通过& 来获取内存地址
}返回
intArr的内存地址=0xc0000161203、数组的第一个元素的地址，就是数组的首地址
package main
import (
"fmt"
)
func main() {
var intArr [3]int
fmt.Printf("%p\n%p\n%p\n%p\n",
&intArr,
&intArr[0],
&intArr[1],
&intArr[2])
}返回
0xc000016120
0xc000016120
0xc000016128
0xc000016130说明
1、通过上面结果可知，数组的内存地址是连续性的
2、intArr数组名 和intArr[0] 第一个索引位的地址是一样的，也证明了数组的第一个元素的地址，就是数组的首地址
3 intArr[0] 到intArr[1]顺延的内存地址,就是在数组定义时所指定的数据类型(int)的大小(字节数)的值
int类型占用8个字节,通过上面的接结果可知:
0xc000016120
0xc000016120 //索引位0 和数组地址相同
0xc000016128 //索引位1 基于0顺延一个int类型的8字节
0xc000016130 //索引位2 基于1顺延一个int的字节，
//因为这里是16进制，所以结果是304、改变数组中的值是不会修改内存地址的
package main
import (
"fmt"
)
func main() {
var intArr [3]int
intArr[0] = 10
intArr[1] = 20
intArr[2] = 30
fmt.Println(intArr)
fmt.Printf("%p\n%p\n%p\n%p\n",
&intArr,
&intArr[0],
&intArr[1],
&intArr[2])
intArr[0] = 40
intArr[1] = 50
intArr[2] = 60
fmt.Println(intArr)
fmt.Printf("%p\n%p\n%p\n%p\n",
&intArr,
&intArr[0],
&intArr[1],
&intArr[2])
}返回
[10 20 30]
0xc000016120
0xc000016120
0xc000016128
0xc000016130
[40 50 60]
0xc000016120
0xc000016120
0xc000016128
0xc0000161305、从终端接收数值存储到数组中
package main
import (
"fmt"
)
func main() {
var score [5]float64
for i := 0; i < len(score); i++{
fmt.Printf("请输入第%d个元素的值",i+1)
fmt.Scanln(&score[i]) //Scanln接收用户输入
}
fmt.Println(score) //输出整个数组的值
for i := 0; i < len(score); i++{
fmt.Printf("score[%d]=%v\n",i,score[i]) //%d 表示十进制显示，%v表示直接输出
}
}返回
请输入第1个元素的值1
请输入第2个元素的值2
请输入第3个元素的值3
请输入第4个元素的值4
请输入第5个元素的值5
[1 2 3 4 5]
score[0]=1
score[1]=2
score[2]=3
score[3]=4
score[4]=5二、四种初始化数组的方法
1、在定义时直接初始化
package main
import (
"fmt"
)
func main() {
var numArr01 [3]int = [3]int{1, 2, 3} //在声明数组的时候直接赋值
fmt.Println("numArr01",numArr01)
}
//numArr01 [1 2 3]2、可以不定义数组类型，go有自己的类型推导自动识别
package main
import (
"fmt"
)
func main() {
var numArr02 = [3]int{1, 2, 3}
fmt.Println("numArr02",numArr02)
}3、不设置数组的大小，自动识别元素的数量
package main
import (
"fmt"
)
func main() {
var numArr03 = [...]int{1, 2, 3} //...表示自动识别
fmt.Println("numArr03",numArr03)
}4、给指定索引位添加元素
package main
import (
"fmt"
)
func main() {
//这里的1、0、2表示数组内的索引位
//这里是给指定的元素初始化值
var numArr04 = [...]int{1: 800, 0: 900, 2:999}
fmt.Println("numArr04",numArr04)
//类型推导也可以
numArr05 := [...]int{1: 800, 0: 900, 2:999}
fmt.Println("numArr05",numArr05)
}
//numArr04 [900 800 999]
//numArr05 [900 800 999]三、遍历数组（for-range）
//格式
for index, value := range 数组列表 {
代码块
}
说明:
//index是数组循环获取的的下标,从0开始
//value"是数组循环获取的对应索引下标的值
//他们都是仅在for循环内部可见的局部变量
//遍历数组元素时，如果不需要使用下标index，可以直接把下班index标为下划线"_"
//index 和value名称不是固定的，可以自定义，一般命名为index和value案例1 基本使用
package main
import (
"fmt"
)
func main() {
heroes := [...]string{"宋江","无用","卢俊义"}
for index, value := range heroes {
fmt.Printf("index=%v value=%v\n",index,value) //遍历输出索引位和对应的值
}
}返回
index=0 value=宋江
index=1 value=无用
index=2 value=卢俊义案例2 除去下标
package main
import (
"fmt"
)
func main() {
heroes := [...]string{"宋江","无用","卢俊义"}
for _, value := range heroes {
//如果不需要索引位的值,修改为下划线"_"即可
//将index改为下划线
//直接输入value就可以取值
fmt.Printf("value=%v\n",value)
}
}返回
value=宋江
value=无用
value=卢俊义四、数组使用细节和注意事项
1、数组不能动态变化
数组是多个"相同类型"数据的组合，一个数组一旦声明/定义了，长度是固定的，不能动态变化
案例
package main
import (
"fmt"
)
func main() {
var arr01 [3]int
arr01[0] = 1
arr01[1] = 30
arr01[2] = 1.1 //这里会报错，因为数组类型是int，而1.1是浮点值
arr01[3] = 890 //无效的 数组 索引 '3' (3 元素的数组超出界限)
//长度固定，不能动态变化，
}
2、设置数组时，如果不设置空间大小则视为切片
var arr []int //切片是啥后面再说3、数组的类型可以是所有类型
数组中元素可以是任何类型，包括值类型和引用类型，但是不能混用
4、数组创建后，有默认值
数值类型数组 //0
字符串数组 //""
bool数组 //false
//等同于基本数据类型本身案例
package main
import (
"fmt"
)
func main() {
//整数、浮点数、默认都为0
//字符串 默认 ""
//bool类型 默认是false
var arr01 [3]int
var arr02 [3]string
var arr03 [3]bool
fmt.Printf("arr01=%v\narr02=%v\narr03=%v\n",arr01,arr02,arr03)
}
返回
arr01=[0 0 0]
arr02=[ ]
arr03=[false false false]5、 使用数组的步骤
1. 声明数组并开辟内存空间 //make和new
2. 给数组元素赋值（默认0值）案例 new 和make的区别
6、数组的下标是从0开始的
package main
import (
"fmt"
)
func main() {
var arr04 [3]string //数组的下标是从0开始的 0-2
varr04[3] = "tom" //当索引位超出会报越界
}
7、go 的数组是值类型
package main
import (
"fmt"
)
func test01(arr [3]int){
arr[0] = 88 //值转递，相当于是将main的arr数组拷贝了一份
//所以在这里被修改后是不会影响到main中调用的数组的
}
func main() {
arr := [3]int{11,22,33}
test01(arr) //将数组作为参数传递
fmt.Println(arr)
}
返回
[11 22 33]8、修改其他函数的数组
上面我们已经知道了数组是以值拷贝的形式进行传参的，但是我们想要其他函数中修改数组的值怎么做？ 使用指针
案例
package main
import (
"fmt"
)
func test01(arr *[3]int){ //*开头表示 我这边是以指针的形式接收数据的
//引用指针，相当于直接调用main中arr变量的内存地址来修改数据
(*arr)[0] = 88 //在赋值时，我们去调用这个指针变量
//*arr去调用，但同时这是一个数组类型,所以要加括号
}
func main() {
arr := [3]int{11,22,33}
test01(&arr) //我们传参的时候将数组的内存地址进行传递
fmt.Println(arr)
}
返回
[88 22 33]9、数组长度是数组类型的一部分
在传递函数参数时，需要考虑数组的长度. 判断以下三段代码是否正确
案例1
package main
import (
"fmt"
)
func modify(arr []int){ //这里接收参数时没有设置数组的长度,说明接收的就变成了切片
//正确的写法是arr [3]int
arr[0] = 100
fmt.Println("modify 的arr",arr)
}
func main(){
var arr = [...]int{1,2,3}
modify(arr)
}
案例2
package main
import (
"fmt"
)
func modify(arr [4]int){ //arr [4]int 和下面数组的长度不同
//下面的数组只有3位的长度，不能传递到4长度的数组
//不同长度的数组相当于是不同的数据类型
arr[0] = 100
fmt.Println("modify 的arr",arr)
}
func main(){
var arr = [...]int{1,2,3}
modify(arr)
}案例3
package main
import (
"fmt"
)
func modify(arr [3]int){
arr[0] = 100
fmt.Println("modify 的arr",arr)
}
func main(){
var arr = [...]int{1,2,3}
modify(arr)
}
//正确数组练习题
1、创建一个byte类型的26个元素的数组
创建一个byte类型的26个元素的数组，分别放置'A'-'Z' ，使用for循环访问所有元素并打印出来。
提示：
字符类型(byte)运算 'A'+ 1 -->'B' 这里的1也是byte类型才可以。 然后通过printf %c输出字符
package main
import "fmt"
func main(){
var shuzu [26]byte
for key,_ := range shuzu{ //for-range遍历数组
shuzu[key] = 'A' + byte(key) //'A'加索引位的byte作为值赋予
}
fmt.Printf("%c ",shuzu) //以字符形式输出
}返回
[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] 练习2 请求出一个数组的最大值，并得到对应的下标
/*
1. 声明一个数组 var intArr[5] = [...]int {1,-1,9,90,11}
2. 假定第一个元素就是最大值，下标就是0
3. 然后从第二个元素开始循环比较，如果发现有更大的，则交换
*/
package main
import "fmt"
func main(){
var test = [5]int{12,2,21,45,5}
maxzhi := test[0]
xiabiao := 0
//这里len去获取这个数组的长度，然后循环每次去判断是否小于这个长度
//这里因为要从索引位1开始，1-4的位置，总长度是5，所以必须是小于，不能是小于等于，不然长度不够了
for i := 1; i < len(test);i++{
if maxzhi < test[i]{
maxzhi = test[i]
xiabiao = i
}
}
fmt.Println("最大值",maxzhi)
fmt.Println("最大值下标",xiabiao)
}
练习3 请求出一个数组的和 与他的平均值 for-range
/*
请求出一个数组和 和平均值 for-range
思路
1. 就是声明一个数组
2. 求出和sum
3. 求出平均值
*/
package main
import (
"fmt"
)
func main(){
var intArr2 = [...]int {1,2,3,4,7}
sum := 0
for _, val := range intArr2 {
//_下划线 val，表示只要值，不要索引下标
sum += val
}
fmt.Printf("sum=%v 平均值=%v\n", sum, sum / len(intArr2))
//上面显示的是sum=17 平均值=3
//这里应该是有小数点的，但是因为int的缘故都抹掉了
//所以我们需要修改一下平均值的数据类型和除的个数的数据类型
fmt.Printf("sum=%v 平均值=%v", float64(sum), float64(sum) / float64(len(intArr2)))
}
数组的复杂使用反转
随机生成5个数，并将其反转输出
案例
/*
思路
1. 随机生成5个数，rand Intn()函数
2. 当我们得到随机数后，就放入到一个数组中
3. 反转打印,交换的次数
第一个和倒数第一个元素交换，第二个和倒数第二个交换
如下
[1 2 3 4 5] 反转为 [5 4 3 2 1 ]
或者说
[1 2 3 4 5 6 ] 反转为 [ 6 5 4 3 2 1]
他反转的概念可以理解为如下
[1 5]
[ 2 4]
[3]
我们是从两边开始替换，然后向中间靠拢的
*/
package main
import (
"fmt"
"math/rand"
)
func main(){
var intArr3 [5]int
for i := 0; i < len(intArr3); i++{
intArr3[i] = rand.Intn(100) //随机生成0-100的整数
}
fmt.Println("我是交换之前的值",intArr3)
temp :=0
for i := 0; i < len(intArr3) / 2; i++{
//考虑到要进行反转，需要先筛选出一半的值存下来 比如 1 2
//然后拿另一半的值，覆盖之前取出值的位置 4 5 --》 1 2
//最后再将之前取出的值写入到之后取出值的位置 1 2 --> 4 5
//以此来完成前后值的反转
temp = intArr3[len(intArr3) - 1 - i]
//len(intArr3) - 1 来获取真正的索引位， (len的值是统计长度，是从1开始的，所以要减一)
//第一次循环，数组会拿到索引总长度-i的值，也就是0-4的最大值4位置的值
//将最后的索引位值 放入到临时变量中
intArr3[len(intArr3) - 1 - i ] = intArr3[i]
//然后将数组中第一个值写入到数组中最大值4的位置
intArr3[i] = temp
//最后将之前拿到的最后一位索引位的值，再赋予到第一位的值的索引位，完成反转
}
fmt.Println("我是交换之后的值",intArr3)
}
返回
我是交换之前的值 [81 87 47 59 81]
我是交换之后的值 [81 59 47 87 81]