【Golang】数组与切片-学习笔记

超长待机。

已于 2022-08-23 12:03:55 修改

阅读量200

点赞数 1

分类专栏： Golang学习笔记文章标签： golang 学习开发语言

于 2022-07-20 20:54:58 首次发布

本文链接：https://blog.csdn.net/qq_45070951/article/details/125900108

版权

Golang学习笔记专栏收录该内容

12 篇文章 1 订阅

订阅专栏

数组

1.为什么需要数组

看一个问题
一个养鸡场有6只鸡，它们的体重分别是3kg, 5kg, 1kg, 3.4kg, 2kg, 50kg 。请问这六只鸡的总体重是多少?平均体重是多少?请你编一个程序。=》数组
使用传统的方法来解决

package main
import "fmt"
func main() {
	// 思路分析:定义六个变量,分别表示六只鸡的，然后求出和,然后求出平均值。
	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
	// 将 totalweight / 6 四舍五入保留到小数点2返回值
	avgweight := fmt.Sprintf("%.2f", totalweight / 6)
	fmt.Printf("totalweight=%v avgweight=%v", totalweight, avgweight)
}

运行结果

注：
（1）使用传统的方法不利于数据的管理和维护
（2）传统的方法不够灵活，因此我们引出需要学习的新的数据类型=→>数组

2. 数组介绍

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

3.数组的快速入门

使用数组的方法来解决养鸡场的问题
代码

package main
import "fmt"

func main(){
	var hens [7]float64
	//2.给数组的每个元素赋值,元素的下标是从o开始的0-5hens[o]= 3.0//hens数组的第一个元素 
	hens[0] = 3.0
	hens[1]= 5.0//hens数组的第2个元素
	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.Println()
	fmt.Printf("totalweight2=%v avgweight2=%v\n", totalweight2, avgweight2)
}

运行结果

注：
（1）使用数组来解决问题，程序的可维护性增加
（2）而且方法代码更加清晰，也容易扩展

4.数组定义和内存布局

数组的定义
var 数组名 [数组大小]数据类型
var a [5]int
赋初值 a[0] = 1 a[1] = 30 …
数组在内存布局(重要)
数组的内存布局
总结：
（1）数组的地址可以通过数组名来获取&intArr
（2）数组的第一个元素的地址，就是数组的首地址
（3）数组的各个元素的地址间隔是依据数组的类型决定，比如 int64 ->8 int32->4…
举个栗子

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[0]的地址%p\t",&intArr[0])
	fmt.Printf("intArr[1]的地址%p\t",&intArr[1])
	fmt.Printf("intArr[2]的地址%p\t",&intArr[2])
}

运行结果

5.数组的使用

访问数组元素
数组名[下标] 比如：要使用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 num1 [3]int = [3]int{1,2,3}
	fmt.Println("num1 = ",num1)

	var num2 = [3]int{5,6,7}
	fmt.Println("num2 = ",num2)

	var num3 = [...]int{7,8,9}
	fmt.Println("num3 = ",num3)

	var num4 = [...]int{1:100, 0:200, 2:300}
	fmt.Println("num4 = ",num4)

	// 类型推导
	strArr5 := [...]string{1:"tom", 0:"jack",2:"marry"}
	fmt.Println("strArr5 = ",strArr5)
}

运行结果

6.数组的遍历

1）for循环遍历
略
2）for-range结构遍历
这是go语言一种特有的结构，可以用来遍历访问数组的元素。
for-range的基本语法

for index, value := range array01 {…
}

注：
（1）第一个返回值index是数组的下标
（2）第二个value是在该下标位置的值
（3）他们都是仅在for循环内部可见的局部变量
（4）遍历数组元素的时候，如果不想使用下标index，可以直接把下标index标为下划线_
（5）index和value的名称不是固定的，可自行指定，一般命名为index和value
举个栗子
代码

package main
import "fmt"

func main(){
	// for-range 遍历数组
	heroes := [...]string{"宋江","吴用","卢俊义"}
	for i, v := range heroes{
		fmt.Printf("i=%v, v=%v", i, v)
		fmt.Printf("heroes[%d]=%v\n", i, heroes[i])
	}
	for _, v := range heroes{
		fmt.Printf("元素的值=%v\n",v)
	}
}

运行结果

