Go语言学习笔记-07数组与切片

数组

Go语言中的数组是一个长度固定，由相同类型的元素组成

声明

只声明，不初始化，默认为数据类型的零值

var arr [个数]数据类型

声明并初始化

var arr [5]int = [5]int{} // [0,0,0,0,0]
var arr [5]int = [5]{1,2,3,4,5} // [1,2,3,4,5]

为某些位置设置值，其余保持为0

var arr [5]int = [5]int{3:9} // [0,1,3,9,0] 为第4个元素设置值，其余保持为0

使用...自动设置元素个数

var arr = [...]{1,2,3,4,5}

使用...设置稀疏数组

var arr = [...]{49:50} // 设置第50个元素值为50，其余的为0

多维数组声明

var arr [2][3]int // 声明了一个2行3列的数组

可以拆开来看，看作2个[3]int

多为数组初始化

// 第2维以后的类型申明可写可不写
var arr = [2][3]int{[3]int{1,2,3},[3]int{4,5,6}}
var arr = [2][3]int{{1,2,3},{4,5,6}}

ch07/main.go

package main

import "fmt"

func main() {
    // 声明不初始化，默认为数据类型的零值
    var arr1 [5]int
    fmt.Println("arr1", arr1)

    // 声明并初始化
    var arr2 [5]int = [5]int{1, 2, 3, 4, 5}
    fmt.Println("arr2", arr2)

    // 为某些位置设置值，其余保持为0
    var arr3 [5]int = [5]int{3: 9}
    fmt.Println("arr4", arr3)

    // 使用...自动设置元素个数
    var arr4 = [...]int{4: 5}
    fmt.Println("arr4", arr4)

    // 多维数组
    var arr5 = [2][3]int{[3]int{1, 2, 3}, {4, 5, 6}}
    fmt.Println("arr5", arr5)
}

输出

arr1 [0 0 0 0 0]
arr2 [1 2 3 4 5]      
arr4 [0 0 0 9 0]      
arr4 [0 0 0 0 5]      
arr5 [[1 2 3] [4 5 6]]

获取数组的长度

使用内置函数len获取

package main

import "fmt"

func main() {
    var arr = [5]int{}
    fmt.Printf("arr的长度为%d", len(arr))
}

输出

arr的长度为5

读取数组的值

使用下标获取数组的值，下标从0开始，不支持负数获取

package main

import "fmt"

func main() {
    var arr = [5]int{1, 2, 3, 4, 5}

    fmt.Printf("arr[1]=%d", arr[1])
}

切片

切片与数组很相像，只是它的长度不是固定的，随着元素的增多动态地变化

切片在go中的底层实现，是由一个指向底层数组的指针，切片的长度（切片元素的个位）以及底层数组的长度（切片的最大容量）三部分组成

可以通过内置函数len获取切片长度，通过内置函数cap获取切片容量

ch07/lenandcap/main.go

package main

import "fmt"

func main() {
    var slice = []int{1, 2, 3, 4, 5}
    fmt.Printf("slice 的长度为：%d,容量为：%d", len(slice), cap(slice))
}

输出

slice 的长度为：5,容量为：5

声明

var slice []数据类型

声明并初始化，长度和容量相等

var slice = []int{1,2,3,4,5} // [1,2,3,4,5] len=5 cap=5

只声明不初始化，长度和容量都为0，切片的默认值为nil

var slice []int // []int(nil) len=0 cap=0

ch07/sliceinit/main.go

package main

import "fmt"

func main() {
    var slice1 = []int{1, 2, 3, 4, 5}
    var slice2 []int
    fmt.Printf("slice1 %v 长度为：%d，容量为：%d\n", slice1, len(slice1), cap(slice1))
    fmt.Printf("slice2 %#v 长度为：%d，容量为：%d\n", slice2, len(slice2), cap(slice2))
}

输出

slice1 [1 2 3 4 5] 长度为：5，容量为：5
slice2 []int(nil) 长度为：0，容量为：0

通过make函数创建切片

var slice = make([]数据类型，长度，容量)

ch07/makeslice/main.go

package main

import "fmt"

func main() {
    slice := make([]int, 5)
    slice2 := make([]int, 5, 10)

    fmt.Printf("slice %v 长度：%d，容量：%d\n", slice, len(slice), cap(slice))
    fmt.Printf("slice2 %v 长度：%d，容量：%d\n", slice2, len(slice2), cap(slice2))
}

输出

slice [0 0 0 0 0] 长度：5，容量：5
slice2 [0 0 0 0 0] 长度：5，容量：10

通过数组创建切片

可以通过array[low:high:max]形式从一个数组中获取到一个切片，此时切片起始元素是数组下标为low的元素，切片的长度为high-low，切片的容量为max-low，切片的底层数组就是就是array，换言之，修改切片的值，array同样也会受到影响

array[low:high]，max省略时，max的默认值为数组的长度

array[:]可以得到一个和arr元素一样的切片

ch07/arraytoslice/main.go

package main

import "fmt"

func main() {
    arr := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    slice1 := arr[2:7:8] // [2,3,4,5,6]
    slice2 := arr[:]     // [1,2,3,4,5,6,7,8,9,10]
    slice3 := arr[3:4]   // [4]

    fmt.Printf("slice1 %v，长度：%d，容量：%d\n", slice1, len(slice1), cap(slice1))
    fmt.Printf("slice2 %v，长度：%d，容量：%d\n", slice2, len(slice2), cap(slice2))
    fmt.Printf("slice3 %v，长度：%d，容量：%d\n", slice3, len(slice3), cap(slice3))

    // 修改切片的第4个元素，及把6改为12
    slice1[3] = 12

    // 原数组arr发生改变
    fmt.Printf("修改后slice1 %v，长度：%d，容量：%d\n", slice1, len(slice1), cap(slice1))
    fmt.Printf("修改后slice2 %v，长度：%d，容量：%d\n", slice2, len(slice2), cap(slice2))
    fmt.Printf("修改后arr %v\n", arr)

}

输出

slice1 [3 4 5 6 7]，长度：5，容量：6
slice2 [1 2 3 4 5 6 7 8 9 10]，长度：10，容量：10       
slice3 [4]，长度：1，容量：7                            
修改后slice1 [3 4 5 12 7]，长度：5，容量：6             
修改后slice2 [1 2 3 4 5 12 7 8 9 10]，长度：10，容量：10
修改后arr [1 2 3 4 5 12 7 8 9 10]