扫码订阅《 Go语言核心编程教程》或入驻星球,即可阅读文章!

GOLANG ROADMAP

阅读模式

  • 沉浸
  • 自动
  • 日常
首页
Go学习
  • Go学院

    • Go小课
    • Go小考
    • Go实战
    • 精品课
  • Go宝典

    • 在线宝典
    • B站精选
    • 推荐图书
    • 精品博文
  • Go开源

    • Go仓库
    • Go月刊
  • Go下载

    • 视频资源
    • 文档资源
Go求职
  • 求职服务

    • 内推互助
    • 求职助力
  • 求职刷题

    • 企业题库
    • 面试宝典
    • 求职面经
Go友会
  • 城市
  • 校园
推广返利 🤑
实验区
  • Go周边
消息
更多
  • 用户中心

    • 我的信息
    • 推广返利
  • 玩转星球

    • 星球介绍
    • 角色体系
    • 星主权益
  • 支持与服务

    • 联系星主
    • 成长记录
    • 常见问题
    • 吐槽专区
  • 合作交流

    • 渠道合作
    • 课程入驻
    • 友情链接
author-avatar

GOLANG ROADMAP


首页
Go学习
  • Go学院

    • Go小课
    • Go小考
    • Go实战
    • 精品课
  • Go宝典

    • 在线宝典
    • B站精选
    • 推荐图书
    • 精品博文
  • Go开源

    • Go仓库
    • Go月刊
  • Go下载

    • 视频资源
    • 文档资源
Go求职
  • 求职服务

    • 内推互助
    • 求职助力
  • 求职刷题

    • 企业题库
    • 面试宝典
    • 求职面经
Go友会
  • 城市
  • 校园
推广返利 🤑
实验区
  • Go周边
消息
更多
  • 用户中心

    • 我的信息
    • 推广返利
  • 玩转星球

    • 星球介绍
    • 角色体系
    • 星主权益
  • 支持与服务

    • 联系星主
    • 成长记录
    • 常见问题
    • 吐槽专区
  • 合作交流

    • 渠道合作
    • 课程入驻
    • 友情链接
  • 尚硅谷Go语言核心编程教程

    • 课程说明
    • 第1章 GOLANG 开山篇
    • 第2章 GOLANG 的概述
    • 第3章 GOLANG 变量
    • 第4章 运算符
    • 第5章 程序流程控制
    • 第6章 函数、包和错误处理
    • 第7章 数组与切片
    • 第8章 排序和查找
    • 第9章 map
    • 第10章 面向对象编程 ( 上 )
    • 第11章 面向对象编程 ( 下 )
    • 第12章 项目1:家庭收支记账软件项目
    • 第13章 项目2:客户信息关系系统
    • 第14章 文件操作
    • 第15章 单元测试
    • 第16章 goroutine和channel
    • 第17章 反射
    • 第18章 TCP 编程
    • 第19章 REDIS 的使用
    • 第20章 数据结构

扫码订阅《 Go语言核心编程教程》或入驻星球,即可阅读文章!

第7章 数组与切片


GOLANG ROADMAP

# 7.1 为什么需要数组

【点击观看视频】数组的使用价值

看一个问题

一个养鸡场有 6 只鸡,它们的体重分别是 3 kg, 5 kg, 1 kg, 3. 4 kg, 2 kg, 50 kg 。请问这六只鸡的总体重是多少?平均体重是多少? 请你编一个程序。=》数组

使用传统的方法来解决

package main
import (
	"fmt"
)

func main() {

	/*
	一个养鸡场有6只鸡,它们的体重分别是3kg,5kg,1kg,
	3.4kg,2kg,50kg 。请问这六只鸡的总体重是多少?平
	均体重是多少? 请你编一个程序。=》数组
	*/

	//思路分析:定义六个变量,分别表示六只鸡的,然后求出和,然后求出平均值。
	hen1 := 3.0 
	hen2 := 5.0
	hen3 := 1.0 
	hen4 := 3.4 
	hen5 := 2.0 
	hen6 := 50.0
	
	totalWeight := hen1 + hen2 + hen3 + hen4 + hen5 + hen6
	//fmt.Sprintf("%.2f", totalWeight / 6) 将 totalWeight / 6 四舍五入保留到小数点2返回值
	avgWeight := fmt.Sprintf("%.2f", totalWeight / 6)
	fmt.Printf("totalWeight=%v avgWeight=%v\n", totalWeight, avgWeight)  
}
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

