Go語言學(xué)習(xí)之?dāng)?shù)組的用法詳解

更新時間：2022年04月22日 14:52:21 作者：隱姓埋名4869

數(shù)組是相同數(shù)據(jù)類型的一組數(shù)據(jù)的集合，數(shù)組一旦定義長度不能修改，數(shù)組可以通過下標(biāo)（或者叫索引)來訪問元素。本文將通過示例詳細(xì)講解Go語言中數(shù)組的使用，需要的可以參考一下

引言

數(shù)組是相同數(shù)據(jù)類型的一組數(shù)據(jù)的集合，數(shù)組一旦定義長度不能修改，數(shù)組可以通過下標(biāo)（或者叫索引)來訪問元素。

相對于去聲明 number0, number1, ..., number99 的變量，使用數(shù)組形式 numbers[0], numbers[1] ..., numbers[99] 更加方便且易于擴展。
數(shù)組元素可以通過索引（位置）來讀取（或者修改），索引從0 開始，第一個元素索引為 0，第二個索引為1，以此類推。

一、數(shù)組的定義

1. 語法

var  variable_name [SIZE] variable_type

variable_name:數(shù)組的名稱

SIZE:數(shù)組長度，必須是常量

variable_type:數(shù)組保存元素的類型

2. 示例

package main
 
import "fmt"
 
func main() {
    var a [3]int    //定義一個int類型的數(shù)組a，長度是3
    var b [2]string //定義一個字符串類型的數(shù)組b，長度是2
 
    fmt.Printf("a: %T\n", a) //使用%T來輸出類型
    fmt.Printf("b: %T\n", b)
    fmt.Printf("a: %v\n", a)
    fmt.Printf("b: %v\n", b)
}
 
 
//輸出結(jié)果如下，可以看到?jīng)]初始化的值，int是0，而字符串則是空的字符串
a: [3]int
b: [2]string
a: [0 0 0]
b: [ ]

從上面運行的結(jié)果中可以看出來，數(shù)組和長度和元素類型共同組成了數(shù)組的類型

二、數(shù)組的初始化

初始化，就是給數(shù)組的元素賦值，沒有初始化的數(shù)組，默認(rèn)元素值都是零值，布爾類型是false，字符串是空字符串。

1. 未初始化的數(shù)組

package main
 
import "fmt"
 
func main() {
    var a [2]bool
    var b [2]int
    var c [3]string
    var d [3]float32
 
    fmt.Printf("a: %v\n", a)
    fmt.Printf("b: %v\n", b)
    fmt.Printf("c: %v\n", c)
    fmt.Printf("d: %v\n", d)
 
}
 
 
//輸出結(jié)果如下
a: [false false]
b: [0 0]
c: [  ]
d: [0 0 0]

2. 使用初始化列表

package main
 
import "fmt"
 
func main() {
    var a = [3]int{1, 2, 3}
    var b = [2]string{"hello world"}
    var c = [2]bool{true, false}
 
    a1 := [2]int{1, 2} //類型推斷
    fmt.Printf("a: %v\n", a)
    fmt.Printf("b: %v\n", b)
    fmt.Printf("c: %v\n", c)
    fmt.Printf("a1: %v\n", a1)
}
 
//輸出結(jié)果如下
a: [1 2 3]
b: [hello world ]
c: [true false]
a1: [1 2]

使用初始化列表，就是將值寫在大括號里面

3. 省略數(shù)組長度

如果數(shù)組長度不確定，可以使用 ...代替數(shù)組的長度，編譯器會根據(jù)元素個數(shù)自行推斷數(shù)組的長度

package main
 
import "fmt"
 
func main() {
    var a = [...]int{1, 2, 3, 4, 5}
    var b = [...]string{"hello", "world", "hello", "go"}
    var c = [...]bool{true, false}
 
    a1 := [...]int{1, 2} //類型推斷
 
    fmt.Printf("a: %v\n", a)
    fmt.Printf("b: %v\n", b)
    fmt.Printf("c: %v\n", c)
    fmt.Printf("a1: %v\n", a1)
}
 
