【Go】Go语言中的数组基本语法与应用实战

✨✨ 欢迎大家来到景天科技苑✨✨

🎈🎈 养成好习惯，先赞后看哦~🎈🎈

🏆 作者简介：景天科技苑
🏆《头衔》：大厂架构师，华为云开发者社区专家博主，阿里云开发者社区专家博主，CSDN全栈领域优质创作者，掘金优秀博主，51CTO博客专家等。
🏆《博客》：Python全栈，Golang开发，PyQt5和Tkinter桌面开发，小程序开发，人工智能，js逆向，App逆向，网络系统安全，数据分析，Django，fastapi，flask等框架，云原生K8S，linux，shell脚本等实操经验，网站搭建，数据库等分享。

所属的专栏：Go语言开发零基础到高阶实战
景天的主页：景天科技苑

Go语言数组

Go语言中的数组（Array）和切片（Slice）是处理数据的两种重要数据结构。
数组是一种相同数据类型、并且具有固定长度的序列，而切片则是对数组或另一个切片的一个连续片段的引用，提供了一种灵活且强大的方式来操作数据集合。

什么是数组

• 一组数
  • 数组需要是相同类型的数据的集合
  • 数组是需要定义大小的
  • 数组一旦定义了大小是不可以改变的。

数组的基本用法

1. 数组的声明

数组和其他变量定义没什么区别，唯一的就是这个是一组数，需要给一个大小 [6]int [10]string
数组是一个相同类型数据的有序集合，通过下标来取出对应的数据

2. 数组几个特点：

1、长度必须是确定的，如果不确定，就不是数组，大小不可以改变
2、元素必须是相，同类型不能多个类型混合, [any也是类型，可以存放任意类型的数据]
3、数组的中的元素类型，可以是我们学的所有的类型，int、string、float、bool、array、slice、map

3. 数组的定义方式

数组的定义： [数组的大小size] 变量的类型 ，
我们定义了一组这个类型的数组集合，大小为size，最多可以保存size个数

定义了数组数据类型， 数组中的数据必须使用同一种数据类型，否则报错

package main

import "fmt"

func main() {
    //定义数组: [数组的大小size] 变量的类型
    //定义了数据类型，数组里面必须使用同一种数据类型
        //定义了数组长度，如果某个下标未赋值，会给出其数据类型的默认值

    var a = [5]int{1, 2, 3, 4, "5"}
    fmt.Println(a)

}

数组赋值：
声明数组长度和数据类型

var a [5]int
// 给数组赋值,下标index，所有的数组下标都是从0开始的。
a[0] = 100
a[1] = 200
a[2] = 300
a[3] = 400
a[4] = 500

打印数组
fmt.Println(a)


通过下标方式获取数组某元素
fmt.Println(a[1])

获取数组长度和数组容量
数组中的常用方法 len()获取数组的长度 cap() 获取数组的容量
数组的容量在定义后就不能更改，而切片的容量在定义后可以更改。

fmt.Println("数组长度:", len(a))
fmt.Println("数组容量", cap(a))

修改数组的值，直接通过下标修改

a[2] = 3000
fmt.Println(a)
fmt.Println(a[2])

完整代码：

package main

import "fmt"

// 数组
// 数组和其他变量定义没什么区别，唯一的就是这个是一组数，需要给一个大小  [6]int   [10]string
// 数组是一个相同类型数据的==有序==集合，通过下标来取出对应的数据
// 数组几个特点：
// 1、长度必须是确定的，如果不确定，就不是数组，大小不可以改变
// 2、元素必须是相，同类型不能多个类型混合, [any也是类型，可以存放任意类型的数据]
// 3、数组的中的元素类型，可以是我们学的所有的类型，int、string、float、bool、array、slice、map

func main() {
    //数组本身也是一种数据类型
    //定义数组: [数组的大小size] 变量的类型
    //定义了数据类型，数组里面必须使用同一种数据类型
    //声明数组长度和数据类型
    var a [5]int
    // 给数组赋值,下标index，所有的数组下标都是从0开始的。
    //定义了数组长度，如果某个下标未赋值，会给出其数据类型的默认值
    a[0] = 100
    a[1] = 200
    a[2] = 300
    a[3] = 400
    a[4] = 500

    //打印数组
    fmt.Println(a)

    //取出数组中的某元素
    fmt.Println(a[1])

    //数组中的常用方法 len()获取数组的长度  cap() 获取数组的容量
    fmt.Println("数组长度:", len(a))
    fmt.Println("数组容量", cap(a))

    //修改数组的值
    a[2] = 3000
    fmt.Println(a)
    fmt.Println(a[2])

}

4. 初始化数组的几种方式

