详细介绍Go语言之数组与切片

目录
  • 一、数组
    • 1、数组的定义
    • 2、数组赋值
    • 3、定义并初始化
    • 4、数组的大小是类型的一部分
    • 5、数组是值类型
    • 6、数组长度 len() 数组长度在定义阶段已经固定
    • 7、数组循环
    • 8、多维数组
    • 9、数组定义并指定位置初始化
  • 二、切片基础
    • 1、切片的定义
    • 2、使用切片
    • 3、修改切片,会影响数组
    • 4、修改数组也会影响切片
    • 5、切片只切数组的一部分
    • 6、当多个切片共用相同的底层数组时,每个切片所做的更改将反应在数组中
    • 7、切片的长度和容量
    • 8、切片追加值

一、数组

数组是同一类型元素的集合,可以放多个值,但是类型一致,内存中连续存储

Go 语言中不允许混合不同类型的元素,而且数组的大小,在定义阶段就确定了,不能更改

1、数组的定义

// 定义一个大小为3的string类型和int8类型的数组,里面可以放3个字符串和3个数字
var names [3]string
var ages [3]int8
fmt.Println(names, ages) // 输出:[  ] [0 0 0]

2、数组赋值

var ages [3]int8
ages[0] = 18
ages[2] = 22

fmt.Println(ages)
fmt.Println(ages[1])

// 输出
[18 0 22]
0

3、定义并初始化

// 方式一:
var ages [3]int = [3]int{1, 2, 3}
fmt.Println(ages) // 输出:[1 2 3]

// 方式二:
var ages = [3]int{1, 2, 3}
fmt.Println(ages) // 输出:[1 2 3]

// 方式三:...后面放几个值,数组大小就是多少
var ages = [...]int{1, 2, 3, 4, 5, 6, 7, 8}
fmt.Println(ages) // 输出:[1 2 3 4 5 6 7 8]

// 方式四:
ages := [...]int{1, 2, 3, 4, 8}
fmt.Println(ages) // 输出:[1 2 3 4 8]

4、数组的大小是类型的一部分

var a [2]int = [2]int{1, 2}
var b [2]int = [2]int{1, 3}

b = a  // 如果不是同一种类型,不允许相互赋值
fmt.Println(b)

5、数组是值类型

因为数组是值类型,Go 函数传参,都是 copy 传递,如果是值类型,函数内改了,不会影响原来的

var a = [2]int{1, 2}
fmt.Println(a) // [1 2]
test(a)  // [99 2]
fmt.Println(a) // [1 2]

func test(a [2]int) {
 a[0] = 99
 fmt.Println(a)
}

6、数组长度 len() 数组长度在定义阶段已经固定

var a = [2]int{1, 2}
fmt.Println(len(a))  // 输出:2

7、数组循环

// 普通循环
var a = [...]int{7, 6, 5, 4, 3, 2, 1}
for i := 0; i < len(a); i++ {
   fmt.Println(a[i])
}

// 通过 range 来循环(range不是一个内置函数,是一个关键字如:for,if,else)
// 如果用一个变量接收,这个值是可迭代的索引
// 如果用两个变量接收,这两个变量一个是索引,一个是具体的值
var a = [...]int{7, 6, 5, 4, 3, 2, 1}
for i, value := range a {
    fmt.Println(i) // 索引
    fmt.Println(value) // 值
}

// 不要索引只要值循环打印
for _, value := range a {
 fmt.Println(value)
}

8、多维数组

var a [3][3]int // 定义
a[0][1] = 20 // 使用
fmt.Println(a) // 输出:[[0 20 0] [0 0 0] [0 0 0]]

// 定义并赋初始值
var a [3][3]int = [3][3]int{{1}, {2, 3, 4}, {5, 6}}
fmt.Println(a) // 输出:[[1 0 0] [2 3 4] [5 6 0]]

// 循环多维数组
var a [3][3]int = [3][3]int{{1}, {2, 3, 4}, {5, 6}}
for _, value := range a {
   for _, inValue := range value {
      fmt.Println(inValue)
   }
}

9、数组定义并指定位置初始化

// 在索引为5和7的位置指定初始化值
var ages [10]int = [10]int{5: 55, 7: 77}
fmt.Println(ages) // 输出:[0 0 0 0 0 55 0 77 0 0]

二、切片基础

切片是由数组建立的一种方案、灵活且功能强大的包装(Wrapper)。

它本身不拥有任何数据,只对现有数组的引用。

1、切片的定义

// 定义一个数组
var a = [10]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
// 基于数组,做一个切片
b := a[:]

fmt.Println(b)   // 输出:[9 8 7 6 5 4 3 2 1 0]
fmt.Printf("%T", b)  // 输出:[]int  中括号中不带东西,就是切片类型

fmt.Println(a)   // 输出:[9 8 7 6 5 4 3 2 1 0]
fmt.Printf("%T", a)  // 输出:[10]int

2、使用切片

var a = [10]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
b := a[:]

fmt.Println(b[0]) // 输出:9
fmt.Println(b[2]) // 输出:7