对上面代码的说明

1 ) 使用传统的方法不利于数据的管理和维护.

2 ) 传统的方法不够灵活,因此我们引出需要学习的新的数据类型=>数组.

# 7.2 数组介绍

数组可以存放多个同一类型数据。数组也是一种数据类型,在Go中,数组是值类型。

# 7.3 数组的快速入门

【点击观看视频】数组的快速入门

我们使用数组的方法来解决养鸡场的问题.

package main
import (
	"fmt"
)

func main() {

	//使用数组的方式来解决问题

	//1.定义一个数组
	var hens [7]float64
	//2.给数组的每个元素赋值, 元素的下标是从0开始的  0-5
	hens[0] = 3.0  //hens数组的第一个元素 hens[0]
	hens[1] = 5.0  //hens数组的第2个元素 hens[1]
	hens[2] = 1.0 
	hens[3] = 3.4 
	hens[4] = 2.0 
	hens[5] = 50.0 
	hens[6] = 150.0  //增加一只鸡
	//3.遍历数组求出总体重
	totalWeight2 := 0.0 
	for i := 0; i < len(hens); i++ {
		totalWeight2 += hens[i]
	}

	//4.求出平均体重
	avgWeight2 := fmt.Sprintf("%.2f", totalWeight2 / float64(len(hens)))  
	fmt.Printf("totalWeight2=%v avgWeight2=%v", totalWeight2, avgWeight2)

}
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

对上面代码的总结

1 ) 使用数组来解决问题,程序的可维护性增加.

2 ) 而且方法代码更加清晰,也容易扩展。

# 7.4 数组定义和内存布局

【点击观看视频】数组定义和内存布局

数组的定义

var 数组名 [数组大小]数据类型
var a [5]int
赋初值 a[0]= 1 a[1]= 30 .
1
2
3

数组在内存布局(重要)

image-20210114135801066

对上图的总结:

1 ) 数组的地址可以通过数组名来获取 &intArr

2 ) 数组的第一个元素的地址,就是数组的首地址

3 ) 数组的各个元素的地址间隔是依据数组的类型决定,比如int 64 - > 8 int 32 - > 4

package main
import (
	"fmt"
)

