Go数组

package main
import (
	"fmt"
)

func main() {

	var intArr [3]int //int占8个字节
	//当我们定义完数组后，其实数组的各个元素有默认值 0
	fmt.Println(intArr) //[0 0 0]
	intArr[0] = 10
	intArr[1] = 20
	intArr[2] = 30
	fmt.Println(intArr) //[10 20 30]
	fmt.Printf("intArr的地址=%p intArr[0] 地址%p intArr[1] 地址%p intArr[2] 地址%p\n",
		&intArr, &intArr[0], &intArr[1], &intArr[2])
	//intArr的地址=0xc000010360 intArr[0] 地址0xc000010360 intArr[1] 地址0xc000010368 intArr[2] 地址0xc000010370


	//四种初始化数组的方式
	var numArr01 [3]int = [3]int{1, 2, 3}
	fmt.Println("numArr01=", numArr01) //numArr01= [1 2 3]

	var numArr02 = [3]int{5, 6, 7}
	fmt.Println("numArr02=", numArr02) //numArr02= [5 6 7]

	//这里的 [...] 是规定的写法
	var numArr03 = [...]int{8, 9, 10}
	fmt.Println("numArr03=", numArr03) //numArr03= [8 9 10]

	var numArr04 = [...]int{1: 800, 0: 900, 2:999}
	fmt.Println("numArr04=", numArr04) //numArr04= [900 800 999]

	//类型推导
	strArr05 := [...]string{1: "tom", 0: "jack", 2:"mary"}
	fmt.Println("strArr05=", strArr05) //strArr05= [jack tom mary]
}

package main
import (
	"fmt"
)

func main() {

	//演示for-range遍历数组
	heroes  := [...]string{"宋江", "吴用", "卢俊义"}
	//使用常规的方式遍历，我不写了..

	for i, v := range heroes {
		fmt.Printf("i=%v v=%v\n", i , v)
		fmt.Printf("heroes[%d]=%v\n", i, heroes[i])
	}

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

package main
import (
	"fmt"
)

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

//函数
func test02(arr *[3]int) {  // 此时的arr变成了指向数组的一个指针
	fmt.Printf("arr指针的地址=%p", &arr) //arr指针的地址=0xc00008e020
	(*arr)[0] = 88 //*arr 取值符
}

func main() {

	/*
	//数组是多个相同类型数据的组合,一个数组一旦声明/定义了,其长度是固定的, 不能动态变化。
	var arr01 [3]int
	arr01[0] = 1
	arr01[1] = 30
	//这里会报错
	arr01[2] = 1.1
	//其长度是固定的, 不能动态变化,否则报越界
	arr01[3] = 890

	fmt.Println(arr01)
	*/

	//数组创建后，如果没有赋值，有默认值(零值)
	//1. 数值(整数系列, 浮点数系列) =>0
	//2. 字符串 ==> ""
	//3. 布尔类型 ==> 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]
	
	//数组的下标是从0开始的
	// var arr04 [3]string // 0 - 2
	// var index int = 3
	// arr04[index] = "tom" // 因为下标是 0 - 2 ,因此arr04[3]就越界

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


	arr := [3]int{11, 22, 33}
	fmt.Printf("arr 的地址=%p\n", &arr) //arr 的地址=0xc000060160
	test02(&arr)
	fmt.Println("main arr=", arr) //main arr= [88 22 33]
}

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 < 26; i++ {
		myChars[i] = ‘A‘ + byte(i) // 注意需要将 i => byte
	}

	for i := 0; i < 26; i++ {
		fmt.Printf("%c ", myChars[i])
	}

	//2)请求出一个数组的最大值，并得到对应的下标
	//思路
	//1. 声明一个数组 var intArr[5] = [...]int {1, -1, 9, 90, 11}
	//2. 假定第一个元素就是最大值，下标就0
	//3. 然后从第二个元素开始循环比较，如果发现有更大，则交换
	fmt.Println()
	var intArr [6]int = [...]int {1, -1, 9, 90, 11, 9000}
	maxVal := intArr[0]
	maxValIndex := 0

	for i := 1; i < len(intArr); i++ {
		//然后从第二个元素开始循环比较，如果发现有更大，则交换
		if maxVal < intArr[i] {
			maxVal = intArr[i]
			maxValIndex = i
		}
	}
	fmt.Printf("maxVal=%v maxValIndex=%v\n\n", maxVal, maxValIndex)

	//3)请求出一个数组的和和平均值。for-range
	//思路
	//1. 就是声明一个数组  var intArr[5] = [...]int {1, -1, 9, 90, 11}
	//2. 求出和sum
	//3. 求出平均值
	//代码
	var intArr2 [5]int = [...]int {1, -1, 9, 90, 12}
	sum := 0
	for _, val := range intArr2 {
		//累计求和
		sum += val
	}
	//如何让平均值保留到小数.
	fmt.Printf("sum=%v 平均值=%v \n\n", sum, float64(sum) / float64(len(intArr2)))


	//5)要求：随机生成五个数，并将其反转打印
	//思路
	//1. 随机生成五个数 , rand.Intn() 函数
	//2. 当我们得到随机数后，就放到一个数组 int数组
	//3. 反转打印 , 交换的次数是  len / 2, 倒数第一个和第一个元素交换, 倒数第2个和第2个元素交换
	var intArr3 [5]int
	//为了每次生成的随机数不一样，我们需要给一个seed值
	len := len(intArr3)
	rand.Seed(time.Now().UnixNano())
	for i := 0; i < len; i++ {
		intArr3[i] = rand.Intn(100) //  0<=n<100
	}

	fmt.Println("交换前~=", intArr3)
	//反转打印 , 交换的次数是  len / 2, 
	//倒数第一个和第一个元素交换, 倒数第2个和第2个元素交换
	temp := 0  //做一个临时变量
	for i := 0; i < len / 2; i++ {
		temp = intArr3[len - 1 - i]
		intArr3[len - 1 - i] = intArr3[i]
		intArr3[i] = temp
	}
	fmt.Println("交换后~=", intArr3)
}