go 数组与切片

最新推荐文章于 2024-05-04 17:02:34 发布

wuxingge

最新推荐文章于 2024-05-04 17:02:34 发布

阅读量195

点赞数

分类专栏： go

本文链接：https://blog.csdn.net/wuxingge/article/details/104340781

版权

go 专栏收录该内容

31 篇文章 0 订阅

订阅专栏

数组介绍

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

一个养鸡场有5只鸡，它们的体重分别是3kg，5kg,1kg,3.4kg,2kg, 请问这5只鸡的总体重是多少？平均体重是多少？

package main

import "fmt"

func main() {
	var hens [5]float64
	hens[0] = 3.0
	hens[1] = 5.0
	hens[2] = 1.0
	hens[3] = 3.4
	hens[4] = 2.0
	totalWeight := 0.0
	for i :=0; i < len(hens); i++ {
		totalWeight += hens[i]
	}
	avgWeight := fmt.Sprintf("%.2f", totalWeight / float64(len(hens)))
	fmt.Printf("totalWeight=%v avgWeight=%v", totalWeight, avgWeight)
}

数组定义和内存布局

数组的定义

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

数组在内存布局（重要）

package main

import "fmt"

func main() {
	var intArr [3]int
	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", &intArr, &intArr[0], &intArr[1], &intArr[2])
}

运行结果

[0 0 0]
[10 20 30]
intArr的地址=0xc0420420a0 intArr[0]地址=0xc0420420a0 intArr[1]地址=0xc0420420a8 intArr[2]地址=0xc0420420b0

在这里插入图片描述
说明：

数组的地址可以通过数组名来获取 &intArr
数组的第一个元素的地址，就是数组的首地址
数组的各个元素的地址间隔是依据数组的类型决定，比如int64 -> 8 int32 -> 4 …

数组的使用

访问数组元素
数组名[下标] a数组的第三个元素 a[2]

从终端循环输入5个成绩，保存到float64数组，并输出

package main

import "fmt"

func main() {
	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])
	}
}

四种初始化数组的方式

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)
}

数组的遍历

for-range结构遍历
这是go语言一种独有的结构，可以用来遍历访问数组的元素
语法

for index, value := range array01 {
	...
}

说明：

第一个返回值index是数组的下标
第二个value是再该下标位置的值
它们都是仅在for循环内部可见的局部变量
遍历数组元素的时候，如果不想使用下标index，可以直接把下标index标为下划线 _
index 和value的名称不是固定的，即程序员可以自行指定，一般命名为index和value

package main

import "fmt"

func main() {
	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)
	}
}

数组使用的注意事项

数组是多个相同类型数据的组合，一个数组一旦声明/定义了，其长度是固定的，不能动态变化
var arr []int 这时 arr就是一个slice切片
数组中的元素可以是任何数据类型，包括值类型和引用类型，但是不能混用
数组创建后，如果没有赋值，有默认值（零值）
- 数值类型数组：默认值为0
- 字符串数组：默认值为 “”
- bool数组：默认值为 false

package main

import "fmt"

func main() {
	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 使用数组
数组的下标是从0开始的
数组下标必须在指定范围内使用，否则报 panic: 数组越界
go的数组属值类型，在默认情况下是值传递，因此会进行值拷贝。数组间不会相互影响

package main

import "fmt"

func test01(arr [3]int)  {
	arr[0] = 88
	fmt.Println("test01 arr=", arr)
}
func main() {
	arr :=  [3]int{11, 22, 33}
	test01(arr)
	fmt.Println("main arr=", arr)
}

运行结果

test01 arr= [88 22 33]
main arr= [11 22 33]

如想在其它函数中修改原来的数组，可以使用引用传递（指针方式）

package main

import "fmt"

func test02(arr *[3]int)  {
	(*arr)[0] = 88
	fmt.Println("test02 arr=", *arr)
}
func main() {
	arr :=  [3]int{11, 22, 33}
	test02(&arr)
	fmt.Println("main arr=", arr)
}

长度是数组类型的一部分，在传递函数参数时，需要考虑数组的长度

数组应用案例

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

package main

import "fmt"

func main() {
	var myChars [26]byte
	for i :=0; i < 26; i++ {
		myChars[i] = 'A' + byte(i)
	}
	for i :=0; i < 26; i++ {
		fmt.Printf("%c ", myChars[i])
	}
}

求出一个数组的最大值，并得到对应的下标

package main

import "fmt"

func main() {
	var intArr [6]int = [...]int{1, -2, 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", maxVal, maxValIndex)
}

求出一个数组的和与平均值

package main

import "fmt"

func main() {
	var intArr [6]int = [...]int{1, -2, 9, 90, 11, 9000}
	sum := 0
	for _, val := range intArr {
		sum += val
	}
	fmt.Printf("sum=%v 平均值=%v", sum, float64(sum) / float64(len(intArr)))
}

随机生成五个数，并将其反转打印

package main

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

func main() {
	var intArr3 [5]int
	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)
	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)
}

