简单聊一聊Go语言中的数组和切片

目录
  • 1. 数组
  • 2. 切片(Slice)
    • append 函数
  • 总结

1. 数组

数组是一个由固定长度的特定类型元素组成的序列,一个数组可以由零个或多个元素组成。因为数组的长度是固定的,因此在 Go 语言中很少直接使用数组。和数组对应的类型是 Slice(切片),它是可以增长和收缩的动态序列,slice 功能也更灵活。

数组的每个元素可以通过索引下标来访问,索引下标的范围是从 0 开始到数组长度减 1 的位置。内置的 len 函数将返回数组中元素的个数。

var a [3]int             // array of 3 integers
fmt.Println(a[0])        // print the first element
fmt.Println(a[len(a)-1]) // print the last element, a[2]

默认情况下,数组的每个元素都被初始化为元素类型对应的零值,对于数字类型来说就是 0。

var q [3]int = [3]int{1, 2, 3}
var r [3]int = [3]int{1, 2}
fmt.Println(r[2]) // "0"

如果在数组的长度位置出现的是“...”省略号,则表示数组的长度是根据初始化值的个数来计算。因此,上面 q 数组的定义可以简化为:

q := [...]int{1, 2, 3}
fmt.Printf("%T\n", q) // "[3]int"

数组的长度是数组类型的一个组成部分,因此[3]int 和[4]int 是两种不同的数组类型。

数组的长度必须是常量表达式,因为数组的长度需要在编译阶段确定。

q := [3]int{1, 2, 3}
q = [4]int{1, 2, 3, 4} // compile error: cannot assign [4]int to [3]int

如果一个数组的元素类型是可以相互比较的,那么数组类型也是可以相互比较的,这时候我们可以直接通过==比较运算符来比较两个数组,只有当两个数组的所有元素都是相等的时候数组才是相等的。不相等比较运算符!=遵循同样的规则。

a := [2]int{1, 2}
b := [...]int{1, 2}
c := [2]int{1, 3}
fmt.Println(a == b, a == c, b == c) // "true false false"
d := [3]int{1, 2}
fmt.Println(a == d) // compile error: cannot compare [2]int == [3]int

2. 切片(Slice)

Slice(切片)代表变长的序列,序列中每个元素都有相同的类型。一个 slice 类型一般写作[]T,其中 T 代表 slice 中元素的类型;slice 的语法和数组很像,只是没有固定长度而已。

一个 slice 是一个轻量级的数据结构,提供了访问数组子序列(或者全部)元素的功能,而且 slice 的底层确实引用一个数组对象。

一个 slice 由三个部分构成:指针、长度和容量。

  • 指针指向第一个 slice 元素对应的底层数组元素的地址,要注意的是 slice 的第一个元素并不一定就是数组的第一个元素。
  • 长度对应 slice 中元素的数目;
  • 长度不能超过容量,容量一般是从 slice 的开始位置到底层数据的结尾位置。内置的 len 和 cap 函数分别返回 slice 的长度和容量。

表示一年中每个月份名字的字符串数组,还有重叠引用了该数组的两个 slice。数组这样定义:

months := [...]string{1: "January", /* ... */, 12: "December"}

因此一月份是 months[1],十二月份是 months[12]。

通常,数组的第一个元素从索引 0 开始,但是月份一般是从 1 开始的,因此我们声明数组时直接跳过第 0 个元素,第 0 个元素会被自动初始化为空字符串。

slice 的切片操作 s[i:j],其中 0 ≤ i≤ j≤ cap(s),用于创建一个新的 slice,引用 s 的从第 i 个元素开始到第 j-1 个元素的子序列。新的 slice 将只有 j-i 个元素。如果 i 位置的索引被省略的话将使用 0 代替,如果 j 位置的索引被省略的话将使用 len(s)代替。因此,months[1:13]切片操作将引用全部有效的月份,和 months[1:]操作等价;months[:]切片操作则是引用整个数组。让我们分别定义表示第二季度和北方夏天月份的 slice,它们有重叠部分:

Q2 := months[4:7]
summer := months[6:9]
fmt.Println(Q2)     // ["April" "May" "June"]
fmt.Println(summer) // ["June" "July" "August"]

两个 slice 都包含了六月份。

append 函数

append 函数用于向 slice 追加元素:

var runes []rune
for _, r := range "Hello, 世界" {
    runes = append(runes, r)
}
fmt.Printf("%q\n", runes) // "['H' 'e' 'l' 'l' 'o' ',' ' ' '世' '界']"

为了提高内存使用效率,新分配的数组一般略大于保存 x 和 y 所需要的最低大小。通过在每次扩展数组时直接将长度翻倍从而避免了多次内存分配,也确保了添加单个元素操作的平均时间是一个常数时间。这个程序演示了效果:

func main() {
    var x, y []int
    for i := 0; i < 10; i++ {
        y = appendInt(x, i)
        fmt.Printf("%d cap=%d\t%v\n", i, cap(y), y)
        x = y
    }
}

//每一次容量的变化都会导致重新分配内存和copy操作:
0  cap=1    [0]
1  cap=2    [0 1]
2  cap=4    [0 1 2]
3  cap=4    [0 1 2 3]
4  cap=8    [0 1 2 3 4]
5  cap=8    [0 1 2 3 4 5]
6  cap=8    [0 1 2 3 4 5 6]
7  cap=8    [0 1 2 3 4 5 6 7]
8  cap=16   [0 1 2 3 4 5 6 7 8]
9  cap=16   [0 1 2 3 4 5 6 7 8 9]

让我们仔细查看 i=3 次的迭代。当时 x 包含了[0 1 2]三个元素,但是容量是 4,因此可以简单将新的元素添加到末尾,不需要新的内存分配。然后新的 y 的长度和容量都是 4,并且和 x 引用着相同的底层数组,如图 4.2 所示。

在下一次迭代时 i=4,现在没有新的空余的空间了,因此 appendInt 函数分配一个容量为 8 的底层数组,将 x 的 4 个元素[0 1 2 3]复制到新空间的开头,然后添加新的元素 i,新元素的值是 4。新的 y 的长度是 5,容量是 8;后面有 3 个空闲的位置,三次迭代都不需要分配新的空间。当前迭代中,y 和 x 是对应不同底层数组的 view。这次操作如图 4.3 所示。

内置的 append 函数可能使用比 appendInt 更复杂的内存扩展策略。

因此,通常我们并不知道 append 调用是否导致了内存的重新分配,因此我们也不能确认新的 slice 和原始的 slice 是否引用的是相同的底层数组空间。

同样,我们不能确认在原先的 slice 上的操作是否会影响到新的 slice。

总结

