Golang 速成 | slice 和 map¶

slice 切片¶

Go 语言切片是对数组的抽象。

Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片 ("动态数组")，与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

定义切片¶

你可以声明一个未指定大小的数组来定义切片：

Go
var identifier []type

切片不需要说明长度。或使用 make() 函数来创建切片：

Go
var slice1 []type = make([]type, len)

//也可以简写为

slice1 := make([]type, len)

也可以指定容量，其中 capacity (容量) 为可选参数：

Go
//这里 len 是数组的长度并且也是切片的初始长度。
make([]T, length, capacity)

切片初始化¶

直接初始化切片，[] 表示是切片类型，{1,2,3} 初始化值依次是1,2,3，其 cap = len = 3 ：

Go
s := []int{1, 2, 3}

初始化切片 s ，是数组 arr 的引用：

Go
s := arr[:]

//s := arr[startIndex:endIndex]
//将 arr 中从下标 startIndex 到 endIndex-1 下的元素创建为一个新的切片
//缺省 startIndex 时将表示从 arr 的第一个元素开始
//缺省 endIndex 时将表示一直到 arr 的最后一个元素

通过内置函数 make() 初始化切片 s ，[]int 标识为其元素类型为 int 的切片：

Go
s := make([]int, len, cap)

len() 和 cap() 函数¶

切片是可索引的，并且可以由 len() 方法获取长度。

切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少。

以下为具体实例：

Go
package main

import "fmt"