切片

切片的英文是slice
切片是数组的一个引用，因此切片是引用类型，在进行传递时，遵守引用传递的机制
切片的使用和数组类似，遍历切片、访问切片的元素和求切片长度len(slice)都一样
切片的长度是可以变化的，因此切片是一个可以动态变化数组
切片定义的基本语法

var 切片名 []类型
var a []int

package main

import "fmt"

func main() {
	var intArr [5]int = [...]int{1, 22, 33, 66, 99}
	//slice就是切片名
	slice := intArr[1:3] //顾头不顾尾
	fmt.Println("intArr=", intArr)
	fmt.Println("slice的元素是 =", slice)
	fmt.Println("slice的元素个数 =", len(slice))
	fmt.Println("slece的容量 =", cap(slice))
}

package main

import "fmt"

func main() {
	var intArr [5]int = [...]int{1, 22, 33, 66, 99}
	slice := intArr[1:3]
	slice[0] = 200
	fmt.Println("intArr=", intArr)
	fmt.Println("slice=", slice)
	fmt.Println("slice 元素个数 =", len(slice))
	fmt.Println("slice 容量 =", cap(slice))
	fmt.Println("intArr[1] 地址= ", &intArr[1])
	fmt.Println("slice[0] 地址= ", &slice[0])
	fmt.Println("slice[0] 值 =", slice[0])
}

运行结果

intArr= [1 200 33 66 99]
slice= [200 33]
slice 元素个数 = 2
slice 容量 = 4
intArr[1] 地址=  0xc042062038
slice[0] 地址=  0xc042062038
slice[0] 值 = 200

切片在内存中形式

slice的确是一个引用类型
slice从底层来说，其实就是一个数据结构(struct结构体)

type slice struct {
	ptr *[2]int
	len int
	cap int
}

切片的使用

第一种方式：定义一个切片，然后让切片去引用一个已经创建好的数组

package main

import "fmt"

func main() {
	var arr [5]int = [...]int{1, 2, 3, 4, 5}
	var slice = arr[1:3]
	fmt.Println("arr=", arr)
	fmt.Println("slice=", slice)
	fmt.Println("slice len = ", len(slice))
	fmt.Println("slice cap = ", cap(slice))
}

运行结果

arr= [1 2 3 4 5]
slice= [2 3]
slice len =  2
slice cap =  4

第二种方式：通过make来创建切片
语法

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

说明
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))
}

说明：

通过make方式创建切片可以指定切片的大小和容量
如果没有给切片的各个元素赋值，那么就会使用默认值[int, float => 0 string =>"" bool => false]
通过make方式创建的切片对应的数组是由make底层维护，对外不可见，即只能通过slice去访问各个元素

第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区别
方式1是直接引用数组，这个数组是事先存在的，程序员是可见的
方式2是通过make来创建切片，make也会创建一个数组，是由切片在底层进行维护，程序员是看不见的

在这里插入图片描述

切片的遍历

for循环常规方式遍历
for-range结构遍历切片

package main

import "fmt"

func main() {
	var arr [5]int = [...]int{10, 20, 30, 40, 50}
	slice := arr[1:4]
	for i := 0; i < len(slice); i++ {
		fmt.Printf("slice[%v]=%v\n", i, slice[i])
	}
	for i, v := range slice {
		fmt.Printf("i=%v v=%v\n", i, v)
	}
}

切片的使用注意事项

切片初始化时， var slice = arr[startIndex:endIndex]
说明：从arr数组下标为startIndex, 取到下标为endIndex的元素(不含arr[endIndex])
切片初始化时，仍然不能越界。范围在[0-len(arr)]之间，但是可以动态增长

var slice = arr[0:end] 可以简写  var slice = arr[:end]
var slice = arr[start:len(arr)] 可以简写： var slice = arr[start:]
var slice = arr[0:len(arr)] 可以简写： var slice = arr[:]

cap是一个内置函数，用于统计切片的容量，即最大可以存放多少个元素
切片定义完后，还不能使用，因为本身是一个空的，需要让其引用到一个数组，或者make一个空间供切片来使用
切片可以继续切片