1.在定义数组的时候就直接初始化，用大括号包裹数组的值

var arr1 = [5]int{1, 2, 3, 4, 5}
fmt.Println(arr1)

2.短变量快速初始化

arr2 := [3]int{1, 2, 3}
fmt.Println(arr2)

3. 自动根据数组的长度来给 … 赋值，自动推导长度
   数据如果来自用户，我不知道用户给我多少个数据，数组
   … 代表数组的长度
   Go的编译器会自动根据数组的长度来给 … 赋值，自动推导长度
   注意点：这里的数组不是无限长的，也是固定的大小，大小取决于数组元素个数。

var arr3 = [...]int{1, 2, 3, 4, 5, 5, 6, 7, 8, 8, 8}
fmt.Println(len(arr3))
fmt.Println(arr3)

4. 数组默认值,我只想给其中的某几个index位置赋值。
   {index:值}

var arr4 [10]int
arr4 = [10]int{1: 100, 5: 500}
fmt.Println(arr4) // [0 100 0 0 0 500 0 0 0 0]

给赋值的下标有值，没赋值的下标是默认值

完整代码：

package main

import "fmt"

func main() {
    // 在定义数组的时候就直接初始化，用大括号包裹数组的值
    var arr1 = [5]int{1, 2, 3, 4, 5}
    fmt.Println(arr1)

    //短变量快速初始化
    arr2 := [3]int{1, 2, 3}
    fmt.Println(arr2)

    // 比较特殊的点
    // 数据如果来自用户，我不知道用户给我多少个数据，数组
    // ... 代表数组的长度
    // Go的编译器会自动根据数组的长度来给 ... 赋值，自动推导长度
    // 注意点：这里的数组不是无限长的，也是固定的大小，大小取决于数组元素个数。
    //var arr3 = [...]int{1, 2, 3, 4, 5, 5, 6, 7, 8, 8, 8}
    arr3 := [...]int{1, 2, 3, 4, 5, 5, 6, 7, 8, 8, 8}
    fmt.Println(len(arr3))
    fmt.Println(arr3)

    // 数组默认值,我只想给其中的某几个index位置赋值。
    // {index:值}
    var arr4 [10]int
    arr4 = [10]int{1: 100, 5: 500}
    fmt.Println(arr4) // [0 100 0 0 0 500 0 0 0 0]
}


遍历数组元素
遍历数组可以通过下标获取元素 arr[index]、使用for循环或者for-range结构。
直接通过下标获取元素 arr[index]

使用for循环遍历：
for i := 0; i < len(arr); i++ {  
    fmt.Println(arr[i])  
}

使用for-range遍历：
for index, value := range arr {  
    fmt.Printf("Index: %d, Value: %d\n", index, value)  
}

goland 快捷方式 数组.forr，来循环数组。

切片很多时候都使用for range
for 下标,下标对应的值 range 目标数组切片
就是将数组进行自动迭代。返回两个值 index、value
注意点，如果只接收一个值，这个时候返回的是数组的下标
注意点，如果只接收两个值，这个时候返回的是数组的下标和下标对应的值

package main

import "fmt"

/*
1、直接通过下标获取元素 arr[index]

2、 0-len i++ 可以使用for循环来结合数组下标进行遍历

3、for range：范围   (new)
*/
func main() {

    var 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])
    // 错误：index 5 out of bounds [0:5] 数组下标越界
    // 数组的长度只有5，你要取出6个元素，不可能取出
    //fmt.Println(arr1[5])
    fmt.Println("------------------")
    // 获取数组的长度  len()
    // 下标从0开始，不能<=
    for i := 0; i < len(arr1); i++ {
        fmt.Println(arr1[i])
    }
    fmt.Println("------------------")
    // goland 快捷方式 数组.forr，未来循环数组、切片很多时候都使用for    range
    // for 下标,下标对应的值  range 目标数组切片
    // 就是将数组进行自动迭代。返回两个值 index、value
    // 注意点，如果只接收一个值，这个时候返回的是数组的下标
    // 注意点，如果只接收两个值，这个时候返回的是数组的下标和下标对应的值
    // 如果我们只想要数组的值，index可以用_匿名变量来接收
    for _, value := range arr1 {
        fmt.Println(value)
    }

}

数组是值类型

所有的赋值后的对象修改值后不影响原来的对象，赋值后的对象和原对象是互相独立的
验证值传递还是引用传递一个很好的方式就是：赋值后修改值，看是否影响原来的变量值，如果不影响就是值传递，影响了就是引用传递

package main

import "fmt"