func main() {
	var intArr [3]int //int占8个字节
	//当我们定义完数组后,其实数组的各个元素有默认值 0
	fmt.Println(intArr)
	intArr[0] = 10
	intArr[1] = 20
	intArr[2] = 30
	fmt.Println(intArr)
	fmt.Printf("intArr的地址=%p intArr[0] 地址%p intArr[1] 地址%p intArr[2] 地址%p\n", 
		&intArr, &intArr[0], &intArr[1], &intArr[2])
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 7.5 数组的使用

【点击观看视频】数组的使用
  • 访问数组元素

    数组名 [ 下标 ] 比如:你要使用a数组的第三个元素 a[ 2 ]

  • 快速入门案例:从终端循环输入 5 个成绩,保存到float 64 数组,并输出.

package main
import (
	"fmt"
)

func main() {
	//从终端循环输入5个成绩,保存到float64数组,并输出.
	var score [5]float64

	for i := 0; i < len(score); i++ {
		fmt.Printf("请输入第%d个元素的值\n", i+1)
		fmt.Scanln(&score[i])
	}
	
	//变量数组打印
	for i := 0; i < len(score); i++ {
		fmt.Printf("score[%d]=%v\n", i, score[i])
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
  • 四种初始化数组的方式
package main
import (
	"fmt"
)

func main() {
	//四种初始化数组的方式
	var numArr01 [3]int = [3]int{1, 2, 3}
	fmt.Println("numArr01=", numArr01)

	var numArr02 = [3]int{5, 6, 7}
	fmt.Println("numArr02=", numArr02)
	//这里的 [...] 是规定的写法
	var numArr03 = [...]int{8, 9, 10}
	fmt.Println("numArr03=", numArr03)

	var numArr04 = [...]int{1: 800, 0: 900, 2:999}
	fmt.Println("numArr04=", numArr04)

	//类型推导
	strArr05 := [...]string{1: "tom", 0: "jack", 2:"mary"}
	fmt.Println("strArr05=", strArr05)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 7.6 数组的遍历

【点击观看视频】数组for-range遍历

# 7.6.1 方式 1 - 常规遍历:

前面已经讲过了,不再赘述。

# 7.6.2 方式 2 - for-range结构遍历

这是Go语言一种独有的结构,可以用来遍历访问数组的元素。

  • for--range的基本语法
for index,value :=range array01{

}
1
2
3

1.index数组的下标

2.value该下标对应的值

3.他们都是for循环内可见的局部变量

4.如果不想使用下标index,可以替换为"_"

5.index和value的名称不是固定的。可以自己改变

  • for-range的案例
package main
import (
	"fmt"
)

func main() {

	//演示for-range遍历数组
	 heroes  := [...]string{"宋江", "吴用", "卢俊义"}
	//使用常规的方式遍历,我不写了..

	for i, v := range heroes {
		fmt.Printf("i=%v v=%v\n", i , v)
		fmt.Printf("heroes[%d]=%v\n", i, heroes[i])
	}

	for _, v := range heroes {
		fmt.Printf("元素的值=%v\n", v)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 7.7 数组使用的注意事项和细节

【点击观看视频】数组注意事项和细节(1)
【点击观看视频】数组注意事项和细节(2)

1 ) 数组是多个相同类型数据的组合,一个数组一旦声明/定义了,其长度是固定的, 不能动态变化

package main
import (
	"fmt"
)

func main() {	
	//数组是多个相同类型数据的组合,一个数组一旦声明/定义了,其长度是固定的, 不能动态变化。
	var arr01 [3]int
	arr01[0] = 1
	arr01[1] = 30
	//这里会报错
	arr01[2] = 1.1  
	//其长度是固定的, 不能动态变化,否则报越界
	arr01[3] = 890

	fmt.Println(arr01)
}	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2 ) vararr[]int 这时 arr 就是一个slice切片,切片后面专门讲解,不急哈.

3 ) 数组中的元素可以是任何数据类型,包括值类型和引用类型,但是不能混用。

4 ) 数组创建后,如果没有赋值,有默认值(零值)

  • 数值类型数组:默认值为 0

  • 字符串数组: 默认值为 ""

  • bool数组: 默认值为 false

package main
import (
	"fmt"
)

func main() {	
	//数组创建后,如果没有赋值,有默认值(零值)
	//1. 数值(整数系列, 浮点数系列) =>0
	//2. 字符串 ==> ""
	//3. 布尔类型 ==> false

	var arr01 [3]float32
	var arr02 [3]string
	var arr03 [3]bool
	fmt.Printf("arr01=%v arr02=%v arr03=%v\n", arr01, arr02, arr03)
}	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

5 ) 使用数组的步骤 1. 声明数组并开辟空间 2 给数组各个元素赋值(默认零值) 3 使用数组

6 ) 数组的下标是从 0 开始的

package main
import (
	"fmt"
)

func main() {	
	//数组的下标是从0开始的

	var arr04 [3]string // 0 - 2
	var index int = 3
	arr04[index] = "tom" // 因为下标是 0 - 2 ,因此arr04[3]就越界
}	
1
2
3
4
5
6
7
8
9
10
11
12

7.) 数组下标必须在指定范围内使用,否则报 panic:数组越界,比如vararr[ 5 ]int 则有效下标为 0 - 4

8 ) Go的数组属值类型, 在默认情况下是值传递, 因此会进行值拷贝。数组间不会相互影响

package main
import (
	"fmt"
)

//函数
func test01(arr [3]int) {
	arr[0] = 88
} 

func main() {	
	//Go的数组属值类型, 在默认情况下是值传递, 因此会进行值拷贝。数组间不会相互影响

	arr := [3]int{11, 22, 33}
	test01(arr)
	fmt.Println("main arr=", arr) 
}	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

image-20210114142843128

9 ) 如想在其它函数中,去修改原来的数组,可以使用引用传递(指针方式)

