[go学习笔记.第七章.数组和切片] 2.数组的遍历,注意事项和细节以及数组的应用实例

本文链接：https://blog.csdn.net/zhoupenghui168/article/details/125286811

一.数组的遍历

方式一: 常规方法-for循环

package main

import(
    "fmt"
)

func main(){    

    // 从终端循环输入5个成绩,保存到float64数组,并输出
	 var score [5]float64
	 for i := 0; i < len(score); i++ {
	 	fmt.Printf("请输入第%d个元素", i+ 1)
	 	fmt.Scanln(&score[i])
	 }	
 
     //打印
	 for i :=0; i < len(score); i++ {
	 	fmt.Printf("score[%d] = %v\n", i, score[i])
	 }
}

方式二:

        for-range结构遍历

        这是go语言的一种独有的结构,可以遍历访问数组的元素

基本语法

for index, value := range array01() {

        ...

                }

说明:

1.第一个返回值index是数组的下标

2.第二个value是在该下标位置的值

3.index, value 都是仅在for循环内部可见的局部变量

4.遍历数组元素时,如果不想使用下标,可以直接把下标index标为下划线_

5.index, value名称不是固定的,可以自行指定,一般命名为index,value

package main

import (
	"fmt"
)

func main() {
	//演示for-range遍历数组
	heros := [...]string{"张三", "李四", "王五"}
	for index, value := range heros {
		fmt.Printf("i=%v, v=%v\n", index, value)
	}

	for _, value := range heros {
		fmt.Printf("元素的值为:%v\n", value)
	}
}

二.数组注意事项和使用细节

1.数组是多个相同类型数据的组合,一个数组一旦声明/定义了,其长度是固定的,不能动态变化

package main

import (
	"fmt"
)

func test01(arr [3]int) {
	arr[0] = 88
}

func main() {
	//1.数组是多个相同类型数据的组合,一个数组一旦声明/定义了,其长度是固定的,不能动态变化
	var arr1 [3]int
	arr1[0] = 1
	arr1[1] = 2
	arr1[2] = 3.1	// 报错:数组是多个相同类型数据的组合, constant 3.1 truncated to integer
    
    //其长度是固定的,不能动态变化,否则越界
	arr1[3] = 4		//长度越界了:invalid array index 3 (out of bounds for 3-element array)
	fmt.Println(arr1)
}

2.var arr []int 这时的arr是一个切片slice,后面章节介绍

3.数组中的元素可以是任何数据类型,包括值类型和引用类型,但是不能混用

4.数组创建后,如果没有赋值,默认为零值

package main

import(
    "fmt"
)

func main(){
    //4.数组创建后,如果没有赋值,默认为零值
	//1.数值(整数系列,浮点数系列) => 0
	//2.字符串 => ""
	//3.bool => false
	var arr01 [3]float32
	var arr02 [3]string
	var arr03 [3]bool
	fmt.Printf("arr01=%v arr02=%v, arr03=%v\n", arr01, arr02, arr03)	// arr01=[0 0 0] arr02=[  ], arr03=[false false false]

}

5.使用数组的步骤

1.声明数组并开辟空间

2.给数组各个元素赋值(默认值为零)

3.使用数组

6.数组的下标是从0开始的

package main

import(
    "fmt"
)

func main(){
    //6.数组的下标是从0开始的
	var arr04 [2]int	//[0~1]
	var index int = 3
	arr04[index] = 3
	fmt.Println(arr04)	//下标是0~1,arr04[2]越界, panic: runtime error: index out of range [3] with length 2
}

7.数组下标必须在指定范围内使用,否则会报错(panic):数组越界,比如:var arr []int4 ==>有效下标为0~3

8.go的数组属于值类型,在默认情况下是值传递,因此会进行值拷贝,数组间不会相互影响

package main

import(
    "fmt"
)

func test01(arr [3]int) {
	arr[0] = 88
}

func main(){
    //8.go的数组属于值类型,在默认情况下是值传递,因此会进行值拷贝,数组间不会相互影响
	arr := [3]int{11,22,33}
	test01(arr)
	fmt.Println(arr)	//	11,22,33
}