3、修改切片,会影响数组

var a = [10]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
b := a[:]
b[0] = 99 // 修改切片

fmt.Println(b) // 输出:[99 8 7 6 5 4 3 2 1 0]
// 数组会被修改
fmt.Println(a) // 输出:[99 8 7 6 5 4 3 2 1 0]

4、修改数组也会影响切片

var a = [10]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
b := a[:]
a[1] = 99 // 修改数组

fmt.Println(a) // 输出:[9 99 7 6 5 4 3 2 1 0]
// 切片也会被修改
fmt.Println(b) // 输出:[9 99 7 6 5 4 3 2 1 0]

5、切片只切数组的一部分

var a = [10]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
b := a[3:6]

// 修改切片
b[0] = 66
fmt.Println(b)  // 输出:[66 5 4]
fmt.Println(a)  // 输出:[9 8 7 66 5 4 3 2 1 0]

// 修改数组
a[4] = 55
fmt.Println(b)  // 输出:[66 55 4]
fmt.Println(a)  // 输出:[9 8 7 66 55 4 3 2 1 0]

6、当多个切片共用相同的底层数组时,每个切片所做的更改将反应在数组中

var a = [10]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
b := a[3:5]
c := a[4:6]
fmt.Println(a) // 输出:[9 8 7 6 5 4 3 2 1 0]
fmt.Println(b) // 输出:[6 5]
fmt.Println(c) // 输出:[5 4]
b[1] = 555
fmt.Println(a) // 输出:[9 8 7 6 555 4 3 2 1 0]
fmt.Println(b) // 输出:[6 555]
fmt.Println(c) // 输出:[555 4]

7、切片的长度和容量

var a = [10]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
b := a[3:7]

fmt.Println(b) // 输出:[6 5 4 3]
fmt.Println(a) // 输出:[9 8 7 6 5 4 3 2 1 0]

// 切片长度
fmt.Println(len(b))    // 输出:4
// 切片容量(我最多能存多少值,从切片的起始位置开始往后所有的,从索引为3开始)
fmt.Println(cap(b))    // 输出:7

8、切片追加值

var a = [10]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
b := a[6:8]

b = append(b,11)
b = append(b,22)
fmt.Println(a) // 输出:[9 8 7 6 5 4 3 2 11 22]

// 追加到临界点了在追加
b = append(b,33)
b = append(b,44)
fmt.Println(a) // 输出:[9 8 7 6 5 4 3 2 11 22]
fmt.Println(b) // 输出:[3 2 11 22 33 44]

// 数组长度不会在变了,他会在原来基础上翻倍,把我原来那个值copy到我新的数组上a和b已经没有关系了
b[0] = 33
fmt.Println(b) // 输出:[33 2 11 22 33 44]
fmt.Println(a) // 输出:[9 8 7 6 5 4 3 2 11 22]

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

时间: 2021-10-12

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

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

详细介绍Go语言之数组与切片

目录 一.数组 1.数组的定义 2.数组赋值 3.定义并初始化 4.数组的大小是类型的一部分 5.数组是值类型 6.数组长度 len() 数组长度在定义阶段已经固定 7.数组循环 8.多维数组 9.数组定义并指定位置初始化 二.切片基础 1.切片的定义 2.使用切片 3.修改切片,会影响数组 4.修改数组也会影响切片 5.切片只切数组的一部分 6.当多个切片共用相同的底层数组时,每个切片所做的更改将反应在数组中 7.切片的长度和容量 8.切片追加值 一.数组 数组是同一类型元素的集合,可以放多个

深入理解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语言中的数组和切片

目录 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进程来回收该子进程. 那如果是把进程换成线程的话,会怎么样呢?假设主线程在子线程结束前就已经退出,子线程会发生什么? 在一些论坛上看到许多人说子线程也会跟着退出,其实这是错误的,原因在于他们混

简单讲解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

简单总结C语言中各种类型的指针的概念

C语言中有很多关于指针的使用,指针也是C语言的灵魂所在,而且C语言中也有很多有关指针的概念,这里学习并总结了一些知道的概念.   常量指针: 首先它是一个指针,常量只是用来修饰指针的定语.其定义如下: char const * cp; char a='a'; 如何识别呢?根据右结合优先,先是*优先,所以这个cp变量是一个指针,然后是const修饰*,所以这是一个常量指针.即指向常量的指针. cp=&a; //正常语法 *cp=a; //错误语法,因为其指向的值是一个常量 指针常量: 首先它是一个

C语言中的数组和指针汇编代码分析实例

今天看<程序员面试宝典>时偶然看到讲数组和指针的存取效率,闲着无聊,就自己写了段小代码,简单分析一下C语言背后的汇编,可能很多人只注重C语言,但在实际应用当中,当出现问题时,有时候还是通过分析汇编代码能够解决问题.本文只是为初学者,大牛可以飘过~ C源代码如下: 复制代码 代码如下: #include "stdafx.h" int main(int argc, char* argv[]) {        char a=1;        char c[] = "