golang之array

heartchord · · 5046 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

数组


        golang数组包含的每个数据称为数组元素(element),数组包含的元素个数被称为数组长度(length)。

        golang数组的长度在定义后不可更改,并且在声明时可以是一个常量或常量表达式(在编译期即可计算结果的表达式)。golang数组长度是一个内置常量,可以用len()函数来获取。

        golang数组是一个值类型,在赋值和作为参数传递时都将产生一次复制动作,因此在函数体中无法修改传入的数组的内容

• 数组声明和初始化

▶ 数组声明

▪ 语法如下

// 数组声明
var array [n]Type

// 数组声明和初始化
var array [n]Type = [n]Type{v1, v2, ..., vn}
var array = [n]Type{v1, v2, ..., vn}
array := [n]Type{v1, v2, ..., vn}

▪ 示例如下

[32]byte                    // 长度为32的数组,每个元素为一个字节
[2*N] struct { x, y int32 } // 复杂类型数组
[1000]*float64              // 指针数组
[3][5]int                   // 二维数组
[2][2][2]float64            // 等同于[2]([2]([2]float64))

• 数组常用操作

▶ 遍历元素

⊙ 按下标遍历

        使用len()获取元素个数,然后按下标进行元素遍历操作。

▪ 语法如下
for i := 0; i < len(array); i++ {
    ...
}
▪ 示例如下
package main

import "fmt"

func main() {
    array := [5]int{1, 2, 3, 4, 5}
    for i := 0; i < len(array); i++ {
        fmt.Println("array[", i, "] =", array[i])
    }
}
⊙ rang遍历

        可以使用range关键字来快速遍历所有元素。

▪ 语法如下
for i, v := range array {
    ...
}
▪ 示例如下
package main

import "fmt"

func main() {
    array := [5]int{1, 2, 3, 4, 5}
    for i, v := range array {
        fmt.Println("array[", i, "] =", v)
    }
}

数组切片


        golang数组切片解决的问题:golang数组长度在定义之后无法再次修改,并且数组是值类型,每次传递都将产生一份副本。

        golang数组切片拥有独立的数据结构,可抽象为3个变量:一个指向原数组的指针数组切片中元素个数数组切片分配的存储空间

• 创建数组切片

▶ 基于数组

▪ 语法如下

var arraySlice []Type = array[first:last]

        数组切片的元素范围为[first, last)

        first和last的值可以省略,缺省情况下,first=0,last=len(array)

        first和last的值必须满足条件:非负,0 ≤ first ≤ last ≤ len(array),否则编译器将给出错误:
      

      

      

▪ 示例如下

package main

import "fmt"