9.如想在其他函数中,去修改原来的数组,可以使用引用传递(指针方式)

package main

import(
    "fmt"
)

func test02(arr *[3]int) {
	fmt.Printf("arr指针的地址为:%p\n", &arr)	//arr指针的地址为:0xc000006030
	(*arr)[0] = 88
}

func main(){
        //9.如想在其他函数中,去修改原来的数组,可以使用引用传递(指针方式)
		arr := [3]int{11,22,33}
		fmt.Printf("arr的地址为:%p\n", &arr)	//arr的地址为:0xc000016168
		test02(&arr)
		fmt.Println(arr)	//[88 22 33]
}

10.长度是数组类型的一部分,在传递函数参数时,需要考虑数组的长度

三.数组的应用实例

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	//1.创建一个byte类型的26个元素的数组,分别放置A~Z
	//使用for循环访问所有元素并打印,提示:字符运算'A' + 1  => 'B'
	//思路:
	//1.声明一个变量 var myChars [26]byte
	//2.使用for循环,利用字符可以进行运算的特点来赋值'A' + 1  => 'B'
	//3.使用for循环打印
	var myChars [26]byte
	for i := 0; i < len(myChars); i++ {
		myChars[i] = 'A' + byte(i)	//注意:要将i=>byte
	}
	for i := 0; i < len(myChars); i++ {
		fmt.Printf("%c ", myChars[i])	//  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 
	}
	fmt.Println()
	
	//2.请求出一个数组的最大值,并得到对应的下标
	//思路:
	//1.声明一个数组, var arr = [...]{-1, 2, 5, 3, 90, 22}
	//2.假定第一个元素就是最大值,下标为0
	//3.然后从第二个元素开始循环比较,如果发现有更大的,则交换
	var arr = [...]int{-1, 2, 5, 3, 90, 22}
	var max = arr[0]
	var index = 0
	for i := 1; i < len(arr); i++ {
		if arr[i] > max {
			max = arr[i]
			index = i
		}
	}

	fmt.Printf("max = %v, index = %v\n", max, index)	//max = 90, index = 4

	//3.请求出一个数组的和以及平均值,使用for-range
	//思路:
	//1.先声明一个数组var arr = [...]int{-1, 2, 5, 3, 90, 22}
	//2.求出sum
	//3.求出平均值
	var arr1 = [...]int{-1, 2, 3, 90, 23}
	var sum int
	var avg float64
	for _, value := range arr1 {
		//累计求和
		sum += value
	}
	//如何让平均值保留小数
	avg = float64(sum) / float64(len(arr1))
	fmt.Printf("sum= %v, avg = %v\n", sum, avg)	//sum= 117, avg = 23.4

	//4.要求.随机生成5个数,并将其反转打印
	//思路:
	//1.随机生成五个数,rand.Intn()
	//2.当我们得到随机数后,就放到一个数组 int数组
	//3.反转打印: 交换的次数 = 数组大小 / 2 , 倒数第一个和第一个交换,倒数第二个和第二个交换, ...
	var arr3 [5]int
	//为了每次生成的随机数不一样,我们需要给一个Seed值
	lenArr3 :=  len(arr3)
	rand.Seed(time.Now().UnixNano())
	for i := 0; i < lenArr3; i++ {
		arr3[i] = rand.Intn(100)	// 0 <= < 100
	}
	fmt.Println(arr3)	//交换前打印: [9 96 83 40 55]

	temp := 0	//一个临时变量
	for i := 0; i < lenArr3 / 2; i++ {
		temp = arr3[lenArr3 - 1 -i]
		arr3[lenArr3 - 1 -i] = arr3[i]
		arr3[i] = temp
	}
	fmt.Println(arr3)	//交换后打印: 55 40 83 96 9]
}

上一节:[go学习笔记.第七章.数组和切片] 1.数组的快速入门，定义和内存布局

下一节:[go学习笔记.第七章.数组和切片] 3.切片的基本介绍和入门,切片在内存中的布局分析