//輸出結(jié)果如下
a: [1 2 3 4 5]
b: [hello world hello go]
c: [true false]
a1: [1 2]

4. 指定索引值的方式來初始化

可以通過指定所有方式來初始化，未指定的所有默認(rèn)值為零值

package main
 
import "fmt"
 
func main() {
    var a = [...]int{0: 1, 2: 2}
    var b = [...]string{1: "hello", 2: "go"}
    var c = [...]bool{2: true, 5: false}
 
    a1 := [...]int{1, 2} //類型推斷
 
    fmt.Printf("a: %v\n", a)
    fmt.Printf("b: %v\n", b)
    fmt.Printf("c: %v\n", c)
    fmt.Printf("a1: %v\n", a1)
}
 
//輸出結(jié)果如下
a: [1 0 2]
b: [ hello go]
c: [false false true false false false]
a1: [1 2]

總結(jié)

初始化數(shù)組中{}中的元素個數(shù)不能大于[]中的數(shù)字。

如果忽略[]中的數(shù)字不設(shè)置數(shù)組大小，Go 語言會根據(jù)元素的個數(shù)來設(shè)置數(shù)組的大小：

5. 訪問數(shù)組元素

數(shù)組元素可以通過索引（位置）來讀取。

格式為數(shù)組名后加中括號，中括號中為索引的值。數(shù)組的最大下標(biāo)為數(shù)組長度-1，大于這個下標(biāo)會發(fā)生數(shù)組越界。

示例

package main
 
import "fmt"
 
func main() {
    var a [2]int
    a[0] = 100
    a[1] = 200
    fmt.Printf("a[0]: %v\n", a[0])
    fmt.Printf("a[1]: %v\n", a[1])
 
    //對數(shù)組進行修改
    a[0] = 1
    a[1] = 2
    fmt.Println("---------修改后--------")
    fmt.Printf("a[0]: %v\n", a[0])
    fmt.Printf("a[1]: %v\n", a[1])
}
 
//輸出結(jié)果如下
a[0]: 100
a[1]: 200
---------修改后--------
a[0]: 1
a[1]: 2

6. 根據(jù)數(shù)組長度遍歷數(shù)組

可以根據(jù)數(shù)組長度，通過for循環(huán)的方式來遍歷數(shù)組，數(shù)組的長度可以使用len函數(shù)獲得

使用len()函數(shù)獲取數(shù)組的長度

package main
 
import "fmt"
 
func main() {
    var a1 = [3]int{1, 2, 3}
    fmt.Printf("len(a1): %v\n", len(a1))
 
    var a2 = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Printf("len(a2): %v\n", len(a2))
}
 
//輸出結(jié)果如下
len(a1): 3
len(a2): 9

數(shù)組遍歷，根據(jù)長度和下標(biāo)

package main
 
import "fmt"
 
func main() {
    a := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
    for i := 0; i < len(a); i++ {
        fmt.Printf("a[%d]:%v\n", i, a[i])
    }
}
 
//輸出結(jié)果如下
a[0]:1
a[1]:2
a[2]:3
a[3]:4
a[4]:5
a[5]:6
a[6]:7
a[7]:8
a[8]:9

使用for range

package main
 
import "fmt"
 
func main() {
    var a = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
    for i, v := range a {               //i也可以使用空白標(biāo)識符代替，不接受索引的值
        fmt.Printf("a[%v]:%v\n", i, v)
    }
}
 
//輸出結(jié)果如下
a[0]:1
a[1]:2
a[2]:3
a[3]:4
a[4]:5
a[5]:6
a[6]:7
a[7]:8
a[8]:9

三. 訪問數(shù)組元素

1. 訪問數(shù)組元素

