go中数组与切片

为什么需要数组

我们来看一个问题:

  一个养鸡场有 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
    avgWeight := fmt.Sprintf("%.2f", totalWeight / 6)
    fmt.Printf("totalWeight=%v avgWeight=%v\n", totalWeight, avgWeight)
}

运行结果如下:

对上面的代码说明:

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

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

数组介绍

  数组可以存放多个同一类型数据。数组也是一种数据类型,在 Go 中,数组是值类型。
 
数组的快速入门
我们使用数组的方法来解决养鸡场的问题,代码如下:
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、而且方法代码更加清晰,也容易扩展。

数组的定义和内存布局

 

数组的定义

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

数组在内存布局

我们先声明一个数组:

package main

import "fmt"

func main()  {
    var intArr [3]int //int占8个字节
    //当我们定义完数组后,其实数组的各个元素有默认值 0
    fmt.Println(intArr)
}

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

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

3、数组的各个元素的地址间隔是依据数组的类型决定,比如 int64 -> 8 int32->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])
}

运行结果如下:

数组的使用

访问数组元素

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

案例:我们有一个需求,从终端循环输入 5 个成绩,保存到 float64 数组,并输出.

代码如下:

package main

import "fmt"

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

    for i := 0; i < len(score); i++ {
        fmt.Println("请输入第%d个元素的值\n",i+1)
        fmt.Scanln(&score[i])
    }

    // 变量数组打印
    for i := 0; i < len(score); i++ {
        fmt.Printf("score[%d]=%v\n", i, score[i])
    }
}

运行结果如下:

数组的使用方式2:

按照上面的方法每次都要确保提供的初始值和数组长度一致,一般情况下我们可以让编译器根据初始值的个数自行推断数组的长度,例如:

package main

import (
    "fmt"
)

func main()  {
    var testArray [3]int
    var numArray = [...]int{1, 2}
    var nameArray = [...]string{"bingle1", "bingle2", "bingle3"}
    fmt.Println(testArray)                          //[0 0 0]
    fmt.Println(numArray)                           //[1 2]
    fmt.Printf("type of numArray:%T\n", numArray)   //type of numArray:[2]int
    fmt.Println(nameArray)                          //[bingle1 bingle2 bingle3]
    fmt.Printf("type of nameArray:%T\n", nameArray) //type of nameArray:[3]string
}

结果如下:

数组使用方式3:

我们还可以使用指定索引值的方式来初始化数组,例如:

package main

import (
    "fmt"
)

func main()  {
    a := [...]int{1: 1, 3: 5}
    fmt.Println(a)                  // [0 1 0 5]
    fmt.Printf("type of a:%T\n", a) //type of a:[4]int
}

数组的遍历

1、for循环,上面的代码有

2、for-range遍历(类似C#里面的foreach,JavaScript中for-in)

代码如下:

    // 变量数组打印
    //for i := 0; i < len(score); i++ {
    //    fmt.Printf("score[%d]=%v\n", i, score[i])
    //}
    for k, v := range score {
        fmt.Printf("i=%v v=%v\n", k , v)
        fmt.Printf("heroes[%d]=%v\n", k, score[k])
    }

执行结果如下:

 说明:

  1、第一个返回值 k 是数组的下标

  2、第二个 v 是该下标位置的值

  3、他们都仅在for循环内部可见的局部变量

  4、遍历数组元素的时候,如果不想使用下标 k,可以把下标 k 换成_

  5、k 和 v名称是不固定的,即程序员可以自行指定。有时候也用index 和 value 

数组使用的注意事项与细节

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

  2、var arr []int 这时 arr 就是一个 slice 切片

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

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

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

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

    bool 数组: 默认值为 false

  5、使用数组的步骤:

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

  6、数组的下标是从 0 开始的,(这点很好理解,程序员的世界,是从 0 开始的)

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

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

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

package main

import "fmt"

func test(arr *[3]int)  {
    (*arr)[2]=88
}

func main()  {
    arr := [3]int{11,22,33}
    test(&arr)
    fmt.Println(arr)
}

执行结果如下:将最后一个元素的值,改成了88

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

下面看一个数组的使用案例

要求:随机生成五个数,并将其反转打印

我们的思路:

  1、随机生成五个数 , rand.Intn() 函数  

  2、当我们得到随机数后,就放到一个数组 int数组

  3、反转打印 , 交换的次数是  len / 2, 倒数第一个和第一个元素交换, 倒数第2个和第2个元素交换

代码如下:

package main

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

func main()  {
    var intArr [5]int
    len := len(intArr)
    // 为了每次生成的随机数不一样,我们需要给一个seed值
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < len; i++ {
        intArr[i] = rand.Intn(100) // 0<=n<100 ==>[0,100)
    }
    fmt.Println("交换前~=", intArr)

    // 反转打印 , 交换的次数是  len / 2,
    // 倒数第一个和第一个元素交换, 倒数第2个和第2个元素交换
    temp := 0 // 做一个临时变量

    for i := 0; i < len / 2; i++ {
        temp = intArr[len - 1 - i]
        intArr[len - 1 - i] = intArr[i]
        intArr[i] = temp
    }
    fmt.Println("交换后~=", intArr)
}

运行下结果,如下:

 

切片

  

切片的基本介绍

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

快速入门

下面看一个切片的基本使用

package main

import (
    "fmt"
)

func main()  {
    var intArr [5]int = [...]int{1, 22, 33, 66, 99}
    //声明/定义一个切片
    slice := intArr[1:3]
    fmt.Println("intArr=", intArr)
    fmt.Println("slice 的元素是 =", slice) //  22, 33
    fmt.Println("slice 的元素个数 =", len(slice)) // 2
    fmt.Println("slice 的容量 =", cap(slice)) // 切片的容量是可以动态变化
}

运行结果如下:

为什么slice 的容量是 4呢?

我们来看一下,切片的本质:

切片的本质就是对底层数组的封装,它包含了三个信息:底层数组的指针、切片的长度(len)和切片的容量(cap)。

举个例子,现在有一个数组a := [8]int{0, 1, 2, 3, 4, 5, 6, 7},切片s1 := a[:5],相应示意图如下。

 

切片s2 := a[3:6],相应示意图如下:

切片的使用

方式1:定义一个切片,然后让切片去引用一个已经创建好的数组,

func main()  {
    var intArr [5]int = [...]int{1, 22, 33, 66, 99}
    //声明/定义一个切片
    slice := intArr[1:3]
    fmt.Println("intArr=", intArr)
    fmt.Println("slice 的元素是 =", slice) //  22, 33
    fmt.Println("slice 的元素个数 =", len(slice)) // 2
    fmt.Println("slice 的容量 =", cap(slice)) // 切片的容量是可以动态变化
}

 

 

 

1、slice是一个引用类型

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

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

方式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] =30
    fmt.Println(slice)
    fmt.Println("slice 的 size = ",len(slice))
    fmt.Println("slice 的 cap = ",cap(slice))
    fmt.Printf("slice 的 地址 = %p \n",&slice)
    fmt.Printf("slice 的 ptr = %p ",slice)
}