// 数组是值类型： 所有的赋值后的对象修改值后不影响原来的对象。
func main() {
    //数组类型的样子 [size]type
    arr1 := [4]int{1, 2, 3, 4}
    arr2 := [5]string{"景天", "科技"}
    //字符串类型的值不写，默认是空串
    fmt.Println(arr1, "\n", arr2)
    fmt.Printf("%T\n", arr1) // [4]int
    fmt.Printf("%T\n", arr2) // [5]string

    // 数组的值传递和int等基本类型一致
    arr3 := arr1
    fmt.Println(arr1)
    fmt.Println(arr3)

    // 修改arr3观察arr1是否会变化
    arr3[0] = 12
    fmt.Println(arr1)
    fmt.Println(arr3) // 数组是值传递，拷贝一个新的内存空间
}

可见修改赋值后的变量值，不影响原来变量的值，得知数组是值传递

数组排序

数组的排序，一组数是乱序的，我们如何将它按照升序或者降序排列。

常见的排序算法：冒泡排序、插入排序、选择排序、希尔排序、堆排序、快速排序、归并排序、基数排序…

arr := [6]int{1,2,3,4,5,0}
// 升序 ASC  ： 从小到大  0,1,2,3,4,5   A-Z    00:00-24:00
// 降序 DESC ： 从大到小  5,4,3,2,1,0

数据结构：数组就是最简单的数据结构之一

算法：冒泡排序

package main

import "fmt"

// 冒泡：每次筛选出一个最大或者最小的数.
/*
index   0   1   2   3   4
value   12  99  79  48  55
*/
// 冒泡排序逻辑，两两比较，大的往后移或者前移。 大
// 第一轮 ： 12 79 48 55 99 // 5
// 第二轮 ： 12 48 55 79 99 // 4
// 第三轮 ： 12 48 55 79 99 // 3 //
// 第四轮 ： 12 48 55 79 99 //
// 第五轮 ： 12 48 55 79 99

// 代码实践
/*
    // 两个数判断，如果一个数大，则交换位置，大放到后面
    if arr[x] > arr[x+1] {
        arr[x], arr[x+1] = arr[x+1],arr[x]
    }
    // 多轮判断，for， 循环次数 【数组大小】
*/
func main() {

    arr := [...]int{12, 99, 79, 48, 55, 1, 110, 111, 23, 52, 354, 2, 3412, 3, 12, 31}
    fmt.Println("初始数组：", arr)
    // 冒泡排序
    // 1、多少轮
    for i := 1; i < len(arr); i++ {
        // 2、筛选出来最大数字以后，我们下次不需要将它再计算了
        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("第", i, "交换：", arr)
    }

}

我们看到在第12次交换后，其实已经排序好了，但是循环还在继续

为了节省计算机资源，我们希望排序完之后不再继续进行比较了，怎么实现呢？
看如下代码
临时变量检测法

package main

import "fmt"

func main() {
    a := [...]int{21, 72, 564, 27, -12, 0, 32, 999, 54, 81}
    //打印最初数组
    fmt.Println("最初数组", a)

    //冒泡排序
    for i := 1; i < len(a); i++ {
        //交换之前先将a赋值给一个临时变量。当交换结束，a与临时变量相同，表示已经排序完成
        temp := a
        //筛选出来最大数字后就不需要再次进行比较了
        for j := 0; j < len(a)-i; j++ {
            if a[j] > a[j+1] {
                a[j], a[j+1] = a[j+1], a[j]
            }

        }
        //排序好后结束循环
        //交换完成判断，a是否发生了变化，如果没变表示排序结束，结束循环
        if a == temp {
            break
        }

        fmt.Println("第", i, "次交换", a)

    }
    fmt.Println("排序后的数组:", a)

}

多维数组

一维数组： 线性的，一组数

二维数组： 表格性的，数组套数组

三维数组： 立体空间性的，数组套数组套数组

xxxx维数组：xxx，数组套数组套数组…

用法代码展示

package main

import "fmt"

func main() {

    // 定义一个多维数组  二维

    arr := [3][4]int{
        {0, 1, 2, 3},   // arr[0]  //数组
        {4, 5, 6, 7},   // arr[1]
        {8, 9, 10, 11}, // arr[2]
    }
    // 二维数组，一维数组存放的是一个数组
    fmt.Println(arr[0])
    // 要获取这个二维数组中的某个值，找到对应一维数组的坐标，arr[0] 当做一个整体
    fmt.Println(arr[0][1])
    fmt.Println("------------------")
    // 如何遍历二维数组
    for i := 0; i < len(arr); i++ {
        for j := 0; j < len(arr[i]); j++ {
            fmt.Println(arr[i][j])
        }
    }
    // for range
    for i, v := range arr {
        fmt.Println(i, v)
    }
}