Go语言学习笔记05--切片slice与字典map

1.数组案例
//统计输入20个字符中字母出现的个数案例
func checkNumFromInput(){
    inputCharArr := [20]byte{},checkNum := [26]byte{}
    //输入
    for i:=0; i<20; i++{
        fmt.Scanf("%c",&inputCharArr[i]);
    }
    //核验
    for j:=0; j<20; j++{
        checkNum[inputCharArr[j]-'a']++;
    }
    //输出
    for k:=0; k<len(checkNum); k++{
        if checkNum[k] != 0{
            fmt.Printf("字母%c，出现的次数是%d次\n",'a'+k,checkNum[k]);
        }
    }
}
//模拟双色球摇号，6个不重复（1～33）红球，和一个蓝球
func getTicketArray () [7]int{
    finalArr := [7]int{}
    rand.Seed(time.Now().UnixNano())
    //一轮一个随机红球
    for i:=0; i<6; i++{
        temp := rand.Intn(33)+1,flag := true
        //判重
        for j:=0; j<i; j++{
            if temp == finalArr[j]{
                i--,flag = false
                break
            }
        }
        //判是否加
        if(flag){
            finalArr[i] = temp
        }
    }
    //随机蓝球
    finalArr[6] = rand.Intn(33)+1
    return finalArr
}
2.二维数组
    go语言中的二维数组和传统c语言中的二维数组大同小异，还是需要注意声明和赋值的语法就行
    至于数组的特性，仍旧是第一维度表示行，第二维度表示列。数组访问也仍旧需要行列两个维度的参数。
    eg：
        //var arr [3][5]int = [3][5]int{ {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7}};
        var arr [3][5]int = [3][5]int{};
        for i:=0; i<3; i++{
            for j:=0; j<5; j++{
                arr[i][j] = rand.Intn(10);
            }
        }
        fmt.Println(arr);//[[1 7 7 9 1] [8 5 0 6 0] [4 1 2 9 8]]
        fmt.Println(arr[0][1]);//7
3.切片slice
    与传统语言相比，go语言中的数组是一个长度固定的固有结构，因此对于数组的所有操作是不会影响到原数组的。
    这样统一的规定虽然避免了很多情况下对于原数组的误操作，但是数组大多数情况下是有必要发生修改的，
    因此go语言提出了切片(Slice)的概念，切片从某种意义上来说可以认为是数组的一种可修改的表现方式。
        var 切片名 []数据类型 = []数据类型{...}
    eg：
        var slice1 []int = []int{1,2,3,4,5,...}
    如果单独查看切片的语法可能会觉得有些奇怪，那么直接将切片的语法和数组的语法相对比结合就能看到些端倪
    eg：
        var slice1 []int = []int{1,2,3,4,5,...}
        var array [5]int = [5]int{1,2,3,4,5}
    非常明显看到，切片可以认为其实就是长度不固定的数组。其定义语法与数组定义方式几乎相同。
    ps：
        数组数据存栈区，切片数据存堆区
    (1)切片的操作
        1)make方法与切片的自动推导类型
            如果每一次定义切片都采用标准声明方式，会显得代码十分冗余，因此提出了make方式
                切片名 := make(切片类型，切片长度);
            eg:
                slice2 := make([]int, 5);
                slice2[0] = 10;
                slice2[1] = 11;
                ...
            需要说明的是这里的长度并不是说切片就只能有5个长度，而是暂时只分配5个容量
            之后会随着需求不断对切片进行容量扩充。
            ps:切片长度，即切片中实际存储了内容的部分
            ps:切片容量，是切片中用于系统分配存储空间的标尺
        2)append方法与切片扩展
            前面提到过切片是一种类似于可以被修改的数组，因此go语言提供了append方法对切片进行扩容
                切片名 = append(切片名,扩展内容1,扩展内容2,...)
            eg：
                slice3 := []int{1,2,3,4,5};
                fmt.Println(slice3);//[1,2,3,4,5]
                slice3 = append(slice3,11,22,33,44,55);
                fmt.Println(slice3);//[1,2,3,4,5,11,22,33,44,55]
            ps：go语言中的append方法其意义为【扩容】，而不是修改，
                因此append扩充的切片内容会在已知内容之后
                eg：
                    slice4 := make([]int, 5);//[0,0,0,0,0]
                    slice4 = append(slice4,1,2,3);//[0,0,0,0,0,1,2,3]
        3)cap方法-切片容量与切片长度
            cap(切片名)方法能够返回切片容量
            len(切片名)方法能够返回切片长度
            其区别就是：
                ·容量必然大于等于长度，因为系统必须为内容分配出足够的存储空间。
                ·只要添加内容长度必然增加，而容量却不一定增加
                ·如果长度超过了容量，切片才会对容量进行扩展，而且每次扩展都是上次的倍数。
                eg:
                    slice5 := []int{0,0,0,0,0};            //[0,0,0,0,0]
                    fmt.Printf("长度：%d",len(slice5));    //5
                    fmt.Printf("容量：%d",cap(slice5));    //5
                    slice5 = append(slice5, 1,2,3);        //[0,0,0,0,0,1,2,3]
                    fmt.Printf("长度：%d",len(slice5));    //8
                    fmt.Printf("容量：%d",cap(slice5));    //10
                    slice5