Go语言中的 Array, Slice和 Map

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

介绍

曾经学习python的时候,记得书上说 dict 是 python的 horsepower(动力)。然后,Slice 和 Map 又何尝不是 golang 的 workhorse 呢?

  • Array 是值类型,Slice 和 Map 是引用类型。他们是有很大区别的,尤其是在参数传递的时候。
  • 另外,Slice 和 Map 的变量 仅仅声明是不行的,必须还要分配空间(也就是初始化,initialization) 才可以使用。
  • 第三,Slice 和 Map 这些引用变量 的 内存分配,不需要你操心,因为 golang 是存在 gc 机制的(垃圾回收机制)

Array 的用法

  1. 数组的声明(这里就是定义,给数据存储分配了空间):
    var arrayName [arraySize] dataType

  2. 如果数组定义好之后, 没有给数组元素指定值,那么所有元素被自动初始化为零值。

  3. 数组的初始化
var a = [10]int {1, 2, 3, 4, 5, 6, 7, 8, 9, 10} //定义数组的时候,直接初始化

var b = [10]int {1, 2, 3, 4}  //部分元素初始化, 其余元素零值

var c = [...]int {1, 2, 3, 4, 5}   //由初始化列表决定数组长度,不可省去标识符 "...",否则将变成切片Slice

var d = [10]{2:4, 5:7}   //可以按照下标来进行初始化
  1. 数组的访问,可以直接按照下标进行访问
  2. 数组的遍历:
package main
import(
    "fmt"
)
func main() {
    var f = [20]int {1, 1}
    for i := 2; i < 20; i++ {
        f[i] = f[i-1] + f[i-2]
    }
    for i := 0; i < 20; i++ {   //采用下标进行遍历
        if i % 5 == 0 {
            fmt.Printf("\n")
        }
        fmt.Printf("f[%2d] = %4d",i , f[i])
    }
}

也可以采用 range 关键字进行遍历:

func main() {
    var f = [20]int {1, 1}
    for i := 2; i < 20; i++ {
        f[i] = f[i-1] + f[i -2]
    }
    for i , v := range f {   //采用 range 关键字 进行遍历
        fmt.Printf("f[%2d] = %4d", i, v)
    }
}
  1. 多维数组
    var a [3][4]int
    初始化
    var a = [3][4]int {{1,2}, {1,2,3,4}, {2,3, 4}}
    多维数组遍历
/*找到二维数组中的最大元素*/
     package main
     import "fmt"
    func main() {
        var i, j, row, col, max int
        var a = [3][4]int {{1, 3, 7, 3}, {2, 3, 7 , 9}, {22, 3, 5, 10}}
        max = a[0][0]
        for i := 0; i < = 2; i ++ {
                for j := 0; j <= 3; j++ {
                        if a[i][j] > max {
                            max = a[i][j]
                            row = i
                            col = j
                        }
                }
        }
        fmt.Println("max = %d, row = %d, col = %d\n", max, row, col)
    }

Slice 的用法

Slice 的声明(没有分配内存)

 `var s1 []int`
  • 在创建切片的时候,不要指定切片的长度。(否则就成了数组)
  • 切片的类型可以是Go 语言的任何基本数据类型(也包括 引用类型和 Struct 类型)
  • 当一个切片被声明之后,没有初始化的时候,这个 s1 默认的值是 nil。切片的长度是0。可以使用内建函数 len() 获得切片的长度,使用内建函数 cap() 获得切片的容量。

Slice 的创建 (分配了内存)

三种创建方式: 基于底层数组创建,直接创建,或者 make() 函数创建

基于底层数组创建 slice

var slice1 []int   //声明但是不分配空间
slice1 = array[start:end]  //这里不包含 end
slice2 := array[:]         // 引用全部的元素
slice3 := array[0:len(array)]
var slice4 []int
sliec34 = array    //引用全部的元素

直接创建 slice

在声明的时候,直接初始化。

var slice1 = []int {1 ,2, 3, 4, 5}

make() 函数创建 slice

var slice1 = make([]int, 5)  //长度和容量都是 5
var slice2 = make([]int, 5, 10)  //容量是5.

Slice 的 访问和遍历

采用下标进行访问,采用 range 进行遍历。

packge main
import "fmt"
func main() {
    var slice1 = []int {1, 2,3 , 4, 5}
    //使用下标访问 slice
    for i := 0; i <=4; i++ {
        fmt.Println("slice[%d] = %d", i, slice[i])
    }
    fmt.Println()
    //使用range 进行遍历
    for i, v := range slice {
        fmt.Println("slice[%d] = %d", i, v)
    }
 }

Slice 的操作

Slice 中的切片的元素,可以动态的添加和删除,所以操作起来要比数组更加方便。

切片元素的增加

