Go 数组、切片、Maps

 Go 数组

数组：数组是同一类型元素的集合，在内存中乱序存放

package main

import "fmt"

func main() {
    // 1 基本定义和使用
    // 定义一个大小为3的int类型数组
    // 数组在定义阶段，大小和类型就固定了
    //var a [3]int
    //a[2] = 100
    //fmt.Println(a)

    // 2 定义并赋初值
    //var a [3]int = [3]int{1,2,3}
    //fmt.Println(a)  //输出 [1 2 3]

    // 只给第2个位置设为99
    //a := [3]int{2:99}
    ////进阶版
    //a := [3]int{2:99,1:88}
    //fmt.Println(a)

    // 3 数组的大小是类型的一部分
    // 下面两个不是同一个类型
    //var a [2]int
    //var b [3]int

    // 4 数组是值类型（当参数传递到函数中，修改不会改变原来的值）
    // go语言中，值都是copy传递
    /*
        python中都是引用传递，一切皆对象，对象就是地址，当做参数传递是把地址传过去了
        python中比较特殊：可变类型和不可变类型
    */

    var a [3]int=[3]int{5,6,7}
    fmt.Println(a)
    test1(a)
    fmt.Println(a)

    // 5 数组长度(len)
    //var a [3]int=[3]int{5,6,7}
    //fmt.Println(len(a))

    // 6 循环数组
    //方式一
    //var a [3]int=[3]int{5,6,7}
    //for i:=0;i<len(a);i++ {
    //    fmt.Println(a[i])
    //}
    //方式二
    //range:是一个关键字
    //var a [3]int = [3]int{5,6,7}
    //for i,v:=range a{
    //    fmt.Println(i) //索引
    //    fmt.Println(v) //数组的值
    //}

    //函数如果返回两个值，必须用两个值来接收
    //range可以用一个值来接收，如果用一个值来接收，就是索引
    //var a [3]int = [3]int{5,6,7}
    //for i:=range a{
    //    fmt.Println(i)  //索引
    //}
    //只取值，不取索引
    //for _,v:=range a{
    //    fmt.Println(v)  //值
    //}

    // 7 多维数组
    //定义一个二维数组
    //var a [3][2]int
    //定义并初始化
    //var a [3][2]int=[3][2]int{{1,2},{4,5},{9,70}}
    //a[1][0]=999
    //fmt.Println(a)
}

func test1(a [3]int)  {
    a[0]=999
    fmt.Println(a)
}

补充类型零值

// 补充：类型的默认值
var a int
var b float32
var c string
var d bool
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Println(d)

Go 切片

切片是由数组建立的一种方便、灵活且功能强大的包装（Wrapper）。切片本身不拥有任何数据。它们只是对现有数组的引用。切片底层依附于数组。

package main

import "fmt"