數(shù)組元素可以通過索引（位置）來讀取。
格式為數(shù)組名后加中括號，中括號中為索引的值。數(shù)組的最大下標(biāo)為數(shù)組長度-1，大于這個下標(biāo)會發(fā)生數(shù)組越界。

示例 ①

package main
 
import "fmt"
 
func main() {
    var a [2]int
    a[0] = 100
    a[1] = 200
    fmt.Printf("a[0]: %v\n", a[0])
    fmt.Printf("a[1]: %v\n", a[1])
 
    //對數(shù)組進行修改
    a[0] = 1
    a[1] = 2
    fmt.Println("---------修改后--------")
    fmt.Printf("a[0]: %v\n", a[0])
    fmt.Printf("a[1]: %v\n", a[1])
}
 
//輸出結(jié)果如下
a[0]: 100
a[1]: 200
---------修改后--------
a[0]: 1
a[1]: 2

示例 ②

package main
 
import "fmt"
 
func main() {
 
    //聲明數(shù)組的同時快速初始化數(shù)組
    balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
 
    //輸出數(shù)組元素
    for i := 0; i < 5; i++ {
        fmt.Printf("balance[i]: %f\n", balance[i])
    }
 
    //輸出每個數(shù)組元素的值
    balance2 := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
    for x := 0; x < 5; x++ {
        fmt.Printf("balance2[x]: %f\n", balance2[x])
    }
 
    //將索引為1和3的元素初始化
    balance3 := [5]float32{1: 2.0, 3: 7.0}
    for y := 0; y < 5; y++ {
        fmt.Printf("balance3: %f\n", balance3[y])
    }
}
 
 
//輸出結(jié)果如下
balance[i]: 1000.000000
balance[i]: 2.000000
balance[i]: 3.400000
balance[i]: 7.000000
balance[i]: 50.000000
balance2[x]: 1000.000000
balance2[x]: 2.000000
balance2[x]: 3.400000
balance2[x]: 7.000000
balance2[x]: 50.000000
balance3: 0.000000
balance3: 2.000000
balance3: 0.000000
balance3: 7.000000
balance3: 0.000000

2. 根據(jù)數(shù)組長度遍歷數(shù)組

可以根據(jù)數(shù)組長度，通過for循環(huán)的方式來遍歷數(shù)組，數(shù)組的長度可以使用len函數(shù)獲得

使用len()函數(shù)獲取數(shù)組的長度

package main
 
import "fmt"
 
func main() {
    var a1 = [3]int{1, 2, 3}
    fmt.Printf("len(a1): %v\n", len(a1))
 
    var a2 = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Printf("len(a2): %v\n", len(a2))
}
 
//輸出結(jié)果如下
len(a1): 3
len(a2): 9

數(shù)組遍歷，根據(jù)長度和下標(biāo)

package main
 
import "fmt"
 
func main() {
    a := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
    for i := 0; i < len(a); i++ {
        fmt.Printf("a[%d]:%v\n", i, a[i])
    }
}
 
//輸出結(jié)果如下
a[0]:1
a[1]:2
a[2]:3
a[3]:4
a[4]:5
a[5]:6
a[6]:7
a[7]:8
a[8]:9

使用for range

package main
 
import "fmt"
 
func main() {
    var a = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
    for i, v := range a {               //i也可以使用空白標(biāo)識符代替，不接受索引的值
        fmt.Printf("a[%v]:%v\n", i, v)
    }
}
 
//輸出結(jié)果如下
a[0]:1
a[1]:2
a[2]:3
a[3]:4
a[4]:5
a[5]:6
a[6]:7
a[7]:8
a[8]:9

四、冒泡排序

1. 控制臺輸入十名學(xué)生的成績，如果低于60自動修改為60，并最終展示成績清單

package main
 
import "fmt"
 