采用内建函数 append() 向切片尾部,增加新的元素, 这些元素保存到底层的数组

  • append() 并不会影响原来的切片的属性,(原来切片的长度和cap)
  • append() 将会返回更新后的切片的对象。
  • append() 是个变参函数,可以一次性添加多个对象。
  • append() 添加元素的个数超过 切片的 cap() 的时候,那么底层会 重新分配一个 “足够大” 的内存,一般来说是将原来的内存空间扩大二倍,然后将数据复制到新的内存中去, 原来的空间会保留 (供原先切片使用)(底层数组变化这个问题,应该关注一下
    举例如下:
package main

import "fmt"

func main() {
    //使用make 创建 切片
    var slice1 = make([]int, 3, 6)
    // 使用 append 添加元素,并且未超出 cap
    slice2 := append(slice1, 1, 2, 3)
    // 使用 append 添加元素,并且超出 cap. 这个时候底层数组会变化,新增加的元素只会添加到新的底层数组,不会覆盖旧的底层数组。
    slice3 := append(slice1, 4, 5, 6, 7)
    slice1[0] = 10
    fmt.Printf("len = %d cap = %d %v\n", len(slice1), cap(slice1), slice1)
    fmt.Printf("len = %d cap = %d %v\n", len(slice2), cap(slice2), slice2)
    fmt.Printf("len = %d cap = %d %v\n", len(slice3), cap(slice3), slice3)

}

程序输出是:
len = 3 cap = 6 [10 0 0]
len = 6 cap = 6 [10 0 0 1 2 3]     // 这里的[1, 2, 3] 没有被 [4, 5, 6]覆盖
len = 7 cap = 12 [0 0 0 4 5 6 7]   //这里第一个元素没有变成10,并且容量变成原来的2倍。

切片元素的复制

使用切片长时间引用超大的底层数组,会导致严重的内存浪费现象。 可以新建一个小的slice 对象,然后将所需要的数据复制过去,这样子就不会引用底层数组,直接拷贝了数据,这就是需求。函数 copy()可以 在切片之间复制元素。

  • copy() 可以复制的元素数量取决于 复制方 和 被复制方的最小长度。
  • 同一个底层数组之间的 元素复制,会导致元素重叠问题。
package main

import "fmt"

func main() {
    var slice1 = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    var slice2 = make([]int, 3, 5)
    var n int
    n = copy(slice2, slice1) // just copy three elements
    fmt.Println(n, slice2, len(slice2), cap(slice2))

    slice3 := slice1[3:6]   //二者引用同一个底层数组
    n = copy(slice3, slice1[1:5])  //所以,copy的时候发生元素重叠
    fmt.Println(n, slice1, slice3)

}
程序输出为:
3 [1 2 3] 3 5
3 [1 2 3 2 3 4 7 8 9 10] [2 3 4]   //可以看到元素重叠

Map 的用法

map 存储的是 键值对(key-value)。是一个无序的数据的集合,通过键来进行索引得到对应的值。 这种方式可以加快查找速度。Map 通常称为 字典(dictionary) 或者哈希表(Hash table)。Map 现在是很多语言的标配。

字典的声明

字典名称,“键”类型, “值”类型
var mapName map[keyType]valueType
注意:

  1. 不需要给字典指定长度,字典的长度会在初始化或者创建的过程中动态增长
  2. Key 必须是能支持 比较运算符(==, !=)的数据类型,比如 整数,浮点数,指针数组结构体接口等。 而不能函数,字典,切片这些类型。
  3. Value 类型 可以是Go语言的任何基本数据类型。
    var map1 map[string]int

字典的初始化 和 创建

  1. 字典 声明好之后,必须经过初始化或者创建 才能使用。未初始化或者创建的字典为 nil
  2. 可以使用“{}”来在声明的时候进行初始化。
  3. 可是使用 make()来创建字典。
  4. 创建或者初始化之后,就可以使用 “=”操作符来动态的向字典中添加数据项了。
    下面使用方式错误,编译不通过:
var map1 map[string]int
map1["key1"] = 2   //编译不通过,字典没有初始化或者创建

下面使用方式正确

var map1 map[string]int {}  //字典的初始化
map1["key1"] = 1

var map2 map[string]int
map2 = make(map[string]int)  //字典的创建
map2["key2"] = 2    //使用 等号 添加数据项

字典元素的查找

v, OK := mapName[Key]    //注意这里是 := 

如果Key存在,将Key对应的Value赋值给v,OK== true. 否则 v 是0,OK==false.

package main

import "fmt"

func main() {
    var map1 = map[string]int{"key1": 100, "key2": 200}
    //
    v, OK := map1["key1"]
    if OK {
        fmt.Println(v, OK)
    } else {
        fmt.Println(v)
    }
    // 这里 不是 :=,是 = ,因为这些变量已经定义过了。
    v, OK = map1["key3"]
    if OK {
        fmt.Println(v, OK)
    } else {
        fmt.Println(v)
    }

}
输出为:
100 true
0

字典项的删除

go 提供了内置函数 delete() 来删除容器内的元素。

delete(map1, "key1")

如果key1值不存在,那么调用将什么也不发生,也不会产生副作用。 但是,如果传入的map 是一个 nil,那么将导致程序出现异常,这一点在写程序的时候特别注意。

package main

import (
    "fmt"
)

func main() {
    var map1 = map[string]int{"key1": 100, "key2": 200, "key3": 300}
    for k, v := range map1 {
        fmt.Println(k, v)
        if k == "key2" {
            delete(map1, k)
        }
        if k == "key3" {
            map1["key4"] = 400
        }
    }

    fmt.Println(map1)
}
程序输出:
key2 200
key3 300
key1 100
map[key1:100 key4:400 key3:300]  //可以看到 map 是无序的。

字节切片 Byte Slice


本文来自:CSDN博客

感谢作者:xiaorenwuzyh

查看原文:Go语言中的 Array, Slice和 Map

入群交流(和以上内容无关):Go中文网 QQ 交流群:798786647 或加微信入微信群:274768166 备注:入群;关注公众号:Go语言中文网

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