7.数组使用的注意事项和细节

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

（2）var arr []int这时arr 就是一个slice切片
（3）数组中的元素可以是任何数据类型，包括值类型和引用类型，但是不能混用
（4）数组创建后，如果没有赋值，有默认值(零值)
数值类型数组：默认值为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,", arr01, arr02, arr03)
}

运行结果

（5）使用数组的步骤1.声明数组并开辟空间⒉给数组各个元素赋值(默认零值)3.使用数组
（6）数组的下标是从0开始的
（7）数组下标必须在指定范围内使用，否则报panic：数组越界，比如
var arr [5]int则有效下标为0-4
（8）Go的数组属值类型，在默认情况下是值传递，因此会进行值拷贝。数组间不会相互影响
函数内存
代码

package main
import "fmt"

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

运行结果

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

package main
import "fmt"

func Test1(arr *[3]int){
	(*arr)[0] = 88
	fmt.Println("Test1:", arr)
	fmt.Printf("Test1中arr的位置 %p\n",&arr[0])
}
func main(){
	arr := [3]int{11,22,33}
	Test1(&arr)
	fmt.Println("main:", arr)
	fmt.Printf("main中arr的位置 %p\n",&arr[0])
}

运行结果

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

8.数组的应用案例

（1）创建一个byte类型的26个元素的数组，分别放置’A’-Z‘。使用for循环访问所有元素并打印出来。
代码

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

运行结果

（2）请求出一个数组的最大值，并得到对应的下标。
代码

package main
import "fmt"

func main(){
	var nums [6]int = [...]int{1,-1,9,90,11,9000}
	maxKey := nums[0]
	maxIndex := 0
	for i := 1; i < len(nums); i++{
		if maxKey < nums[i]{
			maxKey = nums[i]
			maxIndex = i
		}
	}
	fmt.Printf("maxKey=%v,maxIndex=%v", maxKey, maxIndex)
}

运行结果

（3）请求出一个数组的和和平均值。for-range
代码

package main
import "fmt"

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

运行结果

（4）要求：随机生成五个数，并将其反转打印
代码

package main
import (
	"fmt"
	"math/rand"
	"time"
)
func main(){
	var nums [5]int
	// 为了每次生成的随机数不一样，我们需要设置一个seed值
	// rand.Seed(time.Now().Unix())// 同一秒生成的数是一样的
	rand.Seed(time.Now().UnixNano())
	for i := 0; i < len(nums); i++{
		nums[i] = rand.Intn(100)//默认值[81 87 47 59 81]
	}
	fmt.Println("交换前：", nums)
	for i:= 0; i < len(nums); i++{
		j := len(nums)-i-1
		if i == j{
			break
		}
		nums[i], nums[j] = nums[j], nums[i] 
	}
	fmt.Println("交换后：", nums)

}

运行结果

9.二维数组的介绍

（1）二维数组的应用场景
比如我们开发一个五子棋游戏，棋盘就是需要二维数组来表示。
（2）二维数组快速入门
请用二维数组输出如下图形
0 0 0 0 0 0
0 0 1 0 0 0
0 2 0 3 0 0
0 0 0 0 0 0
代码演示

package main
import(
	"fmt"
)
/*
请用二维数组输出如下图形
0 0 0 0 0 0
0 0 1 0 0 0
0 2 0 3 0 0
0 0 0 0 0 0
*/
func main(){
	var arr [4][6]int
	// 赋初值
	arr[1][2] = 1
	arr[2][1] = 2
	arr[3][2] = 3
	// 遍历二维数组，输出图像
	for i := 0; i < 4; i++{
		for j := 0; j < 6; j++{
			fmt.Print(arr[i][j]," ")
		}
		fmt.Println("\n")
	}
}

运行结果：

（3）使用方式1：先声明/定义，再赋值
语法: var数组名[大小][大小]类型
比如: var arr [2][3]int ，再赋值。
举个栗子
代码：

package main
import(
	"fmt"
)
func main(){

	var arr2 [2][3]int  //以这个为例来分析arr2在内存的布局
	arr2[1][1] = 10
	fmt.Println(arr2)

	fmt.Printf("arr2[0]的地址%p\t",&arr2[0])
	fmt.Printf("arr2[1]的地址%p\n",&arr2[1])

	fmt.Printf("arr2[0][0]的地址%p\t",&arr2[0][0])
	fmt.Printf("arr2[1][0]的地址%p\n",&arr2[1][0])
}

