数组 切片 以及map

package main
​
import (
    "fmt"
    "sort"
)
​
func main() {
    //定义数组 长度定义之后 无法更改
    var arr [3]int     //默认3个0
    var arr2 [3]string //默认3个""
    //赋值
    arr[0] = 1
    arr[1] = 2
    arr[2] = 3
    arr2[0] = "a"
    arr2[1] = "b"
    arr2[2] = "c"
    arr3 := [3]int{1, 2, 3}            //使用花括号定义数组并赋值
    arr4 := [...]int{1, 2, 3}          //省略长度定义数组并赋值 系统自动推断长度
    arr5 := [...]int{0: 1, 1: 2, 5: 3} //以最后一个下标结束，没有赋值的下标默认为0
    //len（）获取数组长度
    fmt.Println("arr长度:", len(arr))
    //打印
    fmt.Printf(" arr类型:%T 值:%v\n arr2类型:%T 值:%v\n arr3类型:%T 值:%v\n arr4类型:%T 值:%v\n arr5类型:%T 值:%v\n", arr, arr, arr2, arr2, arr3, arr3, arr4, arr4, arr5, arr5)
    //循环遍历
    for i := 0; i < len(arr); i++ {
        fmt.Println("arr[", i, "]=", arr[i])
    }
    for i, v := range arr {
        fmt.Println("arr[", i, "]=", v)
    }
    //基本数据类型跟数组都是值类型  切片是引用类型
    a := 10
    b := a
    a = 20
    fmt.Println("a=", a, "b=", b)
    //a= 20 b= 10  a和b的值不同 值类型改变变量副本的值，不会改变变量本身的值
​
    //切片 引用类型
    qp := []int{1, 2, 3, 4, 5}
    qp2 := qp
    qp[0] = 100
    fmt.Println("qp=", qp, "qp2=", qp2)
    //qp=[100 2 3 4 5] qp2=[100 2 3 4 5]  qp和qp2的值相同 引用类型改变变量副本的值，会改变变量本身的值
​
    //多维数组
    darr := [2][2]int{{1, 2}, {3, 4}} //二维数组  只有第一层可以使用推导长度的方式 [...]
    fmt.Println(darr)
    fmt.Println(darr[0][0])
​
    //切片 切片声明默认值为nil 空数组
    qqp := []int{1, 2, 3, 4, 5}
    fmt.Printf("qqp:%v len:%v 类型:%T\n", qqp, len(qqp), qqp)
    //循环遍历
    for i := 0; i < len(qqp); i++ {
        fmt.Println("qqp[", i, "]=", qqp[i])
    }
    for k, v := range qqp {
        fmt.Println("qqp[", k, "]=", v)
    }
    //基于数组定义切片 也可以基于切片定义切片 写法一样
    /*
      切片长度就是它包含的元素个数
      切片的容量是从第一个元素开始，到其底层数组的最后一个元素结束的个数。
    */
    s1 := arr[:] //复制整个数组 [1:3] 表示截取数组 下标1到3的元素  也可以 [1:] [:2] 左包含右不包含
    fmt.Printf("s1:%v len:%v 类型:%T\n", s1, len(s1), s1)
    qqp2 := qqp[1:3]
    //此时 qqp2底层数组是切片 qqp  从下标1到最后一个元素 容量为4
    fmt.Printf("qqp2:%v 类型:%T len:%v  容量:%v\n", qqp2, qqp2, len(qqp2), cap(qqp2))
    //make 声明切片
    s2 := make([]int, 3, 8) //声明长度为3 容量为8的切片
    fmt.Printf("s2:%v len:%v 容量:%v 类型:%T\n", s2, len(s2), cap(s2), s2)
    s2[0] = 100
    s2[1] = 200
    s2[2] = 300
    fmt.Printf("s2:%v len:%v 容量:%v 类型:%T\n", s2, len(s2), cap(s2), s2)
    //append 追加元素到切片
    s1 = append(s1, 4, 5, 6) //追加元素 容量自动扩充 以旧容量为基准 扩充规则倍数 具体规则参考源码
    fmt.Printf("s1:%v len:%v 容量:%v 类型:%T\n", s1, len(s1), cap(s1), s1)
    s2 = append(s2, 400) //容量够用 直接追加
    fmt.Printf("s2:%v len:%v 容量:%v 类型:%T\n", s2, len(s2), cap(s2), s2)
    //切片合并
    s3 := append(s1, s2...) //...表示s2切片的所有元素 合并到s1切片 总的容量直接相加
    fmt.Printf("s3:%v len:%v 容量:%v 类型:%T\n", s3, len(s3), cap(s3), s3)
    //copy 复制切片
    s4 := make([]int, 5)
    copy(s4, s1) //复制s1切片到s4切片 容量不够丢失后面的元素  复制之后修改s4的值 s1的值不受影响
    fmt.Printf("s4:%v len:%v 容量:%v 类型:%T\n", s4, len(s4), cap(s4), s4)
    //删除切片元素
    s1 = append(s1[:2], s1[4:]...) //切片删除元素只能通过控制下标处理
    fmt.Printf("s1:%v len:%v 容量:%v 类型:%T\n", s1, len(s1), cap(s1), s1)
    //排序
    arr6 := []int{5, 2, 8, 3, 9, 1, 7, 6, 4}
    floatlist := []float64{5.6, 2.3, 8.1, 3.2, 9.7, 1.4, 7.8, 6.5, 4.9}
    stringlist := []string{"apple", "banana", "orange", "grape", "pear"}
    sort.Ints(arr6)
    sort.Float64s(floatlist)
    sort.Strings(stringlist)
    fmt.Println("排序后arr6：", arr6)
    fmt.Println("排序后floatlist：", floatlist)
    fmt.Println("排序后stringlist：", stringlist)
    //降序排序
    sort.Sort(sort.Reverse(sort.IntSlice(arr6)))
    sort.Sort(sort.Reverse(sort.Float64Slice(floatlist)))
    sort.Sort(sort.Reverse(sort.StringSlice(stringlist)))
    fmt.Println("降序排序后arr6：", arr6)
    fmt.Println("降序排序后floatlist：", floatlist)
    fmt.Println("降序排序后stringlist：", stringlist)
​
    //map 声明 引用类型
    m := make(map[string]int)
    m["apple"] = 100
    m["banana"] = 200
    m["orange"] = 300
    m2 := map[string]int{"apple": 100, "banana": 200, "orange": 300}
    fmt.Println("map:", m)
    fmt.Printf("map2的值:%v 类型:%T\n", m2, m2)
    //map 遍历
    for k, v := range m {
        fmt.Println("map[", k, "]=", v)
    }
    //删除map元素
    delete(m, "banana")
    fmt.Println("删除banana后的map:", m)
    v, ok := m["banana"] //判断元素是否存在 第一次元素是值，第二个元素是bool值 代表是否存在
    fmt.Println("banana是否存在:", ok, "值:", v)
    //元素为map类型的切片 切片里面带map
    s5 := make([]map[string]string, 2, 2)
    if s5[0] == nil {
        s5[0] = make(map[string]string)
        s5[0]["name"] = "zhangsan"
        s5[0]["age"] = "18"
    }
    if s5[1] == nil {
        s5[1] = make(map[string]string)
        s5[1]["name"] = "lisi"
        s5[1]["age"] = "19"
    }
    fmt.Printf("s5的值:%v 类型:%T\n", s5, s5)
    //map里面带切片
    s6 := make(map[string][]string)
    s6["hobby"] = []string{"吃饭", "睡觉", "打豆豆"}
    s6["like"] = []string{"篮球", "足球", "乒乓球"}
    fmt.Printf("s6的值:%v 类型:%T\n", s6, s6)
    //map排序 先对key排序 再按照key排序的value排序
}
​

延伸阅读

学习golang(七)

学习golang(十一)

学习golang(八)

学习golang(二)

学习golang(三)