3.1 数组--固定大小的连续空间

3.1.1 声明数组

写法 var 数组变量名 [元素数量]T 说明: 变量名就是使用时的变量 元素的数量可以是表达式,最后必须为整型数值 T 可是是任意基本类型,包括数组本身,即可为多维数组

package main
import (
"fmt"
)
func main() {
var team []string
fmt.Println(team)
// [ ]
// 获取数组长度 -- len()
fmt.Println(len(team))
// 5
// 添加元素
team[] = "one"
team[] = "two"
fmt.Println(team)
// [ one two ]
}

3.1.2 初始化数组

package main
import ("fmt")
func main() {
var team1 = []string{"one", "two", "three"}
fmt.Println(team1)
// [one two three]
var team2 = [...]string{"one1", "two2", "three3"}
fmt.Println(team2)
// [one1 two2 three3]
// ... 表示让编译器确定数组大小
}

3.1.3 变量数组 -- 访问每一个数组元素

两种方式遍历都可以

package main
import ("fmt")
func main() {
for i := ; i < len(team2); i++ {
fmt.Println(team2[i])
}
// one1
// two2
// three3
for _, v := range team1 {
fmt.Println(v)
}
// one
// two
// three
for _, v := range team2 {
fmt.Println(v)
}
// one
// two
// three
}

3.2 切片(slice) -- 动态分配大小的连续空间

go语言切片的内部结构包含地址、大小和容量,切片是指快速地操作一块数据集合 比如数据集合作为切糕,切片就是准备切出来的那一块,切片地址就是切切糕的过程开始的位置,切多大的切糕就是切片大小,容量就是准备装切糕的袋子大小

3.2.1 从数组或切片生成新的切片

切片默认指向一段连续内存区域,可以数组,或切片本身 ​ 格式 slice [开始位置:结束位置] slice 表示目标切片对象 开始位置对应目标切片对象的索引 结束位置对应目标切片对象的结束索引

7种特性:

package main
import ("fmt")
func main() {
var a = []int{,,}
fmt.Println(a)
// [1 2 3]
// 特性:
// 1.取数元素数量:结束位置-开始位置
fmt.Println( a[:] )
//[1 2]
fmt.Println( len(a)- - )
//2 // 2.取出元素不包括结束位置对应的索引,切片最后一个元素使用slice[len(slice)]获取
fmt.Println(a[:])
//[1] // 3.当缺省开始位置时,表示从开头到结束位置
fmt.Println(a[:])
// [1 2] // 4.单缺省结束位置时,表示从开始位置到末尾
fmt.Println(a[:])
// [1 2 3] // 5.当两者都缺省时,与切片本身等效
fmt.Println(a[:])
// [1 2 3] // 6.两者为0时,等效于空切片,一般为切片复位
fmt.Println(a[:])
// [] // 7.根据索引位置切片slice元素值时,取值范围是(0 ~ len(slice)-1 ),超界会报运行错误,生成切片时,结束位置可以填写len(slice)但不会报错
fmt.Println(a[:len(a)-])
// [1 2] // fmt.Println(a[0:4])
// .\slice.go:55:15: invalid slice index 4 (out of bounds for 3-element array)
// exit status 2
// Process exiting with code: 1
}

1从指定范围中生成切片

  var nums []int
for i:=; i< len(nums);i++ {
nums[i] = i+
} fmt.Println(nums)
//[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30] // 区间10-18
fmt.Println(nums[:])
// [11 12 13 14 15 16 17 18]
// 中间到尾部
fmt.Println(nums[:])
// [16 17 18 19 20 21 22 23 24 25 26 27 28 29 30]
// 开头到中间
fmt.Println(nums[:])
// [1 2 3 4 5 6 7 8 9 10]

2表示原有的切片

 fmt.Println(nums[:])
// [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30]

3重置切片,清空拥有的元素

fmt.Println(nums[:])
// []
fmt.Println(nums)
// [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30]

3.2.2 声明切片

每一种类型都可以拥有其切片类型,表示多个类型元素的连续集合 切片类型声明格式: var name []T name 表示切片类型的变量名 T 表示切片类型对应的元素类型 ​ 例子

   // 声明字串切片
var str_slice []string
// 声明整型
var int_slice []int
// 声明一个空切片
var null_slice = []int{} // null_slice已经是被分配到内存中,但没有元素 fmt.Println(str_slice, int_slice, null_slice)
// [] [] []

// 输出3个切片大小
fmt.Println( len(str_slice), len(int_slice), len(null_slice) )
// 0 0 0 // 切片判断空的结果
fmt.Println( str_slice == nil)
fmt.Println( int_slice == nil)
fmt.Println( null_slice == nil)
// true
// true
// false null_slice已经是被分配到内存,但没有元素,因此和nill比较时false

切片是动态结构,只能与nil判定相等,不能互相判等时

3.2.3 使用make()函数构造切片--动态创建一个切片

