go 语言三 切片，map

 GO语言：

　　切片

　　map

 

3.1

切片类型

func main() {
    //切片定义的第一种方式是由数组切出来的 a[2:6] 数组名[起始索引:终止索引]
    //fmt.Println("wooo")
    //var a [8] int = [8]int{1,2,3,4,5,6,7,8}
    //    //是对底层数组的引用
    //var b []int =a[2:6]    //根据索引切片  []int 表示切片
    //fmt.Println(b)  //[3 4 5 6]  切片
    //a[2]=30    // 根据索引改值
    //fmt.Println(a)   // [1 2 30 4 5 6 7 8]  底层数组发生了改变
    //fmt.Println(b)    //[30 4 5 6] 切片中的值也发生了改变
    //
    //    //切片本身不存储数据，只是对底层数据的一个引用，
    //    //底层数组的修改会影响切片，切片的修改也会影响底层数组的修改
    //a[1]=20
    //fmt.Println(b)//[30 4 5 6] 切片的修改在没指定的范围内的数组的值不会影响切片中的值

    //更多用法
    //var a [8] int = [8]int{1,2,3,4,5,6,7,8}
    //b:=a[:]   //从头切到尾  [1 2 3 4 5 6 7 8]
    //b:=a[3:]   //从索引为3的开始切到最后，[4 5 6 7 8]
    //b :=a[:4]   // 从头切到索引为4的，不包括索引为4的值 [1 2 3 4] 顾头不顾尾
    ////没有歩长这个东西
    //fmt.Println(b)

    //第二种定义的方式，直接定义
        //切片空值是nil类型
        //所有的引用类型的空值都是nil类型
        //python中的对象都是引用类型，所以空值都可以为none
    //var a[]int  //在这里只是 定义了，没有初始化，如果再给他增值，例如a[0]=10就会报错，只有初始化后才算引用了，才能赋值
    //if a==nil{
    //    fmt.Println("我是空的")
    //}
    //fmt.Println(a)  //[]

        //直接定义，并进行初始化，
    //var a[]int = make([]int,2,3)
        //这样一定创建了一个底层数组，这个切片是依赖于这个底层数组
        //初始化：通过make函数，第一个参数为类型，第二个参数为切片长度，第三个参数为底层数组的长度，也就是切片的容量
    //fmt.Println(a) //[0 0]
        //切片的长度和容量，容量表示能放多少值，
        //切片的容量不是底层数组的大小，因为前面开头已经无法追加值
        //只有从第0个位置切得时候才是底层数组大小
    //var a [8] int = [8]int{1,2,3,4,5,6,7,8}
    //var b []int =a[2:6]
    //fmt.Println(len(b))    //长度为4
    //fmt.Println(cap(b))        //容量为6

    //var a[]int = make([]int,2,3)
    //fmt.Println(a)
    //fmt.Println(len(a))   长度为2
    //fmt.Println(cap(a))    容量为3

    //切片追加值。append内置函数来进行，可以同时增加多个
    //var a [8] int = [8]int{1,2,3,4,5,6,7,8}
    //var b []int =a[2:6]
    //fmt.Println(len(b))
    //fmt.Println(cap(b))
        //append第一个参数要追加的切片，第二个为追加的值，第二个人参数类型必须与追加的切片类型一样
    //b=append(b,555) //让b重新指向，此时的地址和原地址就不一样了
    //fmt.Println(b)   //[3 4 5 6 555]
    //fmt.Println(len(b))  //长度为5
    //fmt.Println(cap(b))        //容量为6
    //fmt.Println(a) //[1 2 3 4 5 6 555 8]
        //如果再追加两个，会是什么情况？数组是不能扩容的
    //b=append(b,555,666,777)
    //fmt.Println(b)  //[3 4 5 6 555 666 777]
    //fmt.Println(len(b)) //长度为7
    //fmt.Println(cap(b))    //容量为12
    //当切片追加到该数组的最大长度时，就不会依附该数组，而是重新建了一个数组，把原来数组的值copy过来，
    //把它的大小变为原来切片容量的两倍，如果继续追加，追加到最后，再申请当前数组容量的两倍也就是24
    //所以一旦超出底层数组的容量范围，你再取就不会影响到底层数组
    //var a[]int = make([]int,2,3)  make创建出来的你是看不到底层数组的

    //切片修改值：
    //var a[]int = make([]int,2,3)
    //a[0]=999
    //fmt.Println(a)  //[999 0]

    //切片的函数传参
    var b = make([]int,3,4)
    test(b)
    fmt.Println(b)
　　
　　
}

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

切片的数据结构

