Golang 学习笔记(04)—— array, slice, map

本文为转载,原文:Golang 学习笔记(04)—— array, slice, map

Golang 学习笔记(04)—— array, slice, map_第1张图片
Golang

介绍

  • Array 是值类型,Slice 和 Map 是引用类型。他们是有很大区别的,尤其是在参数传递的时候。
  • 另外,SliceMap 的变量 仅仅声明是不行的,必须还要分配空间(也就是初始化,initialization) 才可以使用。
  • 第三,SliceMap 这些引用变量 的 内存分配,不需要你操心,因为 golang 是存在 gc 机制的(垃圾回收机制)

array

顾名思义,就是数组的意思,固定长度的数组,使用前必须确定数组的长度。值类型的,即将一个数组赋值给另外一个数组的时候,实际上就是将整个数组拷贝一份。

验证是值类型的

func main(){
    var a = [5]int{1,2,3,4,5}
    e := a
    e[2] = 10
    fmt.Printf("a:%v\n", a)
    fmt.Printf("e:%v\n", e)
}

[图片上传失败...(image-51a319-1513159622174)]

声明

数组的声明如下:(这里就是定义,给数据存储分配了空间)

var arrayName [arraySize] dataType

例如:

var a [10]int
var str [10]string

如果数组定义好之后, 没有给数组元素指定值,那么所有元素被自动初始化为零值。

func main(){
    var a [10]int
    var str [10]string
    fmt.Printf("a:%v\n", a)
    fmt.Printf("str:%v", str)
}

[图片上传失败...(image-938420-1513159622174)]

数组初始化

func main(){
    //定义数组的时候,直接初始化
    var a = [5]int{1,2,3,4,5}
    //初始化部分元素,其余归零
    var b = [10]int {1,2,3,4,5}
    //由初始化列表确定数组长度,不可省略标识符"..."否则会变成切片,
    var c = [...]int {1,2,3}
    //按照指定下标来初始化
    var d = [10]int{2:5, 7:10}
    fmt.Printf("a:%v\n", a)
    fmt.Printf("b:%v\n", b)
    fmt.Printf("c:%v\n", c)
    fmt.Printf("d:%v\n", d)
}

[图片上传失败...(image-2d0124-1513159622174)]

数组的操作

对于数组的赋值和取值都可以用下标来实现,如:

func main(){
    var a [5]int
    a[2] = 10
    b := a[2]
    fmt.Println("a: ", a)
    fmt.Println("set a[2]: ", a[2])
    fmt.Println("get a[2]: ", b)
}

[图片上传失败...(image-37ab69-1513159622174)]

另外可以通过len方法获取数组的长度

a := [10]int
len := len(a)

遍历数组

func main(){
    a := [5]int{1,2,3,4,5}
    //下标遍历数组
    for i := 0; i < len(a); i++{
        fmt.Printf("a[%d] = %d\n", i, a[i])
    }
    fmt.Println("")
    // range关键字遍历
    for i, v := range a{
        fmt.Printf("a[%d] = %d\n", i, v)
    }
}

[图片上传失败...(image-908ce0-1513159622174)]

Slice

slice是引用类型,有点像指向数组的指针,slice的声明与数组的声明类似,但是不需要指定长度。其中,slice有两个重要属性,一个是len(长度),另一个是cap(容量)。长度是只当前slice中数据的实际长度,容量是指当前slice的最大长度。

验证是引用类型的

func main(){
    s1 := []int{1,2,3,4,5} 
    s2 := s1
    s2[2] = 10
    fmt.Println("s1: ", s1)
    fmt.Println("s2: ", s2)
}

[图片上传失败...(image-be53f6-1513159622174)]

声明

slice的声明如下(没有分配内存):

var sliceName [] dataType

另外还有三种创建slice的方式,但这是方式是已经分配内存了的。
三种创建方式: 基于底层数组创建,直接创建,或者 make() 函数创建

  • 基于底层数组创建
func main(){
    a := [5]int{1,2,3,4,5} //数组
    sa1 := a[1:4] //基于数组创建,数据为a[1],a[2],a[3],不包括a[4]
    sa2 := a[:] //引用全部元素
    fmt.Println("a: ",a)
    fmt.Println("sa1: ",sa1)
    fmt.Println("sa2: ",sa2)
}

[图片上传失败...(image-e9e4ff-1513159622174)]

  • 直接创建 slice
    在声明的时候,直接初始化。
var slice1 = []int {1 ,2, 3, 4, 5}
  • make() 函数创建 slice
var slice1 = make([]int, 5)  //长度和容量都是 5
var slice2 = make([]int, 5, 10)  //容量是5.

slice操作

Slice 中的切片的元素,可以动态的添加和删除,所以操作起来要比数组更加方便

增加元素

采用内建函数 append() 向切片尾部,增加新的元素。
先上代码