make()内建函数动态地创建一个切片 写法: make( []T, size, cap ) T: 切片的元素类型 size: 就是为这个类型分配多少个元素 cap: 预分配的元素数量,设置后不影响size,只是能提前分配空间,降低多次分配空间造成的性能问题

   make_a := make([]int, )
make_b := make([]int, , )
fmt.Println(make_a, make_b)
// [0 0] [0 0]

make_b 的内部存储空间已经分配了5个,但是实际上使用了2个元素 make()函数生成的切片一定发生了内存分配操作 但是给定切片的开始和结束位置的切片只是将新的切片结构指向已经分配好的内存区域 切片不一定经过make()函数声明使用,生成切片,声明后使用append()函数 均可以正常使用切片 ​

3.2.4 使用append()函数为切片动态添加元素

每个一起切片都会指向一个一片内存空间,空间能容纳一定数量的元素 当空间不容纳足够多的元素时,切片就会扩容,容量的扩展规律按容量的2倍扩充,如1,2,4,8,16

 var numbers []int

    for i := ; i<; i++ {
numbers = append(numbers, i)
fmt.Printf("len : %d cap: %d pointer: %p\n", len(numbers), cap(numbers), numbers)
} // len : 1 cap: 1 pointer: 0xc000054318
// len : 2 cap: 2 pointer: 0xc000054330
// len : 3 cap: 4 pointer: 0xc00006a0a0
// len : 4 cap: 4 pointer: 0xc00006a0a0
// len : 5 cap: 8 pointer: 0xc000076100
// len : 6 cap: 8 pointer: 0xc000076100
// len : 7 cap: 8 pointer: 0xc000076100
// len : 8 cap: 8 pointer: 0xc000076100
// len : 9 cap: 16 pointer: 0xc000088080
// len : 10 cap: 16 pointer: 0xc000088080 // 一次性添加很多元素
var car []string
// 添加1个元素
car = append(car, "OldDriver")
// 添加多个元素
car = append(car, "apple", "orange", "milk") // 添加切片
team := []string{"pig", "Flyingcake", "Chicken"}
car = append(car, team...) fmt.Println(car)
// [OldDriver apple orange milk pig Flyingcake Chicken]

3.2.5 使用copy()函数复制切片元素到另一个切片

格式: copy( destSlice, srcSlice []T) int srcSlice为数据来源切片 destSlice为复制的目标 复制目标的条件要求:

  1. 目标切片不是分配过空间且足够容纳复制的元素

  2. 来源和目标的类型需一样

copy()返回值表示实际发生复制的元素个数

 // 设置元素个数 100
const elementCount =
// 预分配元素切片
srcData := make([]int, elementCount)
// 将切片赋值
for i := ; i < elementCount; i++ {
srcData[i] = i
}
// 引用切片数据
refData := srcData
// 预分配足够多的元素切片
copyData := make([]int, elementCount)
// 将数据复制到新的切片空间中
copy( copyData, srcData) // 修改原数据第一个元素
srcData[] =
// 打印引用切片的第一个元素
fmt.Println(refData[])
// 99
// 打印复制切片的第一个和最后一个元素
fmt.Println(copyData[], copyData[elementCount-])
// 0 99 // 复制原始数据2到6(不包含)
copy(copyData, srcData[:]) for i:=; i<;i++ {
fmt.Printf("%d ", copyData[i])
}
//2 3 4 5 4 5 6 7 8 9

3.2.6 从切片中删除元素

Go语言没有对删除切片元素提供专门的语法或接口,只能利用切片本身特性删除元素 删除元素的本质:以被删除元素为分界点,将前后两个部分的内存重新连接起来

 seq := []string{"one", "two", "three", "four", "five"}

    // 指定删除位置
index := // 查看删除位置之前的元素和之后的元素
fmt.Println(seq[:index], seq[index + :])
// [one two] [four five] // 将删除点前后元素量连接起来
seq = append(seq[:index], seq[index+:]...)
fmt.Println(seq)
// [one two four five]
 

‘…’ 其实是go的一种语法糖。 第一个用法主要是用于函数有多个不定参数的情况,可以接受多个不确定数量的参数。 第二个用法是slice可以被打散进行传递