func main() {
　　

//切片的数据结构
type sclice struct {
   length int
   Capacity int
   ZerothElement *byte   //指针，
}

//多维切片初始化
var a [][]string=[][]string{{"1","2"},{"3","4"}}
fmt.Println(a)       // [[1 2] [3 4]]
fmt.Println(len(a))
fmt.Println(cap(a))

    //copy函数。底层优化
   var a = make([]int,3,30000)
   a[1]=999
   a[2]=888
   fmt.Println(a)

   var b =make([]int,3,3)
   fmt.Println(b)
   copy(b,a)   //copy(新的，原来的）   短的就要短的，
   fmt.Println(b)
}}

package main

import "fmt"

func main() {
    //循环多维切片
    pls:=[][]string{
        {"c","c++"},
        {"java","js"},
        {"go"},
    }
    fmt.Println(pls)
    for _,v:=range pls {
        for _,l:=range v {
            fmt.Println(l)
        }
    }
}

map

map的定义与空值


    map是go中将值value与键key关联的内置类型，通过响应的键可以获取到值，
    var a map[键值类型]value值类型
    map的空值也是nil类型
    var a map[int]string   //只定义，没有赋值
    fmt.Println(a)    //map[]
    if a== nil{
        fmt.Println("xxx")   //得到结论，map也是一个引用类型，
    }

map的初始化与赋值

    map定义后必须初始化，map的初始化
　　
    var a map[int]string=make(map[int]string)
    a[1]="中国"
    a[2]="888"    //增加值
    fmt.Println(a)
    fmt.Println(a[1])  //取值
    //取一个不存在的key的值，不报错，此时是空字符串，因为value是string类型，默认就是空字符串
    fmt.Println(a[9])
    var b map[int]int=make(map[int]int)
    fmt.Println(b[9])  //此时int空值是0

判断map的key是否存在


    var a map[int]string=make(map[int]string)
    a[1]="中国"
    a[2]="888"    //增加值
    fmt.Println(a)
    fmt.Println(a[1])  //取值

    //判断该key是否存在
    if _,ok:=a[9];ok{    //定义变量 _,ok:=a[1]  条件为ok (true或者false) 中括号中为key
        fmt.Println("该key存在")
    }else {
        fmt.Println("该值不存在")
    }
    v,ok:=a[1]     //如果取得值存在，ok就是true，不存在就为false
    fmt.Println(v)
    fmt.Println(ok)  //ok是个形参，可以随便命名

第二种定义方式和map的增删改取
    
//定义和初始化的第二中方式
    var a map[int]string=map[int]string{1:"kkk",2:"eee"}
    fmt.Println(a)  //map[1:kkk 2:eee]
    //简写方式一
    var c =map[int]string{5:"rrr",6:"ggg"}
    fmt.Println(c)  //map[5:rrr 6:ggg]zzz
    //可简写
    b:=map[int]string{3:"lkk",4:"yyy"}   //最常用
    fmt.Println(b) //map[3:lkk 4:yyy]
    b[8]="mmm"   //增加值
    b[4]="ooo"
    fmt.Println(b[3])   // lkk 取值
    fmt.Println(b[4])  //ooo 改值，有则更改，无则增加
    fmt.Println(b)   //map[3:lkk 4:ooo 8:mmm]
    //字典删除元素
    delete(b,3)   //字典删除没有返回值，只要有该元素一定删除，如果无key，也不会报错
    fmt.Println(b)

补充

    //切片删除元素,
    var d = []int{1,2,3,4,5,6}
    e:=d[0:3]  //切片删除元素只能通过这种方式进行
    d=append(d[0:3],d[2:]...)
    fmt.Println(e)   //[1 2 3]
    fmt.Println(d)   //[1 2 3 3 4 5 6]

map的长度和引用类型

func main() {
    //map的长度len函数
    b:=map[int]string{3:"lkk",4:"yyy"}
    fmt.Println(len(b))  //2

    //map是引用类型
    var a=map[int]string{1:"www",2:"rrr"}
    test(a)
    fmt.Println("=====",a)
}
func test(a map[int]string)  {
    a[1]="666"
    fmt.Println(a)
}

/*结果为
2
map[1:666 2:rrr]
===== map[1:666 2:rrr]
*/

map的相等性

    //map的相等型，只有map为空的时，即为nil时，才能用==，其他都不能用==
    map1 :=map[string]string{
        "爱好":"篮球",
        "特长":"长跑",
    }
    map2:=map1   //直接赋值
    fmt.Println(map2) //map[爱好:篮球 特长:长跑]
    //错误写法，不能使用==
    if map2 == map1{  
        fmt.Println("不能使用等号")
    }

map的循环取出元素

    //map循环取出元素，用range，
    var c=map[int]string{1:"www",2:"rrr"}
    for k,v:=range c{
        fmt.Println(k) //k 是key 1或2
        fmt.Println(v) //v 是value www和rrr
        //map是本身是无序的
    }