package main
import (
	"fmt"
)

//函数
func test02(arr *[3]int) {
	fmt.Printf("arr指针的地址=%p", &arr)
	(*arr)[0] = 88 //!!
} 


func main() {	
	arr := [3]int{11, 22, 33}
	fmt.Printf("arr 的地址=%p", &arr)
	test02(&arr)
	fmt.Println("main arr=", arr)
}	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

image-20210114142931666

10 ) 长度是数组类型的一部分,在传递函数参数时 需要考虑数组的长度,看下面案例

//题1
package main
import (
	"fmt"
)

//默认值拷贝
func modify(arr []int) {
	arr[0] = 100
    fmt.Println("modify的arr",arr)
} 

func main() {	
	var arr = [...]int{1,2,3}
	modify(arr)
}	
//编译错误,因为不能把[3]int 传递给[]int
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//题2
package main
import (
	"fmt"
)

//默认值拷贝
func modify(arr [4]int) {
	arr[0] = 100
    fmt.Println("modify的arr",arr)
} 

func main() {	
	var arr = [...]int{1,2,3}
	modify(arr)
}	
//编译错误,因为不能把[3]int 传递给[4]int
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//题3
package main
import (
	"fmt"
)

//默认值拷贝
func modify(arr [3]int) {
	arr[0] = 100
    fmt.Println("modify的arr",arr)
} 

func main() {	
	var arr = [...]int{1,2,3}
	modify(arr)
}	
//正确
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 7.8 数组的应用案例

【点击观看视频】数组应用实例(1)
【点击观看视频】数组应用实例(2)

1 ) 创建一个byte类型的 26 个元素的数组,分别 放置'A'-'Z‘。使用for循环访问所有元素并打印出来。提示:字符数据运算 'A'+ 1 - >'B'

package main

import (
	"fmt"
)

func main() {
	//1)创建一个byte类型的26个元素的数组,分别 放置'A'-'Z‘。
	//使用for循环访问所有元素并打印出来。提示:字符数据运算 'A'+1 -> 'B'

	//思路
	//1. 声明一个数组 var myChars [26]byte
	//2. 使用for循环,利用 字符可以进行运算的特点来赋值 'A'+1 -> 'B'
	//3. 使用for打印即可
	//代码:
	var myChars [26]byte
	for i := 0; i < 26; i++ {
		myChars[i] = 'A' + byte(i) // 注意需要将 i => byte
	}

	for i := 0; i < 26; i++ {
		fmt.Printf("%c ", myChars[i])
	}

}
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

2 ) 请求出一个数组的最大值,并得到对应的下标。

package main

import (
	"fmt"
)

func main() {
	//请求出一个数组的最大值,并得到对应的下标

	//思路
	//1. 声明一个数组 var intArr[5] = [...]int {1, -1, 9, 90, 11}
	//2. 假定第一个元素就是最大值,下标就0
	//3. 然后从第二个元素开始循环比较,如果发现有更大,则交换

	fmt.Println()
	var intArr [6]int = [...]int{1, -1, 9, 90, 11, 9000}
	maxVal := intArr[0]
	maxValIndex := 0

	for i := 1; i < len(intArr); i++ {
		//然后从第二个元素开始循环比较,如果发现有更大,则交换
		if maxVal < intArr[i] {
			maxVal = intArr[i]
			maxValIndex = i
		}
	}
	fmt.Printf("maxVal=%v maxValIndex=%v\n\n", maxVal, maxValIndex)
}
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

3 ) 请求出一个数组的和和平均值。for-range

package main

import "fmt"

func main() {
	//请求出一个数组的和和平均值。for-range
	//思路
	//1. 就是声明一个数组  var intArr[5] = [...]int {1, -1, 9, 90, 11}
	//2. 求出和sum
	//3. 求出平均值
	//代码
	var intArr2 [5]int = [...]int{1, -1, 9, 90, 12}
	sum := 0
	for _, val := range intArr2 {
		//累计求和
		sum += val
	}

	//如何让平均值保留到小数.
	fmt.Printf("sum=%v 平均值=%v \n\n", sum, float64(sum)/float64(len(intArr2)))

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

4 ) 要求:随机生成五个数,并将其反转打印 , 复杂应用.