func main(){
    s1 := make([]int, 3, 6) //创建一个len=3,cap=6的切片
    fmt.Printf("s1: len = %d   cap = %d   %v\n", len(s1), cap(s1), s1)

    s2 := append(s1, 1, 2, 3)
    fmt.Printf("s1: len = %d   cap = %d   %v\n", len(s1), cap(s1), s1)
    fmt.Printf("s2: len = %d   cap = %d   %v\n", len(s2), cap(s2), s2)
    
    s1[0] = 5
    s2[1] = 20
    fmt.Printf("s1: len = %d   cap = %d   %v\n", len(s1), cap(s1), s1)
    fmt.Printf("s2: len = %d   cap = %d   %v\n", len(s2), cap(s2), s2)

    s3 := append(s1, 1,2,3,4,5)
    fmt.Printf("s1: len = %d   cap = %d   %v\n", len(s1), cap(s1), s1)
    fmt.Printf("s2: len = %d   cap = %d   %v\n", len(s2), cap(s2), s2)
    fmt.Printf("s3: len = %d   cap = %d   %v\n", len(s3), cap(s3), s3)

    s1[0] = 100
    fmt.Printf("s1: len = %d   cap = %d   %v\n", len(s1), cap(s1), s1)
    fmt.Printf("s2: len = %d   cap = %d   %v\n", len(s2), cap(s2), s2)
    fmt.Printf("s3: len = %d   cap = %d   %v\n", len(s3), cap(s3), s3)
}

[图片上传失败...(image-bc6b97-1513159622174)]
从上面的例子可以得出以下结论

  1. append 方法不会影响原来的切片属性
  2. append 方法会返回更新后的切片
  3. 更新后的切片容量没有超过更新前的容量时,这两个切片指向的地址是一样的。
  4. append() 添加元素的个数超过 切片的 cap() 的时候,那么底层会 重新分配一个 “足够大” 的内存,一般来说是将原来的内存空间扩大二倍,然后将数据复制到新的内存中去, 原来的空间会保留 (供原先切片使用)

删除和插入元素

删除和插入元素可以用append 方法实现

func main(){
    s1 := []int{1,2,3,4,5,6,7,8,9,10}
    fmt.Printf("origin data: len=%d  cap=%d  s1=%v\n",len(s1), cap(s1), s1)
    s1 = removeAt(s1, 5)
    fmt.Printf("after remove: len=%d  cap=%d  s1=%v\n",len(s1), cap(s1), s1)
    s1 = insertAt(s1, 5, 6)
    fmt.Printf("after insert: len=%d  cap=%d  s1=%v\n",len(s1), cap(s1), s1)
}

func removeAt(src []int, index int)[]int{
    src = append(src[0:index], src[index+1:]...)
    return src
}

func insertAt(src []int, index int, data int)[]int{
    rear := append([]int{}, src[index:]...)
    src = append(src[0:index], data)
    src = append(src, rear...)
    return src
}

[图片上传失败...(image-944535-1513159622174)]

复制

使用切片长时间引用超大的底层数组,会导致严重的内存浪费现象。 可以新建一个小的slice 对象,然后将所需要的数据复制过去,这样子就不会引用底层数组,直接拷贝了数据,这就是需求。函数 copy()可以 在切片之间复制元素。
copy函数返回复制元素个数,两个参数分别为目的方,源

  • copy() 可以复制的元素数量取决于 复制方 和 被复制方的最小长度。
  • 同一个底层数组之间的 元素复制,会导致元素重叠问题。
func main(){
    s1 := []int{1,2,3,4,5,6,7,8,9,10}
    s2 := make([]int, 3, 6)
    n := copy(s2, s1)
    fmt.Printf("n:%d  s1:%v  s2:%v\n", n, s1, s2)

    //二者引用同一个底层数组
    s3 := s1[1:5]
    s4 := s1[2:7]
    fmt.Println("s3: ",s3)
    fmt.Println("s4: ",s4)
    n = copy(s4, s3)
    fmt.Printf("n:%d  s1:%v  s3:%v  s4:%v\n", n, s1, s3, s4)
}

[图片上传失败...(image-46aad6-1513159622174)]
至于这个结果,之所以s3,s4,s1会变,都是引用导致的。

Map

map是一个key-value的hash结构,是一个无序的数据的集合,通过键来进行索引得到对应的值。 这种方式可以加快查找速度。Map 通常称为 字典(dictionary) 或者哈希表(Hash table)。Map 现在是很多语言的标配

声明

var mapName map[keyType]valueType

注意:

  • 不需要给字典指定长度,字典的长度会在初始化或者创建的过程中动态增长
  • Key 必须是能支持 比较运算符(==, !=)的数据类型,比如 整数,浮点数,指针,数组,结构体,接口等。 而不能是 函数,字典,切片这些类型。
  • Value 类型 可以是Go语言的任何基本数据类型

声明之后的map必须初始化或创建才能使用的,否则就是nil
例如以下是不通过的:

var mymap map[string]int
mymap["key1"] = 1
  • 使用{}在声明的时候初始化map
map1 := map[string]string{}
map1["key1"] = "value1"
  • 使用make创建map
map1 := make(map[string]string)
map1["key1"] = "value1"

map操作

查找

v, ok := mapName[key]

如果Key存在,将Key对应的Value赋值给v,OK== true. 否则 v 是0,OK==false.

删除

delete(mapName, "key1")

如果key1值不存在,那么调用将什么也不发生,也不会产生副作用。 但是,如果传入的map 是一个 nil,那么将导致程序出现异常,这一点在写程序的时候特别注意。

目录
上一节:Golang 学习笔记(03)—— 字符串操作
下一节:Golang 学习笔记(05)—— 面向对象编程

你可能感兴趣的:(Golang 学习笔记(04)—— array, slice, map)