高级数据类型(arraryslicemapptr)

Posted juju-niuniu

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了高级数据类型(arraryslicemapptr)相关的知识,希望对你有一定的参考价值。

高级数据类型:

  高级数据类型有数组、切片、map、指针、结构体、函数、接口、通道等,本文只介绍Arrary、Slice、map、ptr。

数组:

(1)概念:

  数组是同一种数据类型的集合。数组从声明时大小就已经确定,使用过程中可以修改值,但是数组的大小不可改变。

(2)初始化

  方法一:使用初始化列表来设置数组元素的值

  var testArray[3]int

  var numArray=[3]int{4,5}

  方法二:自行推断数组的长度的方式

  var numArray=[...]int{4,5}

  方法三:使用指定索引值的方式来初始化数组

  var numArray=[...]int{1:4,3:5}

(3)数组的遍历

技术图片
func main() {
    var a = [...]string{"南山", "罗湖", "保安"}
    // 方法1:for循环遍历
    for i := 0; i < len(a); i++ {
        fmt.Println(a[i])
    }

    // 方法2:for range遍历
    for index, value := range a {
        fmt.Println(index, value)
    }
}
View Code

 

(4)多维数组

技术图片
func main() {
    a := [3][2]string{
        {"南山", "罗湖"},
        {"保安", "光明"},
        {"龙华", "龙岗"},
    }
    fmt.Println(a) 
    fmt.Println(a[2][1]) //支持索引取值:龙岗
}
View Code

注意:多维数组只有第一层可以使用...来让编译器推导数组长度。

 

切片:

  切片是一个拥有相同类型元素的可变长度的序列,它非常灵活,支持自动扩容。切片是一个引用类型,它的内部结构包含:地址、长度、容量。

 (1)为什么用切片:

  a.数组的内a容固定,不能自动扩展;

  b.值传递,b数组作为函数参数时,将整个数组拷贝一份给形参;

  go语言中,我们几乎可以在所有的场景中,用切片来替代数组。切片拥有自己的长度和容量,可以通过使用len()、cap()函数分别求切片的长度和容量。

(2)基于数组定义切片:

func main() {
    // 基于数组定义切片
    a := [5]int{15, 26, 37, 48, 59}
    b := a[1:4]                     //基于数组a创建切片,包括元素a[1],a[2],a[3]
    fmt.Println(b)                  //[26 37 48]
    fmt.Printf("type of b:%T
", b) //type of b:[]int
        c := a[1:] //[26 37 48 59]
        d := a[:4] //[15 26 37 48]
        e := a[:]  //[15 26 37 48 59]      
}

(3)切片再切片:

技术图片
func main() {
    //切片再切片
    a := [...]string{ "南山区", "罗湖区", "光明区", "宝安区", "龙岗区", "龙华区"}
    fmt.Printf("a:%v type:%T len:%d  cap:%d
", a, a, len(a), cap(a))
    b := a[1:3]
    fmt.Printf("b:%v type:%T len:%d  cap:%d
", b, b, len(b), cap(b))
    c := b[1:5]
    fmt.Printf("c:%v type:%T len:%d  cap:%d
", c, c, len(c), cap(c))
}
View Code

(4)使用make()函数构造切片:

  上面都是基于数组或切片来创建切片的,如果是动态创建一个切片,则用make([]T, size, cap)函数

(5)切片的本质:

  切片的本质就是对底层数组的封装,一个slice是一个轻量级的数据结构,提供访问数组子序列(或者全部)元素的功能。一个slice由三部分组成:指针、长度(len)、容量(cap),指针指向slice的第一个元素对应的底层数组元素的地址(并不一定是底层数组的首地址)

(6)切片的赋值拷贝

技术图片
func main() {
    s1 := make([]int, 3) //[0 0 0]
    s2 := s1             //将s1直接赋值给s2,s1和s2共用一个底层数组
    s2[0] = 200
    fmt.Println(s1) //[200 0 0]
    fmt.Println(s2) //[200 0 0]
}
View Code

(7)切片的遍历

  切片支持索引遍历和for range遍历

技术图片
func main() {
    s := []int{3, 8, 9}

    for i := 0; i < len(s); i++ {
        fmt.Println(i, s[i])
    }

    for index, value := range s {
        fmt.Println(index, value)
    }
}
View Code

(8)添加元素

技术图片
func main() {
    //append()添加元素和切片扩容
    var numSlice []int
    for i := 0; i < 5; i++ {
        numSlice = append(numSlice, i)
        fmt.Printf("%v  len:%d  cap:%d  ptr:%p
", numSlice, len(numSlice), cap(numSlice), numSlice)
    }
}
View Code
    扩容策略
    a.如果cap(申请容量)大于2倍old.cap(旧容量),则newcap=cap;
    b.否则,如果old.cap<1024,则newcap=2*old.cap;
    c.否则,如果old.cap>=1024,则最终容量(newcap)从旧容量(old.cap)开始循环增加原来的1/4,即(newcap=old.cap,for {newcap += newcap/4})直到最终容量(newcap)大于等于新申请的容量(cap);
    d.如果最终容量(cap)计算值溢出,则最终容量(cap)就是新申请容量(cap);
(9)使用copy()函数复制切片
  copy(destSlice,srcSlice[]T)函数可以迅速将一个切片的数组复制到另一个切片空间中
技术图片
func main() {
    // copy()复制切片
    a := []int{1, 2, 3, 4, 5}
    c := make([]int, 5, 5)
    copy(c, a)     //使用copy()函数将切片a中的元素复制到切片c
    fmt.Println(a) //[1 2 3 4 5]
    fmt.Println(c) //[1 2 3 4 5]
    c[0] = 20
    fmt.Println(a) //[1 2 3 4 5]
    fmt.Println(c) //[20 2 3 4 5]
       //说明copy后a和c的底层数组不是同一个数组  
}
View Code

(10)从切片中删除元素

  go语言中没有删除元素的方法,可以使用切片本身的特殊性来删除元素。

技术图片
func main() {
    // 从切片中删除元素
    a := []int{30, 31, 32, 33, 34, 35, 36, 37}
    // 要删除索引为2的元素
    a = append(a[:2], a[3:]...)
    fmt.Println(a) //[30 31 33 34 35 36 37]
}
View Code

要从切片a中删除索引为index的元素,方法是:a=append(a[:index],a[index+1:]...)

map:

(1)概念

  map是一种映射关系容器,是一种无序的基于key-value的数据结构,必须初始化后才可以使用,默认初始值为nil,需要make函数来分配内存。

  在map里所有的键都是唯一的,而且必须是支持==和!=操作符的类型,对于切片、函数以及包含切片的结构体等类型,由于具有引用语义,不能作为映射的键,键为这些类型编译会报错;map值可以是任意类型,所有键的类型必须相同,值也是如此。

注意:map是无序的,每次打印的顺序都可能不同。

(2)map的基本使用:

技术图片
func main() {
    scoreMap := make(map[string]int, 8)
    scoreMap["张三"] = 200
    scoreMap["李四"] = 100
    fmt.Println(scoreMap)
    fmt.Println(scoreMap["李四"])
    fmt.Printf("type of a:%T
", scoreMap)
}

输出:
map[小明:200 李四:100]
100
type of a:map[string]int
View Code

判断某个键是否存在:value,ok:=map[key]

技术图片
func main() {
    scoreMap := make(map[string]int)
    scoreMap["张三"] = 100
    scoreMap["李四"] = 200
    // 如果key存在ok为true,v为对应的值;不存在ok为false,v为值类型的零值
    v, ok := scoreMap["张三"]
    if ok {
        fmt.Println(v)
    } else {
        fmt.Println("没有此人")
    }
}
View Code

map的遍历使用 for range

技术图片
func main() {
    scoreMap := make(map[string]int)
    scoreMap["张三"] = 50
    scoreMap["李四"] = 150
    scoreMap["王五"] = 200
    for k, v := range scoreMap {
        fmt.Println(k, v)
    }
}
View Code

注意:遍历map时的元素顺序与添加键值对的顺序无关。

使用delete()函数删除键值对:delete(map,key)

技术图片
func main(){
    scoreMap := make(map[string]int)
    scoreMap["张三"] = 50
    scoreMap["小明"] = 150
    scoreMap["李四"] = 200
    delete(scoreMap, "小明")//将小明:150从map中删除
    for k,v := range scoreMap{
        fmt.Println(k, v)
    }
}
View Code

求map的键值对的容量,不能用cap()函数,而是用len(),map与slice一样可以自动扩容。

技术图片
func main() {
    rand.Seed(time.Now().UnixNano()) //初始化随机数种子

    var scoreMap = make(map[string]int, 5)

    for i := 0; i < 10; i++ {
        key := fmt.Sprintf("stu%02d", i) //生成stu开头的字符串
        value := rand.Intn(10)          //生成0~10的随机整数
        scoreMap[key] = value
    }
         for k,v:=range scoreMap{
               fmt.Println(k, v)
         }
}            
View Code

 

指针:

  指针是一个代表某个内存地址值,这个内存地址往往是在内存中存储另一个变量的起始位置。go语言的指针保留的应用不到C/C++ 的1/3,不过还是保留了对基本的内存操作。学习go语言指针只需记住两个符号:&(取地址)、*(根据地址取值/解引用)。

(1)栈帧(stack)

   a.用来给函数运行提供的内存空间

   b.当函数调用时,产生栈帧,函数调用结束,释放栈帧

   c.栈帧存储:局部变量、形参、内存字段描述

   d.栈帧的空间使用完后,会自己释放

(2)空指针和野指针

  空指针:未被初始化的指针

  野指针:被一片无效地址空间初始化

func main() {
    var a *int//空指针
    fmt.Println(*a)
    var p *int =0xc04204c080//野指针
    fmt.Println(*p)
}

(3)堆(heap)

  make、new的变量存在堆中,堆上申请的空间在c/c++上必须释放的,而go有垃圾回收(gc),但并不是就可以无限申请内存,因为堆的大小是有限的,所以为了能够循环地申请内存空间,在使用完后,或者不使用后,提示gc进行垃圾回收,可以通过赋nil值来提醒gc进行回收。

  func new(Type) *Type,使用new函数得到的是一个类型的指针,并且该指针对应的值为该类型的零值。

技术图片
func main() {
    a := new(int)
    b := new(bool)
    fmt.Printf("%T
", a) // *int
    fmt.Printf("%T
", b) // *bool
    fmt.Println(*a)       // 0
    fmt.Println(*b)       // false
}
View Code

  指针作为引用类型需要初始化后才会拥有内存空间,才可以给它赋值。应使用内置的new函数对指针进行初始化之后就可以正常对其赋值了。

技术图片
func main() {
    var a *int
    a = new(int)
    *a = 10
    fmt.Println(*a)
}
View Code

  make也是用于内存分配的,区别于new,它只用于slice、map以及channel的内存创建,而且它返回的类型就是这三个类型本身,而不是他们的指针类型,因为这三种类型就是引用类型,所以就没有必要返回他们的指针了。

make与new的差异

  a.二者都是用来分配内存

  b.make只用于slice、map、channel的初始化,返回的是这三个引用类型本身

  c.而new用于内存分配,初始值为类型的零值,返回的是指针

 

(4)变量存储

  等号左边的变量,代表变量所指向的内存空间;(写)

  等号右边变量,代表变量内存空间存储的数据值;(读)

技术图片
func main() {
    var p *int
    p=new(int)
    *p=1000
    fmt.Printf("%d
",*p)
    fmt.Printf("%v
",*p)
}
View Code

(5)指针的函数参数

  传地址(引用):将形参的地址值作为函数参数

  传值(数据):将形参的值拷贝一份给实参

func main() {
        d := 99
    modifty1(d)
    fmt.Println(d)
    modifty2(&d)
    fmt.Println(d)
}

func modifty1(x int) {
    x = 100
}

func modifty2(x *int) {
    *x = 100
}

 

以上是关于高级数据类型(arraryslicemapptr)的主要内容,如果未能解决你的问题,请参考以下文章

hive高级数据类型

Elasticsearch:高级数据类型介绍

Python高级数据类型模块collections

ElasticSearch实战(十六)-高级数据字段类型

ClickHouse 实战:ClickHouse 高级数据类型极简教程

Go语言入门篇-高级数据类型