【点击观看视频】数组复杂应用-反转
package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	//要求:随机生成五个数,并将其反转打印
	//思路
	//1. 随机生成五个数 , rand.Intn() 函数
	//2. 当我们得到随机数后,就放到一个数组 int数组
	//3. 反转打印 , 交换的次数是  len / 2, 倒数第一个和第一个元素交换, 倒数第2个和第2个元素交换

	var intArr3 [5]int
	//为了每次生成的随机数不一样,我们需要给一个seed值
	len := len(intArr3)

	rand.Seed(time.Now().UnixNano())
	for i := 0; i < len; i++ {
		intArr3[i] = rand.Intn(100) //  0<=n<100
	}

	fmt.Println("交换前~=", intArr3)
	//反转打印 , 交换的次数是  len / 2,
	//倒数第一个和第一个元素交换, 倒数第2个和第2个元素交换
	temp := 0 //做一个临时变量
	for i := 0; i < len/2; i++ {
		temp = intArr3[len-1-i]
		intArr3[len-1-i] = intArr3[i]
		intArr3[i] = temp
	}

	fmt.Println("交换后~=", intArr3)

}
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
31
32
33
34
35
36
37

# 7.9 为什么需要切片

【点击观看视频】切片基本介绍和入门

先看一个需求:我们需要一个数组用于保存学生的成绩,但是学生的个数是不确定的,请问怎么办?解决方案:-》使用切片。

# 7.10 切片的基本介绍

1 ) 切片的英文是slice

2 ) 切片是数组的一个引用,因此切片是引用类型,在进行传递时,遵守引用传递的机制。

3 ) 切片的使用和数组类似,遍历切片、访问切片的元素和求切片长度len(slice)都一样。

4 ) 切片的长度是可以变化的,因此切片是一个可以动态变化数组。

5 ) 切片定义的基本语法:

var 切片名 []类型
//比如:vara[]int
1
2

# 7.11 快速入门

演示一个切片的基本使用:

package main
import (
	"fmt"
)

func main() {
	//演示切片的基本使用
	var intArr [5]int = [...]int{1, 22, 33, 66, 99}
	//声明/定义一个切片
	//slice := intArr[1:3]
	//1. slice 就是切片名
	//2. intArr[1:3] 表示 slice 引用到intArr这个数组 
	//3. 引用intArr数组的起始下标为 1 , 最后的下标为3(但是不包含3)    
	slice := intArr[1:3] 
	fmt.Println("intArr=", intArr) //[1 22 33 66 99]
	fmt.Println("slice 的元素是 =", slice) //  22, 33
	fmt.Println("slice 的元素个数 =", len(slice)) // 2
	fmt.Println("slice 的容量 =", cap(slice)) //4 切片的容量是可以动态变化  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 7.12 切片在内存中形式(重要)

【点击观看视频】切片的内存布局分析
  • 基本的介绍:

为了让大家更加深入的理解切片,我们画图分析一下切片在内存中是如何布局的,这个是一个非常重要的知识点:(以前面的案例来分析)

  • 画出前面的切片内存布局

image-20210114144926465

  • 对上面的分析图总结

    1 .slice的确是一个引用类型

    2 .slice 从底层来说,其实就是一个数据结构(struct结构体)

    type slice struct{
     ptr *[ 2 ]int
     len int
     cap int
    }
    
    1
    2
    3
    4
    5

# 7.13 切片的使用

【点击观看视频】使用切片的三种方式
  • 方式 1

第一种方式:定义一个切片,然后让切片去引用一个已经创建好的数组,比如前面的案例就是这样的。

  • 方式 2

第二种方式:通过 make 来创建切片.

基本语法:

 var 切片名 []type = make([]type,len,[cap])
1

参数说明:type: 就是数据类型 len: 大小 cap :指定切片容量,可选,如果你分配了 cap, 则要求 cap>=len.

案例演示:

package main

import (
	"fmt"
)

func main() {
	var slice []float64 = make([]float64, 5, 10)
	slice[1] = 10
	slice[3] = 20
	fmt.Println(slice)
	fmt.Println("slice的size=", len(slice))
	fmt.Println("slice的cap=", cap(slice))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

image-20210114150445181

对上面代码的小结:

1 ) 通过make方式创建切片可以指定切片的大小和容量

2 ) 如果没有给切片的各个元素赋值,那么就会使用默认值[int,float=> 0 string=>”” bool=> false]

