go语言3 数组, 切片, Maps

1 数组

//数组:数组是同一类型元素的集合,在内存中连续存放
package main
import "fmt"

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

    //2 使用数组(从0开始)
    //var a [3]int
    //a[2]=100
    //fmt.Println(a)
    //fmt.Println(a[0])

    //3 定义并赋初值
    //var a [3]int=[3]int{1,2,3}
    //var a =[3]int{1,2,3}
    //a := [3]int{1, 2, 3}

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

    //4 数组的大小是类型的一部分
    //这两个不是一个类型
    //var a [2]int
    //var b [3]int
    //a=b
    //fmt.Println(a>b)

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

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

func test1(a [3]int){    // 值类型传参为copy，内部修改不会改变原来的
    a[0] = 999
    fmt.Println(a)
}

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

    //7 循环数组
    //方式一
    //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是关键字，可以用一个值来接收，如果用一个值来接收，就是索引
    //for i:=range a{
    //    fmt.Println(i)  //索引
    //}
    //只取值，不取索引
    //for _,v:=range a{
    //    fmt.Println(v)  //值
    //}

    //8 多维数组
    //定义一个二维数组
    //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)
}

2 切片

//切片是由数组建立的一种方便、灵活且功能强大的包装（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)
    //
    ////2 使用切片
    //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)    // [1 2 3 4 5 6 7 8 9]
    //fmt.Println(b)    // [1 2 3]
    //a[0]=999
    //b[2]=888
    //fmt.Println(a)    // [999 2 888 4 5 6 7 8 9]
    //fmt.Println(b)    // [999 2 888]

    // 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))
    ////切片容量是9，意思是，可以往里追加值，追加成9个
    //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))  // 容量是7
    //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        // 不会影响b数组
    //fmt.Println(a)
    //fmt.Println(b)

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

    //3是长度，4是容量
    //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))
    //
    //a=append(a,55)
    //fmt.Println(a)
    //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)
    ////会报错
    ////a[0][0]=999
    //// 如何做？(for循环完成初始化)
    //
    //a[0]=make([]int,2,3)
    //a[0][1]=999
    //fmt.Println(a)
    //a[1][0]=99999

    //定义并赋初值用的多
    //var a [][]int=[][]int{{1,2,3},{4,5,6,7,7,8}}
    ////跟上面不一样    切片为 个数为3的int类型数组
    //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)      // 目标   源   a中部分会覆盖b
    //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])

    // 11 切片循环
    // 方式一
    var a []int=make([]int,3,4)
    //for i:=0;i<len(a);i++ {
    //    fmt.Println(a[i])
    //}

    // 方式二
    for i,v:=range a{
        fmt.Println(i)
        fmt.Println(v)
    }
}

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

3 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)
    //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(未赋值为false)
    //var a map[int]int=make(map[int]int)
    //a[0]=0
    //v,ok:=a[0]    // 因为已赋值，所以ok为true
    //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))
    //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==b{} // 因为map是引用类型，这样相当于比较两个地址，不支持直接这样比
    //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循环   只能借助range
    for k,v:=range a{
        fmt.Println(k)
        fmt.Println(v)
    }

    // 9 map是无序的（python中字典从3.6以后有序了，3.6之前无序，底层如何实现的，看博客）
    // https://www.cnblogs.com/xiaoyuanqujing/articles/12008689.html
}

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