func main() {
    var source [10]float32 //分?jǐn)?shù)
    var s float32          //初始化成績
    //遍歷數(shù)組
    for i := 0; i < 10; i++ {
        fmt.Printf("請輸入第%d學(xué)生的成績:", i+1)
        fmt.Scan(&s)
        if s < 60 {
            //修改為60分
            source[i] = 60
        } else {
            //添加學(xué)生成績
            source[i] = s
        }
    }
    fmt.Println("成績錄入成功！")
    fmt.Println("成績清單如下")
    for j := 0; j < 10; j++ {
        fmt.Printf("第%d名學(xué)生的成績", j+1)
        fmt.Println(source[j])
 
    }
}
 
 
//終端輸入結(jié)果
PS D:\goproject\src\dev_code\day10\test\main> go run .\
請輸入第1學(xué)生的成績:50
請輸入第2學(xué)生的成績:55
請輸入第3學(xué)生的成績:80
請輸入第4學(xué)生的成績:70
請輸入第5學(xué)生的成績:90
請輸入第6學(xué)生的成績:50
請輸入第7學(xué)生的成績:30
請輸入第8學(xué)生的成績:44
請輸入第9學(xué)生的成績:55
請輸入第10學(xué)生的成績:66
成績錄入成功！
成績清單如下
第1名學(xué)生的成績60
第2名學(xué)生的成績60
第3名學(xué)生的成績80
第4名學(xué)生的成績70
第5名學(xué)生的成績90
第6名學(xué)生的成績60
第7名學(xué)生的成績60
第8名學(xué)生的成績60
第9名學(xué)生的成績60
第10名學(xué)生的成績66

2. 隨機輸入5個數(shù)字，求出最大值

package main
 
import (
    "fmt"
)
 
func main() {
    var (
        tmp     int    //用來接收比較出來最大的那個數(shù)字
        num     int    //錄入的數(shù)字
        numbers [5]int //5個數(shù)字
    )
    for i := 0; i < 5; i++ {
        fmt.Printf("請輸入第%d個數(shù)字:", i+1)
        fmt.Scan(&num)
        //輸入的數(shù)字添加到集合中
        numbers[i] = num
    }
    fmt.Println("錄入成功！")
    tmp = numbers[0]
    for j := 0; j < 5; j++ {
        //比較最大的數(shù)，大的那個數(shù)用tmp來接收保存，循環(huán)的進行比較
        if numbers[j] > tmp {        //如果是求最小值，把>改為<即可
            tmp = numbers[j]
        }
    }
    fmt.Println("最大值:", tmp)
}
 
//終端輸入結(jié)果如下
PS D:\goproject\src\dev_code\day10\test\main> go run .\
請輸入第1個數(shù)字:888
請輸入第2個數(shù)字:756
請輸入第3個數(shù)字:358
請輸入第4個數(shù)字:218
請輸入第5個數(shù)字:8489
錄入成功！
最大值: 8489

3. 冒泡排序

思路

冒泡排序要對一個列表多次重復(fù)遍歷。它要比較相鄰的兩項，并且交換順序排錯的項，每對列表進行一次遍歷，就有一個最大項排在了正確的位置。
列表的每一個數(shù)據(jù)項都會在其相應(yīng)的位置 冒泡。如果列表有 n 項，第一次遍歷就要比較 n-1 對數(shù)據(jù)。
一旦列表中最大的數(shù)是所比較的數(shù)據(jù)對中的一個，它就會沿著列表一直后移，直到這次遍歷結(jié)束

package main
 
import "fmt"
 
var arr = [...]int{34, 61, 22, 75, 42}
 
func main() {
    fmt.Println("初始值為:", arr)
    //外循環(huán)控制比較的輪數(shù)
    for j := 0; j < len(arr)-1; j++ {
        //內(nèi)循環(huán)控制比較的次數(shù)
        for i := 0; i < len(arr)-j-1; i++ { //內(nèi)層的每輪比較的次數(shù)都-1次
            if arr[i] > arr[i+1] {
                //兩數(shù)比較以后進行位置交換
                arr[i], arr[i+1] = arr[i+1], arr[i]
            }
        }
    }
    fmt.Println("----排序結(jié)束----")
    fmt.Println(arr)
}
 
 
//輸出結(jié)果如下
初始值為: [34 61 22 75 42]
----排序結(jié)束----
[22 34 42 61 75]