func main() {
    //1 创建切片(基于一个数组创建)
    //var a [9]int=[9]int{1,2,3,4,5,6,7,8,9}
    ////2 基于数组，切出一部分成为切片
    //// []int 中括号中没有东西，就是切片
    //var b []int
    //// 没有-1  没有步长
    //
    //b=a[0:3]  //前闭后开
    ////b=a[3:6]  
    ////b=a[:]  
    ////b=a[3:]  
    //fmt.Println(b)
    //fmt.Println(b[0])

    //3 切片的修改会影响底层数组，数组的修改也会影响切片
    //var a [9]int=[9]int{1,2,3,4,5,6,7,8,9}
    //var b []int=a[0:3]  //前闭后开
    //
    //fmt.Println(a)
    //fmt.Println(b)
    //a[0]=999
    //b[2]=888
    //fmt.Println(a)
    //fmt.Println(b)

    // 4 切片的长度和容量
    //var a [9]int=[9]int{1,2,3,4,5,6,7,8,9}
    //    //var b []int=a[2:3]  //前闭后开

    //fmt.Println(len(b))
    ////切片容量是7，意思是，可以往里追加值，追加成7个
    //fmt.Println(cap(b))
    //
    ////容量就是原数组的长度呗？对不对？不太对。。
    //b[0]=9999
    //fmt.Println(a)
    //fmt.Println(b)

    //5 追加值
    //var a [9]int=[9]int{1,2,3,4,5,6,7,8,9}
    //var b []int=a[2:3]  //前闭后开
    //b=append(b,1)
    //b=append(b,11,22,33,44,55)
    //fmt.Println(len(b))
    //fmt.Println(cap(b))
    //fmt.Println(b)
    //fmt.Println(a)
    //到了数组的尾部，继续追加值
    //b=append(b,999)
    //fmt.Println(len(b))
    //fmt.Println(cap(b))  //容量是14
    ////总结1：当切片追加值，超过了切片容量，切片容量会翻倍，在原来容量基础上乘以2
    ////b=append(b,222,333,444,555,666,7,8)
    ////fmt.Println(len(b))
    ////fmt.Println(cap(b))  //容量是14
    //
    ////总结2：一旦超过了原数组， 就会重新申请数组，把数据copy到新数组，切片和原数组就没有关系了
    //fmt.Println(a)
    //fmt.Println(b)
    //a[8]=7777
    //fmt.Println(a)
    //fmt.Println(b)

    //6 通过make创建切片（底层也依附于数组）
    //var a []int
    //切片零值是什么？ nil类型：是所有引用类型的空值
    //fmt.Println(a)  //输出[]
    //if a==nil{
    //    fmt.Println("我是空的")
    //}

    //3是长度，4是容量，用make来创建的切片a不是nil类型
    //var a []int=make([]int,3,4)
    //3是长度，3是容量
    //var a []int=make([]int,3)
    //fmt.Println(a)
    //if a==nil{
    //    fmt.Println("我是空的")
    //}
    //
    //fmt.Println(len(a))
    //fmt.Println(cap(a))

    //6 切片定义并赋初值
    //var a []int=[]int{1,2,3}
    //fmt.Println(a)
    //fmt.Println(len(a))
    //fmt.Println(cap(a))

    //7 切片是引用类型，当参数传递,会修改掉原来的值
    //var a []int=[]int{1,2,3}
    //fmt.Println(a)
    //test3(a)
    //fmt.Println(a)


    //8 多维切片
    //var a [][]int=make([][]int,2,3)
    //fmt.Println(a)  // 输出[[] []]
    //fmt.Println(a[0]==nil)  // 输出true
    ////a[0][0]=999  //会报错
    //// 如何做？(for循环完成初始化)
    //
    //a[0]=make([]int,2,3)
    //a[0][0]=999
    //fmt.Println(a)

    //定义并赋初值用的多
    //var a [][]int=[][]int{{1,2,3},{4,5,6,7,7,8}}
    ////跟上面不一样
    //var a [][3]int=[][3]int{{1,2,3},{4,5,6}}
    //fmt.Println(a)

    //9 切片的copy
    //var a []int=make([]int,3,4)
    //var b []int=make([]int,2,6)
    //a[0]=11
    //a[1]=22
    //a[2]=33
    //b[0]=999
    //fmt.Println(a)
    //fmt.Println(b)
    //
    //copy(b,a)
    //fmt.Println(b)  // 输出[11 22]

    //10 切片越界
    //var a []int=make([]int,3,4)
    //a[0]=11
    //a[1]=22
    //a[2]=33
    //
    //a=append(a,999)
    ////中括号取值，只能取到长度值，不能取到容联大小
    //fmt.Println(a[3])

}

func test3(a []int)  {
    a[0]=999
    fmt.Println(a)
}

Go Maps类型

maps：hash，字典。以key:value形式存储

package main

import "fmt"

func main() {
    //1 map的定义和使用
    //map[key类型]value类型：key的类型必须可hash，key值：数字，字符串
    //map的零值：nil   它是一个引用类型
    //var a map[int]string   
    //fmt.Println(a)  // 输出 map[]
    //if a==nil{
    //    fmt.Println("我是空的")
    //}

    //2 定义了，没有初始化，使用
    //var a map[int]string
    //初始化用make
    //var a map[int]string=make(map[int]string)
    ////如果有，会修改，如果没有，会放入
    //a[1]="lqz"
    //a[1]="egon"
    //a[2]="99"
    //
    ////a["xx"] key值不能乱写
    //
    //fmt.Println(a)

    //3 获取元素
    //var a map[int]string=make(map[int]string)
    ////var a map[int]int=make(map[int]int)
    //fmt.Println(a[0])  //取出value值的空值  ""
    //fmt.Println(a)

    //统一的方案来判断value值是否存在

    //a[0] 可以返回两个值，一个是value值（可能为空），另一个是true或false
    //var a map[int]int=make(map[int]int)
    //a[0]=0
    //v,ok:=a[0]
    //fmt.Println(v)
    //fmt.Println(ok)

    //4 map 删除元素
    //var a map[int]int=make(map[int]int)
    //a[1]=11
    //a[2]=22
    //fmt.Println(a)
    ////根据key删（内置函数）
    //delete(a,1)
    //fmt.Println(a)

    //5 map 长度
    //var a map[int]int=make(map[int]int)
    //fmt.Println(len(a)) // 输出0
    //a[1]=11
    //a[2]=22
    //fmt.Println(len(a))

    //6 map 是引用类型
    //var a map[int]int=make(map[int]int)
    //a[1]=11
    //
    //test4(a)
    //fmt.Println(a)

    //7 Map 的相等性
    //var a map[string]string=make(map[string]string)
    //a["name"]="lqz"
    //var b map[string]string=make(map[string]string)
    //b["name"]="lqz"
    //
    ////不能这样判断，map只能跟nil比较
    //if a==nil {
    //
    //}

    //8 循环map
    var a map[string]string=map[string]string{"name":"lqz","age":"19","sex":"男"}
    //搞不了
    //for i:=0;i<len(a) ; i++ {
    //    fmt.Println(a[i])
    //}

    //range循环
    for k,v:=range a{
        fmt.Println(k)
        fmt.Println(v)
    }

    // 9 map是无序的（python中字典从3.6以后有序了，3.6之前无序)
}

func test4(a map[int]int)  {
    a[1]=999
    fmt.Println(a)
}