TOP

Go语言学习笔记(三)数组 & 切片 & map(一)
2017-09-30 13:26:47 】 浏览:9599
Tags:语言学习 笔记 数组 切片 map

加 Golang学习 QQ群共同学习进步成家立业工作 ^-^ 群号:96933959

数组 Arrays

数组是同一种数据类型的固定长度的序列。

数组是值类型,因此改变副本的值,不会改变本身的值;

当作为方法的入参传入时将复制一份数组而不是引用同一指针。

通过从0开始的下标索引访问元素值。

数组定义

var a []int
a = make([]int, 5)
var a1 [5]int = [5]int{1, 2, 3, 4, 5}      //len:5 content:[1 2 3 4 5]
var a2 = [5]int{1, 2, 3, 4, 5}             //len:5 content:[1 2 3 4 5]
var a3 = [...]int{1, 2, 3, 4, 5}           //len:5 content:[1 2 3 4 5]
var a4 = [...]int{1: 100, 2: 200}          //len:3 content:[0 100 200]
var a5 = [...]string{1: "nick", 2: "dawn"} //len:3 content:[ nick dawn]

数组定义后,长度不能变。

长度是数组类型的一部分,具有不同长度的数组,其类型是不同的。

因此,var a[5] int 和 var a[9]int 是不同的类型。

数组使用

通过下标访问,超出会报错

arr := [5]int{1, 2, 3}
//fmt.Println(arr[5])    //报错

通过for遍历数组元素

func main()  {
    arr := [5]int{1, 2, 3}
    for i:=0; i<len(arr); i++ {
        fmt.Println(arr[i])    //12300
    }
    for i,v := range arr{
        fmt.Printf("index[%d]:content[%v]\n", i, v)
    }
}

值类型数组赋值,改变副本不会改变自身

func main()  {
    arr := [5]int{1, 2, 3}
    arr2 := arr
    arr2[0] = 10
    fmt.Println(arr)    //[1 2 3 0 0]
    fmt.Println(arr2)    //[10 2 3 0 0]
}
package main

import (
    "fmt"
)

func test1(n int) {
    var a []int
    a = make([]int, n)

    a[0] = 1
    a[1] = 1

    for i := 2; i < n; i++ {
        a[i] = a[i-1] + a[i-2]
    }
    for _, v := range a {
        fmt.Println(v)
    }
}

func main() {
    test1(10)
}
栗子(斐波那契数列)

 

二维数组 

多维数组,二维数组举例

var a1 [2][5]int

二维数组遍历

func main() {
    var a1 [2][5]int = [...][5]int{{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}}

    for row, v := range a1 {
        for col, v1 := range v {
            fmt.Printf("(%d,%d)=%d ", row, col, v1)
        }
        fmt.Println()
    }
}

 

切片 Slices

切片是长度可变、容量固定的相同的元素序列。

切片是数组的一个引用,因此切片是引用类型

因此在当传递切片时将引用同一指针,修改值将会影响其他的对象。

slice 与 array 接近,但是在新的元素加入的时候可以增加长度。slice 总是指向底层的一个 array。slice本身不是数组,slice 是一个指向 array的指针。

切片定义 

创建切片跟创建数组唯一的区别在于 Type 前的“ [] ”中是否有数字,为空,则代表切片,否则则代表数组。

s1 := [] int{1, 2, 3}          //直接初始化切片,[]表示是切片类型,初始化值依次是1,2,3.其cap=len=3
s2 := arr[:]                   //初始化切片s2,是数组arr的引用
s3 := arr[startIndex:endIndex] //将arr中从下标startIndex到endIndex-1下的元素创建为一个新的切片
s4 := arr[startIndex:]         //缺省endIndex时将表示一直到arr的最后一个元素
s5 := arr[:endIndex]           //缺省startIndex时将表示从arr的第一个元素开始
s6 := s1[startIndex:endIndex]  //通过切片s6初始化切片截取s1
s7 := make([]int, len, cap)    //通过内置函数make()初始化切片s,cap可以省略(省略时,值等同于len)

len() 与 cap()

长度是指已经被赋过值的最大下标+1,可通过内置函数len()获得。

容量是指切片目前可容纳的最多元素个数,可通过内置函数cap()获得。

arr := [5]int{1, 2, 3}
fmt.Println(len(arr))    //5
fmt.Println(cap(arr))    //5

切片使用

遍历及修改

for i, v := range slice0 {
    slice0[i] = strings.ToUpper(v)
    fmt.Printf("index[%d]content[%s,%s]\n", i, v, slice0[i])
}

append 及 copy

append操作:slice可以在尾部追加元素,甚至还可以将一个slice追加到另一个slice的尾部,如果最终的长度没有超过原始的slice,那么append操作将返回原来的slice,否则将重新分配内存地址。

copy操作:copy操作返回复制的元素的个数,复制的数量是len(src)和len(dst)中最小的值。

slice := []int{1, 2}
fmt.Printf("len[%d],content:%v\n", len(slice), slice) //len[2],content:[1 2]
slice = append(slice, 5, 6, 8, 9)
fmt.Printf("len[%d],content:%v\n", len(slice), slice) //len[6],content:[1 2 5 6 8 9]

slicecp := make([]int, len(slice))
fmt.Printf("len[%d],content:%v\n", len(slice), slice) //len[6],content:[1 2 5 6 8 9]
n := copy(slicecp, slice)
fmt.Printf("len[%d],content:%v, retN:%d\n", len(slice), slice, n) //len[6],content:[1 2 5 6 8 9], retN:6
slicecp[0] = 10
fmt.Printf("len[%d],co  
		
Go语言学习笔记(三)数组 & 切片 & map(一) https://www.cppentry.com/bencandy.php?fid=78&id=121299

首页 上一页 1 2 3 下一页 尾页 1/3/3
】【打印繁体】【投稿】【收藏】 【推荐】【举报】【评论】 【关闭】 【返回顶部
上一篇Go语言学习笔记(二)十分钟上手 下一篇Go语言string,int,int64 ,float..