3 ) 通过make方式创建的切片对应的数组是由make底层维护,对外不可见,即只能通过slice去访问各个元素.

  • 方式 3

第 3 种方式:定义一个切片,直接就指定具体数组,使用原理类似make的方式

案例演示:

package main

import (
	"fmt"
)

func main() {	
	var strSlice []string = []string{"tom", "jack", "mary"}
	fmt.Println("strSlice=", strSlice)
	fmt.Println("strSlice的size=", len(strSlice))
	fmt.Println("strSlice的cap=", cap(strSlice))
}
1
2
3
4
5
6
7
8
9
10
11
12
【点击观看视频】使用切片的区别分析
  • 方式 1 和方式 2 的区别(面试)

    方式1是直接引用数组,这个数组是事先存在的,程序员是可见的

    方式2是通过make来创建切片,make也会创建一个数组,是由切片在底层进行维护,程序员是看不见的。make创建切片的示意图:

    image-20210114151503113

# 7.14 切片的遍历

【点击观看视频】切片的遍历

切片的遍历和数组一样,也有两种方式

  • for 循环常规方式遍历

  • for-range 结构遍历切片

package main

import (
	"fmt"
)

func main() {

	//使用常规的for循环遍历切片
	var arr [5]int = [...]int{10, 20, 30, 40, 50}
	//slice := arr[1:4] // 20, 30, 40
	slice := arr[1:4]
	for i := 0; i < len(slice); i++ {
		fmt.Printf("slice[%v]=%v ", i, slice[i])
	}

	fmt.Println()
	//使用for--range 方式遍历切片
	for i, v := range slice {
		fmt.Printf("i=%v v=%v \n", i, v)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 7.15 切片的使用的注意事项和细节讨论

【点击观看视频】切片注意事项和细节(1)
【点击观看视频】切片注意事项和细节(2)
【点击观看视频】切片注意事项和细节(3)

1 ) 切片初始化时 varslice=arr[startIndex:endIndex]

说明:从arr数组下标为startIndex,取到 下标为endIndex的元素(不含arr[endIndex])。

2 ) 切片初始化时,仍然不能越界。范围在 [ 0 - len(arr)] 之间,但是可以动态增长.

varslice=arr[ 0 :end] 可以简写 varslice=arr[:end]

varslice=arr[start:len(arr)] 可以简写: varslice=arr[start:]

varslice=arr[ 0 :len(arr)] 可以简写:varslice=arr[:]

3 ) cap是一个内置函数,用于统计切片的容量,即最大可以存放多少个元素。

4 ) 切片定义完后,还不能使用,因为本身是一个空的,需要让其引用到一个数组,或者make一 个空间供切片来使用

5 ) 切片可以继续切片[案例演示]

package main
import (
	"fmt"
)

func main() {

	//使用常规的for循环遍历切片
	var arr [5]int = [...]int{10, 20, 30, 40, 50}
	//slice := arr[1:4] // 20, 30, 40
	slice := arr[1:4]
	for i := 0; i < len(slice); i++ {
		fmt.Printf("slice[%v]=%v ", i, slice[i])
	}

	fmt.Println()
	//使用for--range 方式遍历切片
	for i, v := range slice {
		fmt.Printf("i=%v v=%v \n", i, v)
	}

	slice2 := slice[1:2] //  slice [ 20, 30, 40]    [30]
	slice2[0] = 100  // 因为arr , slice 和slice2 指向的数据空间是同一个,因此slice2[0]=100,其它的都变化

	fmt.Println("slice2=", slice2)
	fmt.Println("slice=", slice)
	fmt.Println("arr=", arr)
}
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

6 ) 用append内置函数,可以对切片进行动态追加

package main

import (
	"fmt"
)