func main() {
   var numbers = make([]int,3,5)

   printSlice(numbers)
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Output
1	`len=3 cap=5 slice=[0 0 0]`

空 (nil) 切片¶

一个切片在未初始化之前默认为 nil，长度为 0，实例如下：

Go
package main

import "fmt"

func main() {
   var numbers []int

   printSlice(numbers)

   if(numbers == nil){
      fmt.Printf("切片是空的")
   }
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Output
1 2	`len=0 cap=0 slice=[] 切片是空的`

切片截取¶

可以通过设置下限及上限来设置截取切片 [lower-bound:upper-bound] ，实例如下：

Go
package main

import "fmt"

func main() {
   /* 创建切片 */
   numbers := []int{0,1,2,3,4,5,6,7,8}   
   printSlice(numbers)

   /* 打印原始切片 */
   fmt.Println("numbers ==", numbers)

   /* 打印子切片从索引1(包含) 到索引4(不包含)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])

   /* 默认下限为 0*/
   fmt.Println("numbers[:3] ==", numbers[:3])

   /* 默认上限为 len(s)*/
   fmt.Println("numbers[4:] ==", numbers[4:])

   numbers1 := make([]int,0,5)
   printSlice(numbers1)

   /* 打印子切片从索引  0(包含) 到索引 2(不包含) */
   number2 := numbers[:2]
   printSlice(number2)

   /* 打印子切片从索引 2(包含) 到索引 5(不包含) */
   number3 := numbers[2:5]
   printSlice(number3)

}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Output

len=9 cap=9 slice=[0 1 2 3 4 5 6 7 8]
numbers == [0 1 2 3 4 5 6 7 8]
numbers[1:4] == [1 2 3]
numbers[:3] == [0 1 2]
numbers[4:] == [4 5 6 7 8]
len=0 cap=5 slice=[]
len=2 cap=9 slice=[0 1]
len=3 cap=7 slice=[2 3 4]

append() 和 copy() 函数¶

如果想增加切片的容量，我们必须创建一个新的更大的切片并把原分片的内容都拷贝过来。

下面的代码描述了从拷贝切片的 copy 方法和向切片追加新元素的 append 方法。

Go
package main


import "fmt"


func main() {
   var numbers []int
   printSlice(numbers)


   /* 允许追加空切片 */
   numbers = append(numbers, 0)
   printSlice(numbers)


   /* 向切片添加一个元素 */
   numbers = append(numbers, 1)
   printSlice(numbers)


   /* 同时添加多个元素 */
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)


   /* 创建切片 numbers1 是之前切片的两倍容量*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)


   /* 拷贝 numbers 的内容到 numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}


func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Output
1 2 3 4 5	`len=0 cap=0 slice=[] len=1 cap=1 slice=[0] len=2 cap=2 slice=[0 1] len=5 cap=6 slice=[0 1 2 3 4] len=5 cap=12 slice=[0 1 2 3 4]`

map¶

map 和 slice 类似，只不过是数据结构不同，map存储是无序的，遍历 map 时返回的键值对的顺序是不确定的，下面是 map 的一些声明方式：

Go
package main


import (
    "fmt"
)


func changeValue(m_map map[string]string) {
    //map 为引用传递
    m_map["newKey"] = "newValue"
}

func main() {
    //第一种声明
    var test1 map[string]string
    //在使用map前，需要先make，make的作用就是给map分配数据空间
    test1 = make(map[string]string, 10) 
    test1["one"] = "php"
    test1["two"] = "golang"
    test1["three"] = "java"
    fmt.Println(test1) //map[two:golang three:java one:php]


    //第二种声明
    test2 := make(map[string]string)
    test2["one"] = "php"
    test2["two"] = "golang"
    test2["three"] = "java"
    fmt.Println(test2) //map[one:php two:golang three:java]

    //第三种声明
    test3 := map[string]string{
        "one" : "php",
        "two" : "golang",
        "three" : "java",
    }
    fmt.Println(test3) //map[one:php two:golang three:java]



    language := make(map[string]map[string]string)
    language["php"] = make(map[string]string, 2)
    language["php"]["id"] = "1"
    language["php"]["desc"] = "php是世界上最美的语言"
    language["golang"] = make(map[string]string, 2)
    language["golang"]["id"] = "2"
    language["golang"]["desc"] = "golang抗并发非常good"

    fmt.Println(language) //map[php:map[id:1 desc:php是世界上最美的语言] golang:map[id:2 desc:golang抗并发非常good]]


    //增删改查
    // val, key := language["php"]  //查找是否有php这个子元素
    // if key {
    //     fmt.Printf("%v", val)
    // } else {
    //     fmt.Printf("no");
    // }

    //language["php"]["id"] = "3" //修改了php子元素的id值
    //language["php"]["nickname"] = "啪啪啪" //增加php元素里的nickname值
    //delete(language, "php")  //删除了php子元素
    fmt.Println(language)
}

源码¶

slice¶

Go
package main  

import "fmt"  

func printArray(myArray [4]int) {  
    //值拷贝  

    for index, value := range myArray {  
       fmt.Println("index = ", index, ", value = ", value)  
    }  

    myArray[0] = 111  
}  


func main() {  
    //固定长度的数组  
    var myArray1 [10]int  

    myArray2 := [10]int{1,2,3,4}  
    myArray3 := [4]int{11,22,33,44}  

    //for i := 0; i < 10; i++ {  
    for i := 0; i < len(myArray1); i++ {  
       fmt.Println(myArray1[i])     
    }  

    for index, value := range myArray2 {  
       fmt.Println("index = ", index, ", value = ", value)  
    }  

    //查看数组的数据类型  
    fmt.Printf("myArray1 types = %T\n", myArray1)  
    fmt.Printf("myArray2 types = %T\n", myArray2)  
    fmt.Printf("myArray3 types = %T\n", myArray3)  

    printArray(myArray3)  
    fmt.Println(" ------ ")  
    for index, value := range myArray3 {  
       fmt.Println("index = ", index, ", value = ", value)  
    }  
}

Go
package main  

import "fmt"  

func printArray(myArray []int) {  
    //引用传递  
    // _ 表示匿名的变量  
    for _, value := range myArray {  
       fmt.Println("value = ", value)  
    }  

    myArray[0] = 100  
}  

func main() {  
    myArray := []int{1,2,3,4} // 动态数组，切片 slice  
    fmt.Printf("myArray type is %T\n", myArray)  

    printArray(myArray)  

    fmt.Println(" ==== ")  

    for _, value := range myArray {  
       fmt.Println("value = ", value)  
    }  
}

Go
package main  

import "fmt"  

func main() {  
    //声明slice1是一个切片，并且初始化，默认值是1，2，3。 长度len是3  
    //slice1 := []int{1, 2, 3}  
    //声明slice1是一个切片，但是并没有给slice分配空间  
    var slice1 []int  
    //slice1 = make([]int, 3) //开辟3个空间 ，默认值是0  

    //声明slice1是一个切片，同时给slice分配空间，3个空间，初始化值是0  
    //var slice1 []int = make([]int, 3)  
    //声明slice1是一个切片，同时给slice分配空间，3个空间，初始化值是0, 通过:=推导出slice是一个切片  
    //slice1 := make([]int, 3)  

    fmt.Printf("len = %d, slice = %v\n", len(slice1), slice1)  

    //判断一个silce是否为0  
    if slice1 == nil {  
       fmt.Println("slice1 是一个空切片")  
    } else {  
       fmt.Println("slice1 是有空间的")  
    }  
}

Go
package main  

import "fmt"  

func main() {  
    var numbers = make([]int, 3, 5)  

    fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers), cap(numbers), numbers)  

    //向numbers切片追加一个元素1, numbers len = 4， [0,0,0,1], cap = 5    numbers = append(numbers, 1)  

    fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers), cap(numbers), numbers)  

    //向numbers切片追加一个元素2, numbers len = 5， [0,0,0,1,2], cap = 5    numbers = append(numbers, 2)  

    fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers), cap(numbers), numbers)  

    //向一个容量cap已经满的slice 追加元素，  
    numbers = append(numbers, 3)  

    fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers), cap(numbers), numbers)  

    fmt.Println("-=-------")  
    var numbers2 = make([]int, 3)  
    fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers2), cap(numbers2), numbers2)  
    numbers2 = append(numbers2, 1)  
    fmt.Printf("len = %d, cap = %d, slice = %v\n", len(numbers2), cap(numbers2), numbers2)  
}

Go
package main  

import "fmt"  

func main() {  
    s := []int{1, 2, 3} //len = 3, cap = 3, [1,2,3]  

    //[0, 2)    s1 := s[0:2] // [1, 2]  

    fmt.Println(s1)  

    s1[0] = 100  

    fmt.Println(s)  
    fmt.Println(s1)  

    //copy 可以将底层数组的slice一起进行拷贝  
    s2 := make([]int, 3) //s2 = [0,0,0]  

    //将s中的值 依次拷贝到s2中  
    copy(s2, s)  
    fmt.Println(s2)  

}

map¶

Go
package main  

import "fmt"  

func main() {  
    //===> 第一种声明方式  

    //声明myMap1是一种map类型 key是string， value是string  
    var myMap1 map[string]string  
    if myMap1 == nil {  
       fmt.Println("myMap1 是一个空map")  
    }  

    //在使用map前， 需要先用make给map分配数据空间  
    myMap1 = make(map[string]string, 10)  

    myMap1["one"] = "java"  
    myMap1["two"] = "c++"  
    myMap1["three"] = "python"  

    fmt.Println(myMap1)  

    //===> 第二种声明方式  
    myMap2 := make(map[int]string)  
    myMap2[1] = "java"  
    myMap2[2] = "c++"  
    myMap2[3] = "python"  

    fmt.Println(myMap2)  

    //===> 第三种声明方式  
    myMap3 := map[string]string{  
       "one":   "php",  
       "two":   "c++",  
       "three": "python",  
    }  
    fmt.Println(myMap3)  
}

Go
package main  

import "fmt"  

func printMap(cityMap map[string]string) {  
    //cityMap 是一个引用传递  
    for key, value := range cityMap {  
       fmt.Println("key = ", key)  
       fmt.Println("value = ", value)  
    }  
}  

func ChangeValue(cityMap map[string]string) {  
    cityMap["England"] = "London"  
}  

func main() {  
    cityMap := make(map[string]string)  

    //添加  
    cityMap["China"] = "Beijing"  
    cityMap["Japan"] = "Tokyo"  
    cityMap["USA"] = "NewYork"  

    //遍历  
    printMap(cityMap)  

    //删除  
    delete(cityMap, "China")  

    //修改  
    cityMap["USA"] = "DC"  
    ChangeValue(cityMap)  

    fmt.Println("-------")  

    //遍历  
    printMap(cityMap)  
}