运行结果：

二维数组在内存的存在形式(重点)
二维数组在内存的布局
（4）使用方式2：直接初始化
声明: var数组名 [大小][大小] 类型=[大小][大小] 类型{初值…},{初值…}}
赋值(有默认值，比如 int类型的就是0)
举个栗子
代码：

package main
import(
	"fmt"
)
func main(){
	var arr3 [2][3]int = [2][3]int{{1,2,3},{4,5,6}}
	fmt.Println("arr3=",arr3)
}

运行结果：

注：二维数组在声明/定义时也对应有四种写法[和一维数组类似]

var数组名 [大小][大小]类型 = [大小][大小]类型{初值..}, {初值..}}
var数组名 [大小][大小]类型 = [...][大小]类型{{初值..}, {初值..}}
var 数组名 = [大小][大小]类型{{初值..}, {初值..}}
var 数组名 = [...][大小]类型{{初值..}, {初值..}}

（5）二维数组的遍历
双层for循环完成遍历
for-range方式完成遍历
举个栗子
代码：

package main
import(
	"fmt"
)

func main(){

	var arr3 [2][3]int = [2][3]int{{1,2,3},{4,5,6}}
	// fmt.Println("arr3=",arr3)
	// for 循环遍历
	for i := 0; i < len(arr3); i++{
		for j := 0; j < len(arr3[i]); j++{
			fmt.Printf("%v\t",arr3[i][j])
		}
		fmt.Println()
	}

	// for-range遍历
	for i ,v1 := range arr3{
		for j, v2 := range v1{
			fmt.Printf("arr3[%v][%v]=%v \t", i, j, v2)
		} 
		fmt.Println()
	}

运行结果：

（6）二维数组的应用案例
如下要求：
定义二维数组，用于保存三个班，每个班五名同学成绩，并求出每个班级平均分、以及所有班级平均分
代码

// 定义二维数组，
// 保存三个班，每个班五名同学成绩，
// 并求出每个班级平均分、以及所有班级平均分
package main
import(
	"fmt"
)
var scores [3][5]float64
func Scan_f(){
	for i := 0; i < len(scores); i++{
		for j := 0; j < len(scores[i]); j++{
			fmt.Printf("请输入第%v班的第%v同学的成绩\n", i+1, j+1)
			fmt.Scanln(&scores[i][j])
		}
	}
}

func Average(){
	tol_sum_sc := 0.0
	for i := 0; i < len(scores); i++{
		sum_sc := 0.0
		for j := 0; j < len(scores[i]); j++{
			sum_sc += scores[i][j]
		}
		fmt.Printf("第%v班级的总分为%v,平均分为%v\n", i+1, sum_sc, sum_sc / float64(len(scores[i])))
		tol_sum_sc += sum_sc
	}
	fmt.Printf("所有班级的总分为%v,平均分为%v\n", tol_sum_sc, tol_sum_sc / float64(15))
}

func main(){
	Scan_f()
	Average()
}

切片

1.为什么需要切片

先看一个需求：我们需要一个数组用于保存学生的成绩，但是学生的个数是不确定的，请问办？解决方案：–》使用切片。

2.切片的基本介绍

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

var 切片名 []类型 
比如：var a [] int

3.快速入门

举个栗子

package main
import(
    "fmt"
)
func main()  {
    // 演示切片的基本使用
    var intArr [5]int = [...]int{1, 22, 33, 66, 99}
    // 声明/ 定义一个切片
    //1. 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)
    fmt.Println("slice 的元素是 = ", slice)
    fmt.Println("slice 的元素个数 = ", len(slice))
    fmt.Println("slice 的容量 = ", cap(slice))
}

运行结果

4.切片在内存中形式

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

对上面的分析
1.slice 的确是一个引用类型
2.slice 从底层来说，其实就是一个数据结构(struct)

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

5.切片的使用

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

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

运行结果

方式2
第二种方式：通过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
    //对于切片，必须使用make
    fmt.Println(slice)
    fmt.Println("slice 的size = ", len(slice))
    fmt.Println("slice 的cap = ", cap(slice))
}

运行结果