func main() {

	//使用常规的for循环遍历切片
	var arr [5]int = [...]int{10, 20, 30, 40, 50}
	//slice := arr[1:4] // 20, 30, 40
	slice := arr[1:4]
	for i := 0; i < len(slice); i++ {
		fmt.Printf("slice[%v]=%v ", i, slice[i])
	}

	fmt.Println()
	//使用for--range 方式遍历切片
	for i, v := range slice {
		fmt.Printf("i=%v v=%v \n", i, v)
	}

	slice2 := slice[1:2] //  slice [ 20, 30, 40]    [30]
	slice2[0] = 100      // 因为arr , slice 和slice2 指向的数据空间是同一个,因此slice2[0]=100,其它的都变化

	fmt.Println("slice2=", slice2)
	fmt.Println("slice=", slice)
	fmt.Println("arr=", arr)

	fmt.Println()

	//用append内置函数,可以对切片进行动态追加
	var slice3 []int = []int{100, 200, 300}
	//通过append直接给slice3追加具体的元素
	slice3 = append(slice3, 400, 500, 600)
	fmt.Println("slice3", slice3) //100, 200, 300,400, 500, 600

	//通过append将切片slice3追加给slice3
	slice3 = append(slice3, slice3...) // 100, 200, 300,400, 500, 600 100, 200, 300,400, 500, 600
	fmt.Println("slice3", slice3)

}
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
31
32
33
34
35
36
37
38
39
40
41
42

对上面代码的小结

image-20210114152259991

切片 append 操作的底层原理分析:

  • 切片append操作的本质就是对数组扩容
  • go底层会创建一下新的数组newArr(安装扩容后大小)
  • 将slice原来包含的元素拷贝到新的数组newArr
  • slice 重新引用到newArr
  • 注意newArr是在底层来维护的,程序员不可见.

7.) 切片的拷贝操作

切片使用copy内置函数完成拷贝,举例说明

package main

import (
	"fmt"
)

func main() {

	//切片的拷贝操作
	//切片使用copy内置函数完成拷贝,举例说明
	fmt.Println()
	var slice4 []int = []int{1, 2, 3, 4, 5}
	var slice5 = make([]int, 10)
	copy(slice5, slice4)
	fmt.Println("slice4=", slice4) // 1, 2, 3, 4, 5
	fmt.Println("slice5=", slice5) // 1, 2, 3, 4, 5, 0 , 0 ,0,0,0

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

对上面代码的说明:

  • ( 1 ) copy(para 1 ,para 2 ) 参数的数据类型是切片

  • ( 2 ) 按照上面的代码来看,slice 4 和slice 5 的数据空间是独立,相互不影响,也就是说 slice 4 [ 0 ]= 999 ,slice 5 [ 0 ] 仍然是 1

8 ) 关于拷贝的注意事项

package main

import (
	"fmt"
)

func main() {

	//思考题,下面的代码有没有错误
	var a []int = []int{1, 2, 3, 4, 5}
	var slice = make([]int, 1)
	fmt.Println(slice) // 0
	copy(slice, a)
	fmt.Println(slice) // 1
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

说明: 上面的代码没有问题,可以运行, 最后输出的是 [ 1 ]

9 ) 切片是引用类型,所以在传递时,遵守引用传递机制。看两段代码,并分析底层原理

package main

import (
	"fmt"
)

func main() {
	var slice []int
	var arr [5]int = [...]int{1, 2, 3, 4, 5}
	slice = arr[:]
	var slice2 = slice
	slice2[0] = 10

	fmt.Println("slice2", slice2) // 10 2 3 4 5
	fmt.Println("slice", slice) // 10 2 3 4 5
	fmt.Println("arr", arr) // 10 2 3 4 5

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main

import (
	"fmt"
)

func test(slice []int) {
	slice[0] = 100
}

func main() {
	var slice = []int{1, 2, 3, 4, 5}
	fmt.Println("slice", slice) //1 2 3 4 5
	test(slice)
	fmt.Println("slice", slice)//100 2 3 4 5

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 7.16 string和slice

【点击观看视频】string和slice

1 ) string底层是一个byte数组,因此string也可以进行切片处理 案例演示:

package main

import (
	"fmt"
)

func main() {
	str := "hello@atguigu"
	//使用切片获取到atuguigu
	slice := str[6:]
	fmt.Println("slice", slice)
}
1
2
3
4
5
6
7
8
9
10
11
12

2 ) string和切片在内存的形式,以 "abcd" 画出内存示意图

