摘要：
每次都数组中获取下标和对应的数值。*/arr1:=[5]int{1,2,3,4,5}fmt.Printlnfmt.Printlnfmt.Printlnfmt.Printlnfmt.Printlnfmt.Printlnfori:=0;i˂len;i++{arr1[i]=i*2+1fmt.Println}fmt.Printlnfmt.Printlnforindex,value:=rangearr1{fmt.Printf}sum:=0for_,v:=rangearr1{sum+=v}fmt.Println}3.数组是值类型packagemainimport"fmt"funcmain(){/*数据类型：基本类型：int，float，string，bool。。*///1.数据类型num:=10fmt.Printfarr1:=[4]int{1,2,3,4}arr2:=[3]float64{2.15,3.18,6.19}arr3:=[4]int{5,6,7,8}arr4:=[2]string{"hello","world"}fmt.Printf//[4]intfmt.Printf//[3]float64fmt.Printf//[4]intfmt.Printf//[2]string//2.赋值num2:=num//值传递fmt.Println//1010num2=20fmt.Println//1020//数组呢arr5:=arr1//值传递fmt.Printlnfmt.Printlnarr5[0]=100fmt.Printlnfmt.Printlna:=3b:=4fmt.Println//比较a和b的数值是否相等fmt.Println//比较数组的对应下标位置的数值是否相等//fmt.Println//invalidoperation:arr1==arr2}4.数组排序packagemainimport"fmt"funcmain(){/*数组的排序：让数组中的元素具有一定的顺序。
1. 数组的创建和使用
package main
import "fmt"
func main() {
/*
数据类型：
基本类型：整数，浮点，布尔，字符串
复合类型：array，slice，map，struct，pointer，function，channel。。。
数组：
1.概念：存储一组相同数据类型的数据结构
理解为容器，存储一组数据
2.语法：
var 数组名 [长度] 数据类型
var 数组名 = [长度] 数据类型{元素1，元素2，。。。}
数组名 := [...]数据类型{元素。。。}
3.通过下标访问
下标，也叫索引：index，
默认从0开始的整数，直到长度减1
数组名[index]
赋值
取值
不能越界：[0,长度-1]
4.长度和容量：go语言的内置函数
len(array/map/slice/string)，长度
cap()，容量
*/
var num1 int
num1 = 100
num1 = 200
fmt.Println(num1)
fmt.Printf("%p
",&num1)
//step1：创建数组
var arr1 [4] int
fmt.Printf("%p
",&arr1)
//step2：数组的访问
arr1[0] = 1
arr1[1] = 2
arr1[2] = 3
arr1[3] = 4
fmt.Println(arr1[0])//打印第一个数值
fmt.Println(arr1[2])//打印第三个数值
//fmt.Println(arr1[4]) //invalid array index 4 (out of bounds for 4-element array)
fmt.Println("数组的长度：",len(arr1)) //容器中实际存储的数据量
fmt.Println("数组的容量：",cap(arr1)) //容器中能够存储的最大的数量
//因为数组定长，长度和容量相同
arr1[0] = 100
fmt.Println(arr1[0])
//数组的其他创建方式
var a [4] int //同 var a= [4] int
fmt.Println(a) //[0 0 0 0]
var b = [4]int{1,2,3,4}
fmt.Println(b) //[1 2 3 4]
var c = [5]int{1,2,4}
fmt.Println(c) //[1 2 4 0 0]
var d = [5]int{1:1,3:2}
fmt.Println(d) //[0 1 0 2 0]
var e = [5]string{"rose","王二狗","ruby"}
fmt.Println(e) //[rose 王二狗 ruby ]
f := [...]int{1,2,3,4,5}
fmt.Println(f) //[1 2 3 4 5]
fmt.Println(len(f)) //5
g:=[...]int{1:3,6:5}
fmt.Println(g) //[0 3 0 0 0 0 5]
fmt.Println(len(g)) //7
}
2. 数组的遍历
package main
import "fmt"
func main() {
/*
数组的遍历：
依次访问数组中的元素
方法一：arr[0],arr[1],arr[2]....
方法二：通过循环，配合下标
for i:=0;i<len(arr);i++{
arr[i]
}
方法三：使用range
range，词义"范围"
不需要操作数组的下标，到达数组的末尾，自动结束for range循环。
每次都数组中获取下标和对应的数值。
*/
arr1 := [5]int{1, 2, 3, 4, 5}
fmt.Println(arr1[0])
fmt.Println(arr1[1])
fmt.Println(arr1[2])
fmt.Println(arr1[3])
fmt.Println(arr1[4])
fmt.Println("---------------")
for i := 0; i < len(arr1); i++ {
arr1[i] = i*2 + 1
fmt.Println(arr1[i])
}
fmt.Println(arr1)
fmt.Println("----------------")
for index, value := range arr1 {
fmt.Printf("下标是：%d,数值是:%d
", index, value)
}
sum := 0
for _, v := range arr1 {
sum += v
}
fmt.Println(sum)
}
3. 数组是值类型
package main
import "fmt"
func main() {
/*
数据类型：
基本类型：int，float，string，bool。。
复合类型：array，slice，map，function，pointer，channel。。
数组的数据类型：
[size]type
值类型：理解为存储的数值本身
将数据传递给其他的变量，传递的是数据的副本(备份)
int,float,string,bool,array
引用类型：理解为存储的数据的内存地址
slice，map。。
*/
//1.数据类型
num := 10
fmt.Printf("%T
", num)
arr1 := [4]int{1, 2, 3, 4}
arr2 := [3]float64{2.15, 3.18, 6.19}
arr3 := [4]int{5, 6, 7, 8}
arr4 := [2]string{"hello", "world"}
fmt.Printf("%T
", arr1) //[4]int
fmt.Printf("%T
", arr2) //[3]float64
fmt.Printf("%T
", arr3) //[4]int
fmt.Printf("%T
", arr4) //[2]string
//2.赋值
num2 := num //值传递
fmt.Println(num, num2) //10 10
num2 = 20
fmt.Println(num, num2) //10 20
//数组呢
arr5 := arr1 //值传递
fmt.Println(arr1)
fmt.Println(arr5)
arr5[0] = 100
fmt.Println(arr1)
fmt.Println(arr5)
a := 3
b := 4
fmt.Println(a == b) //比较a和b的数值是否相等
fmt.Println(arr5 == arr1) //比较数组的对应下标位置的数值是否相等
//fmt.Println(arr1 == arr2) //invalid operation: arr1 == arr2 (mismatched types [4]int and [3]float64)
}
4. 数组排序（冒泡排序）
package main
import "fmt"
func main() {
/*
数组的排序：
让数组中的元素具有一定的顺序。
arr :=[5]int{15,23,8,10,7}
升序：[7,8,10,15,23]
将序：[23,15,10,8,7]
排序算法：
冒泡排序，插入排序，选择排序，希尔排序，堆排序，快速排序。。。。
冒泡排序：（Bubble Sort）
依次比较两个相邻的元素，如果他们的顺序（如从大到小）就把他们交换过来。
*/
arr := [5]int{15, 23, 8, 10, 7}
////第一轮排序
//for j := 0; j < 4; j++ {
// if arr[j] > arr[j+1] {
// arr[j], arr[j+1] = arr[j+1], arr[j]
// }
//}
//fmt.Println(arr)
//
////第二轮排序
//for j:=0;j<3;j++{
// if arr[j] > arr[j+1] {
// arr[j], arr[j+1] = arr[j+1], arr[j]
// }
//}
//fmt.Println(arr)
for i:=1;i<len(arr);i++{
for j := 0; j < len(arr)-i; j++ {
if arr[j] > arr[j+1] {
arr[j], arr[j+1] = arr[j+1], arr[j]
}
}
fmt.Println(arr)
}
}
//[15 8 10 7 23] //第一轮，最大的23被找到
//[8 10 7 15 23] //第二轮，最大的15被找到（因为你len()-1,23最大不用比了）
//[8 7 10 15 23]
//[7 8 10 15 23]
5. 多维数组
package main
import "fmt"
func main() {
/*
一维数组：存储的多个数据是数值本身
a1 :=[3]int{1,2,3}
二维数组：存储的是一维的一维
//3个一维数组，每个一维数组长度为4
a2 := [3][4]int{{},{},{}}
该二维数组的长度，就是3。
存储的元素是一维数组，一维数组的元素是数值，每个一维数组长度为4。
多维数组：。。。
*/
a2 := [3][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}
fmt.Println(a2)
fmt.Printf("二维数组的地址：%p
", &a2)
fmt.Printf("二维数组的长度：%d
", len(a2))
fmt.Printf("一维数组的长度：%d
", len(a2[0]))
fmt.Println(a2[0][3]) // 4
fmt.Println(a2[1][2]) //7
fmt.Println(a2[2][1]) // 10
//遍历二维数组
for i:=0;i<len(a2);i++{
for j:=0;j<len(a2[i]);j++{
fmt.Print(a2[i][j]," ")
}
fmt.Println()
}
fmt.Println("---------------------")
//for range 遍历二维数组
for _,arr := range a2{
for _,val := range arr{
fmt.Print(val," ")
}
fmt.Println()
}
//三维数组
//第一个表示有几个二维数组
//中间表示有几个一维数组
//最后一个表示长度
var threedim [2][3][2]int
fmt.Println(threedim) //[[[0 0] [0 0] [0 0]] [[0 0] [0 0] [0 0]]]
var threedim2 [3][2][2]int
fmt.Print(threedim2) // [[[0 0] [0 0]] [[0 0] [0 0]] [[0 0] [0 0]]]
}