对上面代码的小结:
（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", "mary", "jack"}
    fmt.Println("strSlice = ", strSlice)
    fmt.Println("strSlice size = ", len(strSlice))
    fmt.Println("strSlice cap = ", cap(strSlice)) 
}

运行结果

方式1和方式2的区别
方式1是直接引用数组，这个数组是事先存在的，程序员是可见的。
方式2是通过make来创建切片，make也会创建一个数组，是由切片在底层进行维护，程序员是看不见的。
make创建切片的示意图：

6.切片的遍历

切片的遍历和数组一样，也有两种方式
for 循环常规方式遍历
for-range结构遍历切片

package main
import (
    "fmt"
)
func main(){
    // for 循环遍历切片
    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 ", i, slice[i])
    }

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

运行结果

7.切片的使用的注意事项和细节讨论

（1）切片初始化时var slice = arr[startIndex:endIndex]
说明：从arr数组下标为startIndex，取到下标为endIndex的元素(不含arr[endIndex])。
（2）切片初始化时，仍然不能越界。范围在 [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[:]
（3）cap是一个内置函数，用于统计切片的容量，即最大可以存放多少个元素。
（4）切片定义完后，还不能使用，因为本身是一个空的，需要让其引用到一个数组，或者make 一个空间供切片来使用
（5）切片可以继续切片

package main
import (
    "fmt"
)
func main(){
    // for 循环遍历切片
    var arr [5]int = [...]int{10, 20, 30, 40, 50}
    fmt.Println("arr = ", arr)
    slice := arr[1:4]
    fmt.Println("slice = ", slice)
    slice2 := slice[1:2]
    slice2[0] = 100
    fmt.Println("slice2 = ", slice2)
    fmt.Println("slice = ", slice)
fmt.Println("arr = ", arr)
}

运行结果

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

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

运行结果

切片append操作的底层原理分析：
切片 append操作的本质就是对数组扩容
go底层会创建一下新的数组newArr(安装扩容后大小)
将slice原来包含的元素拷贝到新的数组newArr
slice重新引用到newArr
注意newArr是在底层来维护的，程序员不可见
（7）切片的拷贝操作
切片使用copy内置函数完成拷贝，举例说明

// 切片的拷贝操作
// 切片使用capy内置函数完成拷贝
fmt.Println()
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)

运行结果

注：
（1）copy(paral, para2)参数的数据类型是切片
（2）按照上面的代码来看，slice4和 slice5的数据空间是独立，相互不影响，也就是说 slice4[0] = 999，slice5[0]仍然是1
（8）切片是引用类型，所有在传递时，遵守引用传递机制。举个栗子
(A)

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

运行结果

(B)

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

运行结果

8.string 和slice

（1）string底层是一个byte数组，因此string 也可以进行切片处理
举个栗子

package main
import (
    "fmt"
)
func main(){
    // string 底层是一个byte数组，因此string也可以进行切片处理
    str := "helloworld"
    // 使用切片获取到world
    slice := str[5:]
    fmt.Println("slice=", slice)
}

运行结果

（2）string和切片在内存的形式，以"abcd"画出内存示意图
string和切片在内存的区别
（3）string是不可变的，也就说不能通过str[0] = 'z’方式来修改字符串
（4）如果需要修改字符串，可以先将string -> []byte/ 或者 []rune-> 修改 -> 重写转成string

//如果需要修改字符串，可以先将string -> []byte/ 
// 或者 []rune-> 修改 -> 重写转成string
arr1 := []byte(str)
arr1[0] = 'z'
str = string(arr1)
fmt.Println("str=", str)

// 细节,我们转成[]byte后,可以处理英文和数字，但是不能处理中文
// 原因是[]byte字节来处理,而一个汉字，是3个字节，因此就会出现乱码
//解决方法是将string 转成[]rune即可，因为[]rune是按字符处理，兼容汉字
arr2 := []rune(str)
arr2[0] = '北'
str = string(arr2)
fmt.Println("str=", str)

运行结果

超长待机。

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
【Golang】数组与切片-学习笔记

【Golang】(1)数组相关介绍：数组的定义、内存布局、数组的内存布局、数组的遍历....for-range的使用...(2)切片的基本介绍：切片的使用、切片的遍历、string和切片...
复制链接

扫一扫