控制臺隨機輸入幾個數(shù)，進行冒泡排序

package main
 
import "fmt"
 
var (
    numbers int       //指定輸入的數(shù)
    arr     = []int{} //空數(shù)組
)
 
func main() {
    for i := 0; i < 5; i++ {
        fmt.Printf("請輸入第%d個數(shù)字:", i+1)
        fmt.Scan(&numbers)
        arr = append(arr, numbers)      //使用append進行添加數(shù)組元素
        fmt.Println("添加成功")
    }
    fmt.Println("初始值為:", arr)
    //外循環(huán)控制比較的輪數(shù)
    for j := 0; j < len(arr)-1; j++ {
        //內(nèi)循環(huán)控制比較的次數(shù)
        for i := 0; i < len(arr)-j-1; i++ { //內(nèi)層的每輪比較的次數(shù)都-1次
            if arr[i] > arr[i+1] {
                //兩數(shù)比較以后進行位置交換
                arr[i], arr[i+1] = arr[i+1], arr[i]
            }
        }
    }
    fmt.Println("----排序結(jié)束----")
    fmt.Println(arr)
 
}
 
 
//輸出結(jié)果如下
請輸入第1個數(shù)字:88
添加成功
請輸入第2個數(shù)字:99
添加成功
請輸入第3個數(shù)字:50
添加成功
請輸入第4個數(shù)字:146
添加成功
請輸入第5個數(shù)字:48
添加成功
初始值為: [88 99 50 146 48]
----排序結(jié)束----
[48 50 88 99 146]

五、多維數(shù)組

Go 語言支持多維數(shù)組，如下

//常用的多維數(shù)組聲明方式：
 var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type

//三維的整型數(shù)組：
var threedim [5][10][4]int

1. 二維數(shù)組

二維數(shù)組是最簡單的多維數(shù)組，二維數(shù)組本質(zhì)上是由一維數(shù)組組成的。

二維數(shù)組定義方式如下

var arrayName [ x ][ y ] variable_type

variable_type 為 Go 語言的數(shù)據(jù)類型，arrayName 為數(shù)組名，二維數(shù)組可認(rèn)為是一個表格，x 為行，y 為列

下圖演示了一個二維數(shù)組 a 為三行四列：

二維數(shù)組中的元素可通過 a[i][j]來訪問

package main
 
import "fmt"
 
func main() {
    //創(chuàng)建數(shù)組
    numbers := [][]int{}
    //使用 append() 函數(shù)向空的二維數(shù)組添加兩行一維數(shù)組
    x := []int{1, 2, 3}
    y := []int{4, 5, 6}
    numbers = append(numbers, x)
    numbers = append(numbers, y)
    //顯示兩行數(shù)據(jù)，查看二維數(shù)組中的第一個數(shù)組和第二個數(shù)組
    fmt.Printf("二維數(shù)組中的第1個一維數(shù)組為: %v\n", numbers[0])
    fmt.Printf("二維數(shù)組中的第1個一維數(shù)組為: %v\n", numbers[1])
 
    fmt.Printf("二維數(shù)組中的第1個一維數(shù)組的第一個元素為: ")
    fmt.Println(numbers[0][0]) //numbers[0]里面的第一個元素[0]，為1
 
}
 
 
 
//輸出結(jié)果如下
二維數(shù)組中的第1個一維數(shù)組為: [1 2 3]
二維數(shù)組中的第1個一維數(shù)組為: [4 5 6]
二維數(shù)組中的第1個一維數(shù)組的第一個元素為: 1

2. 初始化二維數(shù)組

多維數(shù)組可通過大括號來初始值，以下為一個3行4列的二維數(shù)組