Go语言--数组、切片、的更多相关文章

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

    本文实例讲述了GO语言数组和切片的用法.分享给大家供大家参考.具体分析如下: 一.数组 与其他大多数语言类似,Go语言的数组也是一个元素类型相同的定长的序列. (1)数组的创建. 数组有3种创建方式: ...

  2. go语言中的数组切片:特立独行的可变数组

    go语言中的数组切片:特立独行的可变数组 初看go语言中的slice,觉得是可变数组的一种很不错的实现,直接在语言语法的层面支持,操作方面比起java中的ArrayList方便了许多.但是在使用了一段 ...

  3. 第四章 go语言 数组、切片和映射

    文章由作者马志国在博客园的原创,若转载请于明显处标记出处:http://www.cnblogs.com/mazg/ 数组是由同构的元素组成.结构体是由异构的元素组成.数据和结构体都是有固定内存大小的数 ...

  4. Go语言数组和切片的原理

    目录 数组 创建 访问和赋值 切片 结构 初始化 访问 追加 拷贝 总结 数组和切片是 Go 语言中常见的数据结构,很多刚刚使用 Go 的开发者往往会混淆这两个概念,数组作为最常见的集合在编程语言中是 ...

  5. Go语言学习之4 递归&闭包&数组切片&map&锁

    主要内容: 1. 内置函数.递归函数.闭包2. 数组与切片3. map数据结构4. package介绍 5. 排序相关 1. 内置函数.递归函数.闭包 1)内置函数 (1). close:主要用来关闭 ...

  6. go语言数组与切片比较

    一.数组 与其他大多数语言类似,Go语言的数组也是一个元素类型相同的定长的序列. (1)数组的创建. 数组有3种创建方式:[length]Type .[N]Type{value1, value2, . ...

  7. go语言之切片即动态数组

    切片和数组的类型有什么不一样,我们可以打印一下,就可以知道两者的区别了,数组是容量的,所以中括号中有容量,切片的动态数组,是没有容量,这是数组和切片最大的区别 test8_4 := [20] int ...

  8. Go语言中的数组与数组切片

    Go中的数组与C的数组一样,只是定义方法不同 c: int a[10][10] Go [10][10]int 定义并初始化 array1 := [5]int{1,2,3,4,5} 变量名 := [in ...

  9. go语言 类型:数组切片

    初看起来,数组切片就像一个指向数组的指针,实际上它拥有自己的数据结构,而不仅仅是个指针.数组切片的数据结构可以抽象为以下3个变量: 1.一个指向原生数组的指针: 2.数组切片中的元素个数: 3.数组切 ...

  10. GO 语言学习笔记--数组切片篇

    1.对于make 数组切片,长度和容量需要理解清楚: 容量表示底层数组的大小,长度是你可以使用的大小: 容量的用处在哪?在与当你用 appen d扩展长度时,如果新的长度小于容量,不会更换底层数组,否 ...

随机推荐

  1. Go语言中的Package问题

    问题一.Go使用Package组织源码的好处是什么? 1.任何源码属于一个包 2.用包组织便于代码的易读和复用 问题二.Go语言中Package的种类 Go语言中存在两种包.一种是可执行程序的包.一种 ...

  2. NSParagraphStyle 的属性

    UILabel * label = [[UILabel alloc] initWithFrame:CGRectMake(0, 0, 20, 20)]; label.font = [UIFont sys ...

  3. 常见的概率分布类型(Probability Distribution)

    统计学中最常见的几种概率分布分别是正态分布(normal distribution),t分布(t distribution),F分布(F distribution)和卡方分布(χ2 distribut ...

  4. docker内安装php缺少的扩展mysql.so和mysqli.so

    首先找到php.ini,放开扩展: 打开php.ini 去掉前面的分号,因为是linux环境所以扩展改为.so文件 进入容器内docker安装扩展的目录: ./docker-php-ext-insta ...

  5. XMLHttpRequest的使用

    XMLHttpRequest的使用 标签(空格分隔): JavaScript 前端 编程 function sendAjax() { //构造表单数据 var formData = new FormD ...

  6. 【洛谷P1129】矩阵游戏

    题目大意:给定一个 N*N 的矩阵,有些格子是 1,其他格子是 0.现在允许交换若干次行和若干次列,求是否可能使得矩阵的主对角线上所有的数字都是1. 题解:首先发现,交换行和交换列之间是相互独立的.主 ...

  7. 您必须知道的 Git 分支开发规范

    Git 是目前最流行的源代码管理工具. 为规范开发,保持代码提交记录以及 git 分支结构清晰,方便后续维护,现规范 git 的相关操作. 分支管理 分支命名 master 分支 master 为主分 ...

  8. Lloyd’s 算法 和 K-Means算法

    在讲Lloyd’s 算法之前先介绍Voronoi图 在数学中,Voronoi图是基于到平面的特定子集中的点的距离将平面划分成区域.预先指定一组点(称为种子,站点或生成器),并且对于每个种子,存在相应的 ...

  9. 课下作业MyCP的分析

    目录 MyCP 题目 截图 代码 相关知识 出现的问题 代码托管 参考资料 MyCP 题目 编写MyCP.java 实现类似Linux下cp XXX1 XXX2的功能,要求MyCP支持两个参数: ja ...

  10. \t \r \n \f

    \t 的意思是 :水平制表符.将当前位置移到下一个tab位置. \r 的意思是: 回车.将当前位置移到本行的开头. \n 的意思是:回车换行.将当前位置移到下一行的开头. \f的意思是:换页.将当前位 ...