func main() {
    var array [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    var arraySlice1 []int = array[:]   // 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
    var arraySlice2 []int = array[:5]  // 1, 2, 3, 4, 5
    var arraySlice3 []int = array[5:]  // 6, 7, 8, 9, 10
    var arraySlice4 []int = array[3:8] // 4, 5, 6, 7, 8

    fmt.Println("\nElements of arraySlice1: ")
    for _, v := range arraySlice1 {
        fmt.Print(v, " ")
    }

    fmt.Println("\nElements of arraySlice2: ")
    for _, v := range arraySlice2 {
        fmt.Print(v, " ")
    }

    fmt.Println("\nElements of arraySlice3: ")
    for _, v := range arraySlice3 {
        fmt.Print(v, " ")
    }

    fmt.Println("\nElements of arraySlice4: ")
    for _, v := range arraySlice4 {
        fmt.Print(v, " ")
    }
    fmt.Println()
}

▶ 直接创建

        golang提供的内置函数make()可以用于灵活地创建数组切片。

▪ 语法如下

// 创建一个初始元素个数为m的数组切片
arraySlice := make([]Type, m)

// 创建一个初始元素个数为m的数组切片,并预留n个元素的存储空间
arraySlice := make([]Type, m, n)

// 直接创建并初始化包含m个元素的数组切片
arraySlice := []Type{v1, v2, ..., vn}

▪ 示例如下

package main

import "fmt"

func main() {
    arraySlice1 := make([]int, 5)       // 0 0 0 0 0
    arraySlice2 := make([]int, 5, 10)   // 0 0 0 0 0
    arraySlice3 := []int{1, 2, 3, 4, 5} // 1 2 3 4 5

    fmt.Println("\nElements of arraySlice1: ")
    for _, v := range arraySlice1 {
        fmt.Print(v, " ")
    }

    fmt.Println("\nElements of arraySlice2: ")
    for _, v := range arraySlice2 {
        fmt.Print(v, " ")
    }

    fmt.Println("\nElements of arraySlice3: ")
    for _, v := range arraySlice3 {
        fmt.Print(v, " ")
    }
}

▶ 基于数组切片

        数组切片(newSlice)也可以基于另一个数组切片(oldSlice)创建。

        newSlice元素范围可以超过oldSlice所包含的元素个数,只要选择范围不超过oldSlice的存储能力,即cap(oldSlice)的值,那么这个创建是合法的,newSlice中超出oldSlice元素的部分都会填上0。

        newSlice的存储能力等同于oldSlice的存储能力,即cap(newSlice) = cap(oldSlice)

▪ 语法如下

newSlice := oldSlice[first:last] // 0 ≤ first ≤ last ≤ cap(oldSlice)

▪ 示例如下

package main

import "fmt"

func main() {
    oldSlice := make([]int, 5, 10)
    newSlice := oldSlice[:8]

    fmt.Println("Length   of oldSlice: ", len(oldSlice)) // 5
    fmt.Println("Capacity of oldSlice: ", cap(oldSlice)) // 10

    fmt.Println("Length   of newSlice: ", len(newSlice)) // 8
    fmt.Println("Capacity of newSlice: ", cap(newSlice)) // 10
}

• 数组切片的元素个数和存储能力

        与数组相比,数组切片多了一个存储能力(capacity)的概念,即当前容纳的元素个数和分配的空间可以是两个不同的值。

        存储能力,可以理解为最大容纳元素个数,最大容纳元素个数减去当前容纳元素个数剩下的空间是隐藏的,不能直接使用。如果要往隐藏空间中新增元素,可以使用append()函数。

        取得当前容纳元素个数可以使用len()函数,取得最大容纳元素个数可以使用cap()函数

package main

import "fmt"

func main() {
    arraySlice := make([]int, 5, 10)
    fmt.Println("len(arraySlice):", len(arraySlice)) // len(arraySlice): 5
    fmt.Println("cap(arraySlice):", cap(arraySlice)) // cap(arraySlice): 10
}

• 数组切片常用操作

▶ 遍历元素

⊙ 按下标遍历

        与遍历数组一样,使用len()获取元素个数,然后按下标进行元素遍历操作。

▪ 语法如下
for i := 0; i < len(arraySlice); i++ {
    ...
}
▪ 示例如下
package main

import "fmt"

func main() {
    arraySlice := []int{1, 2, 3, 4, 5}
    for i := 0; i < len(arraySlice); i++ {
        fmt.Println("arraySlice[", i, "] =", arraySlice[i])
    }
}

⊙ rang遍历

        与遍历数组一样,可以使用range关键字来快速遍历所有元素。

▪ 语法如下
for i, v := range arraySlice {
    ...
}
▪ 示例如下
package main

import "fmt"

func main() {
    arraySlice := []int{1, 2, 3, 4, 5}
    for i, v := range arraySlice {
        fmt.Println("arraySlice[", i, "] =", v)
    }
}

▶ 增加元素

        为数组切片增加元素的方法是使用append()函数。

⊙ 追加元素

        追加元素时,会自动处理存储空间不足的问题,如果追加的内容超过当前最大容纳元素空间,那么数组切片会自动分配一块足够大的内存。自动分配内存策略为:当前存储能力 * 2,即cap(arraySlice) * 2

▪ 语法如下
arraySlice = append(arraySlice, v1, v2, ..., vn)
▪ 示例如下
package main

import "fmt"

func main() {
    arraySlice := make([]int, 0, 10)
    arraySlice = append(arraySlice, 1, 2, 3, 4, 5)

    fmt.Println("len(arraySlice) =", len(arraySlice)) // 5
    fmt.Println("cap(arraySlice) =", cap(arraySlice)) // 10

    for _, v := range arraySlice {
        fmt.Print(v, " ")
    }
    fmt.Println()

    arraySlice = append(arraySlice, 6, 7, 8, 9, 10, 11, 12, 13)
    fmt.Println("len(arraySlice) =", len(arraySlice)) // 13
    fmt.Println("cap(arraySlice) =", cap(arraySlice)) // 20

    for _, v := range arraySlice {
        fmt.Print(v, " ")
    }
}

⊙ 追加数组切片

       为数组切片arraySlice1追加数组切片arraySlice2时,注意在arraySlice2后面追加三个点,这三个点的意思是把arraySlice2所有元素打散后传递给append()函数,这是由于append()函数从第二个参数起的所有参数都必须是待附加的单个元素。

▪ 语法如下
arraySlice = append(arraySlice, appendSlice...)
▪ 示例如下
package main

import "fmt"

func main() {
    arraySlice := []int{1, 2, 3}
    appendSlice := []int{4, 5}

    arraySlice = append(arraySlice, appendSlice...)
    fmt.Println("len(arraySlice) =", len(arraySlice)) // 5
    fmt.Println("cap(arraySlice) =", cap(arraySlice)) // 6

    for _, v := range arraySlice {
        fmt.Print(v, " ")
    }
}

▶ 删除元素

       数组切片可以动态添加元素,但没有删除元素的函数。代替方法是:可以使用数组切片重新组合的方式来删除一个或多个项。不过从数组切片这种数据结构来看,本身并不适合做删除操作,所以尽量减少使用。

▪ 示例如下

package main

import "fmt"

func main() {
    s := []int{1, 2, 3, 4, 5, 6}
    i := 2
    s = append(s[:i], s[i+1:]...)

    fmt.Println(s) // [1 2 4 5 6]
}

▶ 切片之间元素复制

        golang使用内置函数copy()将数组切片arraySlice2的内容复制到数组切片arraySlice1中。

        如果两个数组切片元素个数不同,那么就会按其中元素个数较少的数组切片元素个数进行复制操作。

▪ 示例如下

package main

import "fmt"

func main() {
    arraySlice1 := []int{1, 2, 3, 4, 5}
    arraySlice2 := []int{5, 4, 3}
    copy(arraySlice2, arraySlice1) // 只会复制arraySlice1的前3个元素到arraySlice2中
    fmt.Println(arraySlice2)       // [1 2 3]

    arraySlice3 := []int{1, 2, 3, 4, 5}
    arraySlice4 := []int{5, 4, 3}
    copy(arraySlice3, arraySlice4) // 只会复制arraySlice4的3个元素到arraySlice3的前3个位置
    fmt.Println(arraySlice3)       // [5 4 3 4 5]
}

 


有疑问加站长微信联系(非本文作者)

本文来自:博客园

感谢作者:heartchord

查看原文:golang之array

入群交流(和以上内容无关):加入Go大咖交流群,或添加微信:liuxiaoyan-s 备注:入群;或加QQ群:1006366459

5046 次点击  
加入收藏 微博
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传