a := [3][4]int {
    {0,1,2,3},          //第1行索引為0
    {4,5,6,7},          //第2行索引為1
    {8,9,10,11},        //第3行索引為2
    }

注意，上面的代碼中倒數(shù)第二行的 }必須有逗號，因為最后一行的 }不能單獨一行，也可以寫成下面這樣

a := [3][4]int {
    {0,1,2,3},          //第1行索引為0
    {4,5,6,7},          //第2行索引為1
    {8,9,10,11}}        //第3行索引為2

示例，初始化一個2行2列的二維數(shù)組

package main
 
import "fmt"
 
func main() {
    //創(chuàng)建二維數(shù)組
    list := [2][2]string{}
 
    //向二維數(shù)組中添加元素
    list[0][0] = "你好" //第1個一維數(shù)組中的第1個元素
    list[0][1] = "歡迎" //第1個一維數(shù)組中的第2個元素
    list[1][0] = "來到" //第2個一維數(shù)組中的第1個元素
    list[1][1] = "南京" //第2個一維數(shù)組中的第2個元素
 
    //輸出結(jié)果
    fmt.Println(list)
}
 
 
//輸出結(jié)果如下
[[你好 歡迎] [來到 南京]]

3. 訪問二維數(shù)組

二維數(shù)組通過指定坐標(biāo)來訪問。如數(shù)組中的行索引與列索引，例如：

//訪問二維數(shù)組 val 第三行的第四個元素
val := a[2][3]
//或
var value int = a[2][3]

二維數(shù)組可以使用循環(huán)嵌套來輸出元素

package main
 
import "fmt"
 
func main() {
    nums := [2][3]int{
        {1, 2, 3},
        {4, 5, 6},
    }
    //遍歷二維數(shù)組中的每個元素
    //外層循環(huán)讀取行
    for i := 0; i < 2; i++ {
        //內(nèi)層循環(huán)讀取列
        for j := 0; j < 3; j++ {
            fmt.Println(nums[i][j])
        }
    }
}
 
//輸出結(jié)果如下
1
2
3
4
5
6

創(chuàng)建各個維度元素數(shù)量不一致的多維數(shù)組

package main
 
import "fmt"
 
func main() {
    // 創(chuàng)建空的二維數(shù)組
    list := [][]string{}
 
    // 創(chuàng)建三一維數(shù)組，各數(shù)組長度不同
    num1 := []string{"zhang", "wang", "zhao"}
    num2 := []string{"li"}
    num3 := []string{"sun", "jin"}
 
    // 使用 append() 函數(shù)將一維數(shù)組添加到二維數(shù)組中
    list = append(list, num1)
    list = append(list, num2)
    list = append(list, num3)
 
    // 循環(huán)輸出
    for i := range list {
        fmt.Printf("list: %v\n", i)
        fmt.Println(list[i])
    }
}
 
 
//輸出結(jié)果如下
list: 0
[zhang wang zhao]
list: 1
[li]
list: 2
[sun jin]

六、向函數(shù)傳遞數(shù)組

如果想向函數(shù)傳遞數(shù)組參數(shù)，需要在函數(shù)定義時，聲明形參為數(shù)組，可通過如下兩種方式來聲明：

1. 形參設(shè)定數(shù)組大小

void myFunction(param [10]int)
{
.
.
.
}

2. 形參未設(shè)定數(shù)組大小

void myFunction(param []int)
{
.
.
.
}

3. 示例

函數(shù)接收整形數(shù)組參數(shù)，另一個參數(shù)指定了數(shù)組元素的個數(shù)，并求和

package main
 
import "fmt"
//定義數(shù)組,有5個元素
var numbers [5]int
 
func main() {
    numbers = [5]int{10, 20, 30, 40, 50}
    fmt.Println("元素和為:", sum(numbers))
}
 
func sum(arr [5]int) int {
    //定義求和的變量s
    s := 0
    //求和過程
    for i := range arr {
        s += arr[i]
    }
    return s
}
 
 
//輸出結(jié)果如下
元素和為: 150