package main

import "fmt"

func main() {
	var arr [5]int = [...]int{10, 20, 30, 40, 50}
	slice := arr[1:4]
	for i := 0; i < len(slice); i++ {
		fmt.Printf("slice[%v]=%v\n", i, slice[i])
	}
	for i, v := range slice {
		fmt.Printf("i=%v v=%v\n", i, v)
	}
	slice2 := slice[1:2]
	slice2[0] = 100  // arr, slice, slice2 指向饿数据空间是同一个
	fmt.Println("slice2=", slice2)
	fmt.Println("slice=", slice)
	fmt.Println("arr=", arr)
}

运行结果

slice[0]=20
slice[1]=30
slice[2]=40
i=0 v=20
i=1 v=30
i=2 v=40
slice2= [100]
slice= [20 100 40]
arr= [10 20 100 40 50]

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

package main

import "fmt"

func main() {
	var slice3 []int = []int{100, 200, 300}
	slice3 = append(slice3, 400, 500, 600)
	fmt.Println("slice3=", slice3)
	slice3 = append(slice3, slice3...)
	fmt.Println("slice3=", slice3)
}

在这里插入图片描述
切片append操作的底层原理分析：
切片append操作的本质就是对数组扩容
go底层会创建一个新的数组newArr(按照扩容后大小)
将slice原来包含的元素拷贝到新的数组newArr
slice重新引用到newArr
newArr是在底层来维护的，程序员不可见

切片的拷贝操作
切片使用copy内置函数完成拷贝

package main

import "fmt"

func main() {
	var slice4 []int = []int{1, 2, 3, 4, 5}
	var slice5 = make([]int, 10)
	copy(slice5, slice4)
	fmt.Println("slice4=", slice4)
	fmt.Println("slice5=", slice5)
}

运行结果

slice4= [1 2 3 4 5]
slice5= [1 2 3 4 5 0 0 0 0 0]

说明：

copy(para1, para2) 参数的数据类型是切片
slice4 和 slice5 的数据空间是独立的，相互不影响

package main

import "fmt"

func main() {
	var a []int = []int{1, 2, 3, 4, 5}
	var slice = make([]int, 1)
	fmt.Println(slice)
	copy(slice, a)
	fmt.Println("slice=", slice)
}

运行结果

[0]
slice= [1]

切片是引用类型，所以在传递时，遵守引用传递机制

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

运行结果

slice2= [10 2 3 4 5]
slice= [10 2 3 4 5]
arr= [10 2 3 4 5]

package main

import "fmt"

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

运行结果

slice= [1 2 3 4]
slice= [100 2 3 4]

string 和 slice

string底层是一个byte数组，因此string也可以进行切片处理

package main

import "fmt"

func main() {
	str := "hello@wuxingge"
	slice := str[6:]
	fmt.Println("slice=", slice)
}

string和切片在内存的形式

在这里插入图片描述

string是不可变的，也就是说不能通过 str[0] = ‘z’ 方式来修改字符串
如果需要修改字符串，可以先将string -> []byte /或者 []rune -> 修改 -> 重写转换string

package main

import "fmt"

func main() {
	str := "hello@wuxingge"
	arr1 := []byte(str)
	arr1[0] = 'z'
	str = string(arr1)
	fmt.Println("str=", str)
}

package main

import "fmt"

func main() {
	str := "hello@wuxingge"
	arr1 := []rune(str)
	arr1[0] = '北'
	str = string(arr1)
	fmt.Println("str=", str)
}

编写函数fbn(n int)，要求完成

可以接收一个n int
能够将斐波那契的数列放到切片中
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) {
	fbnSlice := make([]uint64, n)
	fbnSlice[0] = 1
	fbnSlice[1] = 1
	for i := 2; i < n; i++ {
		fbnSlice[i] = fbnSlice[i - 2] + fbnSlice[i - 1]
	}
	return fbnSlice
}
func main() {
	fbnSlice := fbn(20)
	fmt.Println("fbnSlice=", fbnSlice)
}

wuxingge

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
go 数组与切片

数组介绍数组可以存放多个同一类型数据。数组也是一种数据类型，在go中，数组是值类型一个养鸡场有5只鸡，它们的体重分别是3kg，5kg,1kg,3.4kg,2kg, 请问这5只鸡的总体重是多少？平均体重是多少？package mainimport "fmt"func main() { var hens [5]float64 hens[0] = 3.0 hens[1] = 5.0...
复制链接

扫一扫