10-Go语言数组和切片

2018-09-23  本文已影响0人  喝酸奶要舔盖__

Go语言数组数组

一维数组
零值
值类型
package main

import "fmt"

func main() {
    nums := [...]int {2,3,4}
    arr := [...]int{2,3,4}
    fmt.Println(nums == arr) //true

    nums := [3]int{1,2,3}
    res := nums
    fmt.Println(res) //[1,2,3]

    nums := [3]int{1,2,3}
    change(nums)
    fmt.Println(nums)  //[1,2,3]

}
//函数内部无法改变数组元素的值
func change(nums [3]int)  {
    nums[2] = 666
}
二维数组
package main

func main() {
    //定义二维数组格式
    var nums [2][3]int = [2][3]int{
        {1,3,5},
        {2,5,6},
    }

    //简单定义方法
    nums := [2][3]int{
        {1,2,3},
        {4,5,6},
    }

    arr := [...][3]int{
        {12,3,5},
        {1,2,6},
    }
    fmt.Println(arr)
   //二维数组也可以省略元素个数,但是只可以省略行数,不可以省略列数
    arr := [...][3]int{
        {12,3,5},
        {1,2,6},
    }

    //遍历二维数组
    for i:=0; i< 2; i++{
        for j:=0;j < 3 ;j++  {
            fmt.Println(arr[i][j])
        }
    }
}
数组的遍历

Go语言切片

切片
切片与数组
  //定义数组
    var arr [5]int = [5]int{1,3,4,5,6}
    var arr = [5]int{1,3,4,5,6}
    arr := [5]int{1,3,4,5,6}
    arr := [...]int{1,3,4,5,6}

//定义二维数组
    var arrs [2][3]int = [2][3]int{
        {1,3,5},
        {2,4,6},
    }
    var arrs = [2][3]int{
        {1,3,5},
        {2,4,6},
    }

    arrs := [2][3]int{
        {1,3,5},
        {2,4,6},
    }

    arrs := [...][3]int{
        {1,3,5},
        {2,4,6},
    }

  //定义切片
    var sce []int = []int{1,3,5}
    var sce = []int{1,3,5}
    sce := []int{1,3,5}

//定义一个切片,切片中保存的是数组
    var sec [][3]int = [][3]int{
        {1, 3, 5},
        {2, 4, 6},
    }

    var sec = [][3]int{
        {1, 3, 5},
        {2, 4, 6},
    }

    sec := [][3]int{
        {1, 3, 5},
        {2, 4, 6},
    }

//定义一个切片,切片中保存切片
    var sec[][]int = [][]int {
        {1, 3, 5},
        {2, 4, 6},
    }

    var sec = [][]int {
        {1, 3, 5},
        {2, 4, 6},
    }
    sec := [][]int {
        {1, 3, 5},
        {2, 4, 6},
    }
append函数
    sec := make([]int, 1024, 1024)
    sec = append(sec, 6)
    fmt.Println(len(sec))
    fmt.Println(cap(sec))//1280
切片的使用
sec := []int{1,3,5,7,9,11}

sec[2] = 666

sec = append(sec, 7)
fmt.Println(sec)

//5.删除切片中的指定索引对应的数据
    index := 3
    //不仅可以利用数组获取切片,还可以用切片获取切片
    //sec = sec[:index]
    //fmt.Println(sec) //[1 3 5]
    //sec = sec[index +1 :]
    //fmt.Println(sec) //[9 11]
    //将第二个切片追加到第一个切片后面即可
    sec = append(sec[:index], sec[index +1 :]...)
    fmt.Println(sec) //[1 3 5 9 11]
切片的内存地址
package main

import "fmt"

func main() {
    /*
    通过切片生成切片的注意点
    */

    //1.创建一个数组
    var arr  = [3]int{1,2,3}
    //Go语言中不能通过数组名称获取数组的地址
    //fmt.Printf("%p\n", arr)
    fmt.Printf("%p\n", &arr) //0xc0420500a0
    fmt.Printf("%p\n", &arr[0]) //0xc0420500a0

    //2.通过数组创建一个切片
    //直接打印sce打印的是sce中指针保存的地址,也就是底层指向的那个数组的地址
    sce := arr[:]
    fmt.Printf("%p\n", sce) //0xc0420500a0

    //3.通过切片创建切片
    //通过切片创建一个切片, 新的切片和老的切片底层指向同一个数组
    sce2 := sce[:]
    fmt.Printf("%p\n", sce2) //0xc0420500a0

    //修改数组中的值
    arr[2] = 666
    sce[2] = 666
    sce2[2] = 666
    fmt.Println(arr)
    fmt.Println(sce)
    fmt.Println(sce2)
}
copy函数
package main