函數(shù)接收整形數(shù)組參數(shù)，另一個參數(shù)指定了數(shù)組元素的個數(shù)，并求出平均值

package main
 
import "fmt"
 
var (
    //數(shù)組長度為5
    nums = [5]int{10, 20, 40, 60, 80}
    avg  float32
    s    int
)
 
func main() {
    //數(shù)組作為參數(shù)傳遞給函數(shù)
    avg = sums(nums, len(nums))
    //輸出返回的平均值
    fmt.Printf("平均值為: %f", avg)
}
 
//傳入數(shù)組和他的長度，返回值的類型為float32
func sums(x [5]int, length int) float32 {
    for i := 0; i < length; i++ {
        s += x[i]
    }
    avg = float32(s) / float32(length)
    return avg
}
 
 
//輸出結(jié)果如下
平均值為: 42.000000

總結(jié)

數(shù)組的元素可以通過下標(biāo)的方式來訪問，下標(biāo)的最大長度為數(shù)組長度-1，如果大于這個下標(biāo)則會越界

遍歷數(shù)組的兩種方法：

① 通過 for循環(huán)，長度可以使用len()獲取

② 通過for range循環(huán)遍歷數(shù)組，返回數(shù)組下標(biāo)和對應(yīng)的值；若不想要下標(biāo)，可以使用空白標(biāo)識符_來取代

以上就是Go語言學(xué)習(xí)之?dāng)?shù)組的用法詳解的詳細(xì)內(nèi)容，更多關(guān)于Go語言數(shù)組的資料請關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章:

欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

軟件下載

源碼下載

軟件編程

網(wǎng)絡(luò)編程

在線工具

數(shù)據(jù)庫

CMS

常用工具

Go語言學(xué)習(xí)之?dāng)?shù)組的用法詳解

目錄

引言

一、數(shù)組的定義

1. 語法

2. 示例

二、數(shù)組的初始化

1. 未初始化的數(shù)組

2. 使用初始化列表

3. 省略數(shù)組長度

4. 指定索引值的方式來初始化

5. 訪問數(shù)組元素

6. 根據(jù)數(shù)組長度遍歷數(shù)組

三. 訪問數(shù)組元素

1. 訪問數(shù)組元素

2. 根據(jù)數(shù)組長度遍歷數(shù)組

四、冒泡排序

五、多維數(shù)組

1. 二維數(shù)組

2. 初始化二維數(shù)組

3. 訪問二維數(shù)組

六、向函數(shù)傳遞數(shù)組

1. 形參設(shè)定數(shù)組大小

2. 形參未設(shè)定數(shù)組大小

3. 示例

總結(jié)

相關(guān)文章

最新評論

大家感興趣的內(nèi)容

最近更新的內(nèi)容

常用在線小工具

Go語言學(xué)習(xí)之?dāng)?shù)組的用法詳解

目錄

引言

一、數(shù)組的定義

1. 語法

2. 示例

二、數(shù)組的初始化

1. 未初始化的數(shù)組

2. 使用初始化列表

3. 省略數(shù)組長度

4. 指定索引值的方式來初始化

5. 訪問數(shù)組元素

6. 根據(jù)數(shù)組長度遍歷數(shù)組

三. 訪問數(shù)組元素

1. 訪問數(shù)組元素

2. 根據(jù)數(shù)組長度遍歷數(shù)組

四、冒泡排序

五、多維數(shù)組

1. 二維數(shù)組

2. 初始化二維數(shù)組

3. 訪問二維數(shù)組

六、向函數(shù)傳遞數(shù)組

1. 形參設(shè)定數(shù)組大小

2. 形參未設(shè)定數(shù)組大小

3. 示例

總結(jié)

相關(guān)文章

最新評論

大家感興趣的內(nèi)容

最近更新的內(nèi)容

常用在線小工具

一、數(shù)組的定義