image-20210114155348690

3 ) string是不可变的,也就说不能通过 str[ 0 ]='z' 方式来修改字符串

//string是不可变的,也就说不能通过 str[0] = 'z' 方式来修改字符串 
str[0] = 'z' [编译不会通过,报错,原因是string是不可变]
1
2

4 ) 如果需要修改字符串,可以先将string->[]byte/ 或者 []rune-> 修改 -> 重写转成string

package main

import (
	"fmt"
)

func main() {

	//如果需要修改字符串,可以先将string -> []byte / 或者 []rune -> 修改 -> 重写转成string
	//"hello@atguigu" =>改成 "zello@atguigu"
	str := "hello@atguigu"
	arr1 := []byte(str)
	arr1[0] = 'z'
	str = string(arr1)
	fmt.Println("str=", str)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

import (
	"fmt"
)

func main() {

	//如果需要修改字符串,可以先将string -> []byte / 或者 []rune -> 修改 -> 重写转成string
	//"hello@atguigu" =>改成 "zello@atguigu"
	str := "hello@atguigu"

	// 细节,我们转成[]byte后,可以处理英文和数字,但是不能处理中文
	// 原因是 []byte 字节来处理 ,而一个汉字,是3个字节,因此就会出现乱码
	// 解决方法是 将  string 转成 []rune 即可, 因为 []rune是按字符处理,兼容汉字

	arr1 := []rune(str)
	arr1[0] = '北'
	str = string(arr1)
	fmt.Println("str=", str)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 7.17 切片的课堂练习题

【点击观看视频】切片的课堂练习

说明:编写一个函数 fbn(nint) ,要求完成

1 ) 可以接收一个 nint

2 ) 能够将斐波那契的数列放到切片中

3 ) 提示, 斐波那契的数列形式:arr[ 0 ]= 1 ;arr[ 1 ]= 1 ;arr[ 2 ]= 2 ;arr[ 3 ]= 3 ;arr[ 4 ]= 5 ;arr[ 5 ]= 8

代码 + 思路:

package main
import (
	"fmt"
)

func fbn(n int) ([]uint64) {
	//声明一个切片,切片大小 n
	fbnSlice := make([]uint64, n)
	//第一个数和第二个数的斐波那契 为1
	fbnSlice[0] = 1
	fbnSlice[1] = 1
	//进行for循环来存放斐波那契的数列
	for i := 2; i < n; i++ {
		fbnSlice[i] = fbnSlice[i - 1] + fbnSlice[i - 2]
	}

	return fbnSlice
}

func main() {

	/*
	1)可以接收一个 n int
	2)能够将斐波那契的数列放到切片中
	3)提示, 斐波那契的数列形式:
	arr[0] = 1; arr[1] = 1; arr[2]=2; arr[3] = 3; arr[4]=5; arr[5]=8

	思路
	1. 声明一个函数 fbn(n int) ([]uint64)
	2. 编程fbn(n int) 进行for循环来存放斐波那契的数列  0 =》 1 1 =》 1
	*/

	//测试一把看看是否好用
	fnbSlice := fbn(20)
	fmt.Println("fnbSlice=", fnbSlice)

}
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
31
32
33
34
35
36
37
  • 7.1 为什么需要数组
  • 7.2 数组介绍
  • 7.3 数组的快速入门
  • 7.4 数组定义和内存布局
  • 7.5 数组的使用
  • 7.6 数组的遍历
  • 7.6.1 方式 1 - 常规遍历:
  • 7.6.2 方式 2 - for-range结构遍历
  • 7.7 数组使用的注意事项和细节
  • 7.8 数组的应用案例
  • 7.9 为什么需要切片
  • 7.10 切片的基本介绍
  • 7.11 快速入门
  • 7.12 切片在内存中形式(重要)
  • 7.13 切片的使用
  • 7.14 切片的遍历
  • 7.15 切片的使用的注意事项和细节讨论
  • 7.16 string和slice
  • 7.17 切片的课堂练习题