执行结果如下:

 

对上面代码小结:

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

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

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

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

package main

import "fmt"

func main()  {
    var strSlice []string = []string{"bingle1","bingle2","bingle3"}
    fmt.Println("strSlice = ",strSlice)
    fmt.Println("strSlice size = ",len(strSlice)) // 3
    fmt.Println("strSlice cap = ",cap(strSlice)) // ?
}

执行结果:

 

方式 1 和方式 2 的区别:

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

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

  make创建切片的示意图:

 

 

切片的遍历

1、for 循环常规方式遍历

2、for-range 结构遍历切片

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

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()  {
    var arr [5]int = [...]int{10,20,30,40,50}
    fmt.Println(arr)
    slice := arr[1:4]
    for i := 0; i < len(slice); i++ {
        fmt.Printf("slice[%v] = %v ;",i,slice[i])
    }
    slice2 := slice[1:2]
    slice2[0] = 100
    fmt.Println("slice2 = ",slice2)
    fmt.Println("slice = ",slice)
    fmt.Println("arr = ",arr)
}

运行结果如下:

 

slice2[0] = 100之后,为什么相应的 arr 和slice 的值都变成了100?

  因为,arr、slice、slice2 指向的数据空间是同一个

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

package main

import "fmt"

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

    // 通过append将切片slice追加给slice
    slice = append(slice,slice...)
    fmt.Println(slice)
}

执行结果如下:

 

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

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

7、切片的拷贝操作

切片使用 copy 内置函数完成拷贝,代码如下:
package main

import "fmt"

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

 

对上述代码说明:

  1、copy(para1, para2) 参数的数据类型是切片

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

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

 

string和slice

1、string 底层是一个 byte 数组,因此 string 也可以进行切片处理
下面看一段代码:
package main

import "fmt"

func main()  {
    str := "binglezhendeyoudianyisiao"
    slice := str[6:]
    fmt.Println(slice)
}

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

 

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

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

import "fmt"

func main()  {
    str := "binglezhendeyoudianyisiao"
    arr := []byte(str)
    arr[0]='z'
    str = string(arr)
    fmt.Println("str = ",str)
}

下面我们来实现一个斐波那锲函数:

 

package main

import "fmt"

func fbn(n int) []uint64 {
    if n <= 0 {
        return nil
    }
    // 声明一个切片,切片大小为 n
    fbnSlice := make([]uint64, n)
    if n == 1 {
        fbnSlice[0] = 1
        return fbnSlice
    }
    if n == 2 {
        fbnSlice[0] = 1
        fbnSlice[1] = 1
        return fbnSlice
    }
    fbnSlice[0] = 1
    fbnSlice[1] = 1
    for i := 2; i < n; i++ {
        fbnSlice[i] = fbnSlice[i-1] + fbnSlice[i-2]
    }
    return fbnSlice
}

func main() {

    arr := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    fmt.Println(arr)

    fbnSlice := fbn(20)
    fmt.Println("fbnSlice  = ", fbnSlice)
}

posted @ 2021-04-13 11:04  冰乐  阅读(147)  评论(0编辑  收藏  举报