到此这篇关于Go语言中数组和切片的文章就介绍到这了,更多相关Go语言数组和切片内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • golang将切片或数组根据某个字段进行分组操作

    我就废话不多说了,大家还是直接看代码 吧~ package main import ( "fmt" "sort" ) type Person struct { Name string Age int } func main() { p1 := Person{"Tom",20} p2 := Person{"Lily",21} p3 := Person{"Linda",23} p4 := Person{&quo

  • go结构体嵌套的切片数组操作

    看代码吧~ package main import ( "fmt" ) type XCDataStu struct { Id int `json:"id" xorm:"id"` Name string `json:"name" xorm:"name"` } type XCDataStu1 struct { Id int `json:"id" xorm:"id"` St

  • 理解Golang中的数组(array)、切片(slice)和map

    我比较喜欢先给出代码,然后得出结论 数组 复制代码 代码如下: package main import (     "fmt" ) func main() {     arr := [...]int{1, 2, 3}     //打印初始的指针     fmt.Printf("the pointer is : %p \n", &arr)     printPointer(arr) } func printPointer(any interface{}) {

  • 深入理解Go语言中的数组和切片

    一.类型 数组是值类型,将一个数组赋值给另一个数组时,传递的是一份拷贝. 切片是引用类型,切片包装的数组称为该切片的底层数组. 我们来看一段代码 //a是一个数组,注意数组是一个固定长度的,初始化时候必须要指定长度,不指定长度的话就是切片了 a := [3]int{1, 2, 3} //b是数组,是a的一份拷贝 b := a //c是切片,是引用类型,底层数组是a c := a[:] for i := 0; i < len(a); i++ { a[i] = a[i] + 1 } //改变a的值后

  • GO语言数组和切片实例详解

    本文实例讲述了GO语言数组和切片的用法.分享给大家供大家参考.具体分析如下: 一.数组 与其他大多数语言类似,Go语言的数组也是一个元素类型相同的定长的序列. (1)数组的创建. 数组有3种创建方式:[length]Type .[N]Type{value1, value2, ... , valueN}.[...]Type{value1, value2, ... , valueN} 如下: 复制代码 代码如下: func test5() {     var iarray1 [5]int32    

  • go特性之数组与切片的问题

    数组: 复制传递(不要按照c/c++的方式去理解,c/c++中数组是引用传递),定长 切片: 引用传递,底层实现是3个字段 array(数组) + len(长度) +cap(容量) go/src/runtime/slice.go slice结构定义: type slice struct { array unsafe.Pointer len int cap int } 要特别注意的是,切片的引用传递指的是切片传递时,切片的array字段是引用传递的,len和cap字段依然是赋值传递. 写个伪代码:

  • 简单聊一聊Go语言中的数组和切片

    目录 1. 数组 2. 切片(Slice) append 函数 总结 1. 数组 数组是一个由固定长度的特定类型元素组成的序列,一个数组可以由零个或多个元素组成.因为数组的长度是固定的,因此在 Go 语言中很少直接使用数组.和数组对应的类型是 Slice(切片),它是可以增长和收缩的动态序列,slice 功能也更灵活. 数组的每个元素可以通过索引下标来访问,索引下标的范围是从 0 开始到数组长度减 1 的位置.内置的 len 函数将返回数组中元素的个数. var a [3]int // arra

  • 简单分析C语言中指针数组与数组指针的区别

    首先来分别看一下,指针数组的一个小例子: #include <stdio.h> #include <string.h> int lookup_keyword(const char*key, const char* table[], const int size) { int ret = -1; int i = 0; for(i=0; i<size; i++) { if (strcmp(key, table[i]) == 0) { ret = i; break; } } ret

  • Java版C语言版简单使用静态语言实现动态数组的方法

    动态语言相对于静态语言的一个优势,就是数组可以不需要预先确定大小,对于一些数组长度不确定的场景下是非常有用的.像PHP,只需要声明一下数组 $arr = array() 然后就可以直接 $arr[] = 1,$arr[] = 2,$arr[] = 3...这样一直加元素了,删除一个元素就直接使用unset($arr[1]),元素的空间就被释放了,而C和JAVA原生的数组就没有这么方便,声明的时候就必须先预先确定长度,由编译器分配相应的内存空间.不过通过一些巧妙的做法,也是可以实现一样的功能的,这

  • C语言中全局数组和局部数组的问题

    今天同学遇到一个在C语言中全局数组和局部数组的问题,卡了许久,我也没有第一时间看出问题,现在把问题梳理一下,并给出解决方案. 问题描述: 在全局声明的数组与在局部声明的数组有着不同的效果. 首先来看一个程序: 复制代码 代码如下: #include <stdio.h> #include <stdlib.h> #define MAX 10 char a[MAX]; int main() { int i; char b[MAX]; char *c=(char *)malloc(MAX

  • 简单了解C语言中主线程退出对子线程的影响

    这篇文章主要介绍了简单了解C语言中主线程退出对子线程的影响,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 对于程序来说,如果主进程在子进程还未结束时就已经退出,那么Linux内核会将子进程的父进程ID改为1(也就是init进程),当子进程结束后会由init进程来回收该子进程. 那如果是把进程换成线程的话,会怎么样呢?假设主线程在子线程结束前就已经退出,子线程会发生什么? 在一些论坛上看到许多人说子线程也会跟着退出,其实这是错误的,原因在于他们混

  • 浅析Go语言容器之数组和切片的使用

    目录 序列容器 数组 Vector Deque List 单链表 总结 在 Java 的核心库中,集合框架可谓鼎鼎大名:Array .List.Set.Queue.HashMap 等等,随便拎一个出来都值得开发者好好学习如何使用甚至是背后的设计源码(这类文章也挺多,大家上网随便一搜). 虽然 Go 语言没有如此丰富的容器类型,但也有一些基本的容器供开发者使用,接下来让我们一一认识这些容器类型吧. 序列容器 序列容器存储特定类型的数据元素.目前有 5 种序列容器的实现: array vector

  • 简单讲解C语言中宏的定义与使用

    宏定义是预编译功能的一种, 预编译又称为预处理, 是为编译做的预备工作的阶段.处理#开头的指令, 比如拷贝 #include 包含的文件代码,#define宏定义的替换,条件编译等. 使用宏定义的好处:使用宏定义的好处:可提高程序的通用性和易读性,减少不一致性,减少输入错误和便于修改.例如 π 这个常量,我们有时候会在程序的多个地方使用,如果每次使用都重新定义,一来比较麻烦,二来容易出错,所以我们可以把 π 做成宏定义来使用.   语法说明: (1)宏名一般用大写 (2)使用宏可提高程序的通用性

  • 浅析C语言中的数组及字符数组

    我们来编写一个程序,以统计各个数字.空白符(包括空格符.制表符及换行符)以及所有其它字符出现的次数.这个程序的实用意义并不大,但我们可以通过该程序讨论 C 语言多方面的问题. 所有的输入字符可以分成 12 类,因此可以用一个数组存放各个数字出现的次数,这样比使用 10 个独立的变量更方便.下面是该程序的一种版本: #include <stdio.h> /* count digits, white space, others */ main() { int c, i, nwhite, nothe

  • 简单谈谈C语言中的= 和==、!=

    1. =: 在C语言中等号(=)为赋值操作符,下面进行简单说明赋值操作符的使用 1) 变量的赋值操作: int a; a = 10; 此处为将10赋值给a,赋值过后a的值为10 2) 指针变量的赋值操作:(分别为 取地址的赋值和指针变量的赋值) 第一种: int arr[999] = { 0 }; int *p = NULL; p = (int *)&arr; 定义一个int(整形)的变量arr,并且将arr的数组中的每个数组元素初始化为0 定义一个int(整形)的指针变量p,并且初始化为NUL

随机推荐