GO语言的数组array与切片slice详解（golang slice和数组）

GO语言数组(array)

在GO语言中，数组是用于存储相同数据类型的集合，数组长度必须是一个常量表达式，且是一个非负数
GO语言中的数组是一种值类型，下文会介绍

GO语言数组定义的格式

var 数组名称 [数组长度]数组类型
例：
var arr [3]int

输出为：

[0 0 0]

int0string

GO语言数组的赋值操作

// 第一种赋值操作
var arr = [3]int{1,2,3} //直接将值初始化，不同的类似初始化值不相同
// 第二种赋值操作
var arr [3]int  // 初始化数组变量
arr[1] = 1      // 给数组的下标赋值
// 第三种赋值操作
var arr  = [3]string{1:"one",2:"two"}
// 一般常用的就这三种，其它方式都是一些变相的操作，这里不做介绍

len(arr)-1

先来个练习加深下前面所说的影响，将一个int型数组的值全部乘以2

package main
import "fmt"
func main(){
    var arrs = [5]int{1, 2, 3, 4, 5}
    for i, v := range arrs {
        arrs[i] = v * 2
        fmt.Printf("index is %d,value is %d \n", i, arrs[i])
    }
}

输出为

index is 0,value is 2 
index is 1,value is 4 
index is 2,value is 6 
index is 3,value is 8 
index is 4,value is 10

GO语言数组的值类型

new()

var arr1 = new([5]int)
var arr2 [5]int

输出分别为

&[0 0 0 0 0]
[0 0 0 0 0]

GO语言多维数组

var arr1 [3][5]int[[0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0]]

做个小题目：定义一个空的二维数组，将二维数组的值与索引一至

package main
import "fmt"
func main{
var arr_more [5][5]int
    fmt.Println(arr_more)
    for i, x := range arr_more {
        for i1, _ := range x {
            arr_more[i][i1] = i1
        }
    }
    fmt.Println(arr_more)
}

输出

初始化数组：
[[0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0]]
值与索引对应
[[0 1 2 3 4] [0 1 2 3 4] [0 1 2 3 4] [0 1 2 3 4] [0 1 2 3 4]]

数组的处理还有很多别的形式，等着你在实际工作中的发现与总结

GO语言切片(slice)

len()cap()

GO语言切片声明格式

var 声明变量 []变量类型

和声明数组非常相似，切片的声明是不需要指定数组长度，因为切片的长度是可变的(等会介绍)

nil0

package main
import "fmt"
func main{
    var arr = [5]int{1, 2, 3, 4, 5}
    var slice []int
    fmt.Printf("初始化切片默认 %d\n", slice)
    var slice1 []int = arr[:]
    fmt.Printf("切片复制数组(简写) %d\n", slice1)
    var slice2 []int = arr[0:2]
    fmt.Printf("切片获得数组0-1的下标 %d\n", slice2)
    var slice3 []int = arr[2:5]
    fmt.Printf("切片获得数组2-4的下标 %d\n", slice3)
}

输出

初始化切片默认 []
切片复制数组(简写) [1 2 3 4 5]
切片获得数组0-1的下标 [1 2]
切片获得数组2-4的下标 [3 4 5]

[:3][3:]

注意绝对不要用指针指向 slice。切片本身已经是一个引用类型，所以它本身就是一个指针!!

GO语言用make()创建一个切片

make()

var slice []int = make([]type,len,cap)
var 切片变量 []切片类型 = make([]数组类型，数组长度，最大长度) cap是可选参数

通过一个例子来说明make的使用

package main
import "fmt"
func main() {
    var slice1 []int = make([]int, 5)
    for i := 0; i < len(slice1); i++ {
        slice1[i] = 5 * i
        fmt.Printf("Slice at %d is %d\n", i, slice1[i])
    }
    fmt.Printf("\nThe length of slice1 is %d\n", len(slice1))
    fmt.Printf("The capacity of slice1 is %d\n", cap(slice1))
}

输出

Slice at 0 is 0  
Slice at 1 is 5  
Slice at 2 is 10  
Slice at 3 is 15  
Slice at 4 is 20

The length of slice1 is 5  
The capacity of slice1 is 5

var slice[]int = arr[:]

GO语言切片的复制与追加

copy()append()

package main
import "fmt"
func main(){
sl_from := []int{1, 2, 3}
    sl_to := make([]int, 10)

    n1 := copy(sl_to, sl_from)
    fmt.Println(sl_to)
    fmt.Printf("Copied %d elements\n", n1) // n == 3

    sl3 := []int{1, 2, 3}
    sl3 = append(sl3, 4, 5, 6)
    fmt.Println(sl3)
}

输出：

[1 2 3 0 0 0 0 0 0 0]
Copied 3 elements
[1 2 3 4 5 6]

复制与增加需要注意的：

是将后面的元素或切片追加到前面
必须是相同的元素类型
当容量不足时，会生成一个新的地址来保证新增加的元素
如果上面的条件都满足，一般来说都会返回成功，除非内存耗尽了(无解)

小记：

当然切片还有更多的细节及处理方式，完整版最好还是去看官方提供的文档，本篇重点介绍了GO的数组与切片

更多关于GO语言的数组array与切片slice知识请查看下面的相关链接