import "fmt"

func main() {
    /*
    copy函数的作用是将源切片的值拷贝到目标切片当中
    函数格式 copy(目标切片, 源切片)

     */
    sec1 := []int{1, 2, 3, 6, 9, 10}
    sec2 := make([]int, 2, 5)
    fmt.Println(sec2)
    //将源切片的值拷贝到目标切片当中
    //注意点: 拷贝的时候是以目标切片为准,目标切片中长度为多少将来只能拷贝多少个值进来
    copy(sec2, sec1)
    fmt.Println(sec2)
}
切片与字符串

注意点: 切片和数组不同, 切片不支持== !=操作

package main

import "fmt"

func main() {
    /*
    1.切片可以再生成新的切片, 两个切片底层指向同一个数组
    2.切片和数组不同, 切片不支持== !=操作
    3.在Go语言中字符串的底层实现就是切片, 所以可以通过字符串来生成切片
    */

    //数组可以使用== !=操作
    //arr := [3]int{1,2,3}
    //arr2 := [3]int{4,5,6}
    //arr = arr2
    //fmt.Println(arr)


    var str string = "www.it666.com"
    sec := make([]byte, len(str))
    copy(sec,str)
    fmt.Println(len(str))
    fmt.Printf("%s\n",sec) //www.it666.com
}
切片与数组注意点
var arr [4]int
    //数组定义后可以直接使用
    arr[0] = 1
    arr[1] = 3
    arr[2] = 5
    arr[3] = 7

    fmt.Println(arr)

    var sce []int
    //不能逐个初始化,会报错
    //sce[0] = 1
    //sce[1] = 3
    //sce[2] = 5

    //可以使用append函数添加数据
    sce = append(sce,1)
    sce = append(sce,3)
    sce = append(sce,5)
    sce = append(sce,7)
    sce = append(sce,9)

    //打印切片
    fmt.Println(sce)
    fmt.Println(len(sce))
    fmt.Println(cap(sce))

    //计算数组长度的方式
    //第一种方式(推荐)使用len函数
    arr := [4]int{1,3,5,7}
    //length := len(arr)
    //fmt.Println(length)

    //第二种方式,使用unsafe.Sizeof函数计算(不推荐)
    length1 := unsafe.Sizeof(arr)
    length2 := unsafe.Sizeof(arr[0])
    fmt.Println(length1 / length2)

    //计算切片的长度
    //第一种方式(推荐)使用len函数
    //注意点: 切片的长度不能使用unsafe.Sizeof函数计算
    //由于切片本质是结构体,所以unsafe.Sizeof计算的是结构体的字节数,不是指向数组的字节数
    sce := []int{1,3,5,6}
    length := len(sce)
    fmt.Println(length)

package main

import "fmt"

func main() {
    /*
    1.数组作为函数参数是值传递,在函数内部修改形参是不会影响外部实参的值
    2.切片作为函数的参数是地址传递(指针), 在函数内修改形参, 会影响到函数外的实参
    */
    //arr := [4]int{1,3,4,5}
    //fmt.Println(arr)
    //change1(arr)
    //fmt.Println(arr)

    sce := []int{1,2,3,4}
    fmt.Println(sce)
    change2(sce)
    fmt.Println(sce)
    
}
//数组是值传递
func change1(arr [4]int)  {
arr[0] = 666
}

//切片是地址传递指针
func change2(sce []int)  {
    sce[0] = 666
}

可变参数

package main

import "fmt"

func main() {
    /*
    可变参数,底层其实就是一个切片
    */
    res := sum(10,20,30)
    fmt.Println(res)

}
//可变参数底层就是一个切片
//注意点: 当一个函数中定义可变参数时候,可变参数只能放在形参列表的最后面
func sum(nums ...int) (res int) {
    for _, value := range nums {
        res += value
    }
    return
}
上一篇下一篇

猜你喜欢

热点阅读