Go基础03数组和切片

2017-08-21 18:54:54

  • 数组
    数组是一系列同一类型数据的集合.数组中包含的每个元素被称为数组元素,一个数组包含的元素个数称为数组的长度.数组长度在定义后就不能更改.
    go数组的定义:
    [32]byte
    [2N] struct {x, y int 32}
    [1000]    float64
    [3][5]int
    [2][2][2]float64
    go数组初始化:
    初始化数组中 {} 中的元素个数不能大于 [] 中的数字
    var balance = [5]float32{999.9, 3.0, 5.8, 8.9, 3.9}
    如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：
    var balance = […]float32{999.9, 3.0, 5.8, 8.9, 3.9}
    go数组的完整操作:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    package main

    import "fmt"

    func main() {
        var n [10]int  // n 是一个长度为10的数组
    	var i,j int
    	
    	// 初始化数组元素
    	for i=0;i<10;i++{
    	    n[i]=i+100
    	}
        
    	//输出每个数组元素的值
    	for j=0;j<10;j++ {
    	    fmt.Printf("Element[%d] = %d\n", j, n[j] )
    	}
    }

  • 切片
    切片是对数组的抽象,是在数组之上进行的一层封装,切片的长度不固定,可以追加元素.切片的容量即隐藏数组的长度。长度可变指的是在数组长度的范围内可变
    go切片的定义:
    var slice1 []type
    var slice1 []type = make([]type, len)
    slice1 := make([]type, len)
    slice1 := make([]type, len, cap)
    go切片初始化:
    s := []int{1, 2, 3} //直接初始化切片，[]表示是切片类型，{1,2,3}初始化值依次是1,2,3.其cap=len=3
    s := arr[:] //初始化切片s,是数组arr的引用
    s := arr[startIndex:endIndex] //将arr中从下标startIndex到endIndex-1 下的元素创建为一个新的切片
    s := arr[startIndex:] //缺省endIndex时将表示一直到arr的最后一个元素
    s := arr[:endIndex] //缺省startIndex时将表示从arr的第一个元素开始
    s1 := s[startIndex:endIndex] //通过切片s初始化切片s1
    s :=make([]int,len,cap) //通过内置函数make()初始化切片s,[]int 标识为其元素类型为int的切片
    创建数组切片:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    package main

    import "fmt"

    func main() {
       
    	var myArray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}  //定义一个数组
    	var mySlice []int = myArray[:5]
    	var mySlice1 []int  //一个切片在未初始化之前默认为 nil，长度为 0
    	
    	fmt.Println("Elements of myArray: ")
    	for _,v := range myArray{
    	    fmt.Print(v, " ")
    	}
    	
    	fmt.Println("\nElements of mySlice: ")
    	
    	//元素遍历
    	for _, v := range mySlice {
    	    fmt.Print(v, " ")
    	}
    	fmt.Println()
    	
    	//动态增加	
    	mySlice = append(mySlice, 1, 2, 3)
    	fmt.Println(mySlice)
    	
    	//内容复制
    	copy(mySlice, mySlice1)
    	fmt.Println(mySlice1)
    	
    }

    关于动态追加,需要注意,如果定义 mySlice2 = []int{8, 9, 10} ,需要 mySlice = append(mySlice, mySlice2…)
    mySlice2后的三个点表示把mySlice2包含的元素打散后传入,等同于 mySlice = append(mySlice, 7, 8, 9)

  • 总结
    数组定长,定义后不可更改.切片的长度不固定
    数组的定义 初始化 遍历
    切片的定义 初始化 遍历 增加 复制,空切片初始化之前默认为nil,长度为0

您的鼓励是我写作最大的动力

俗话说，投资效率是最好的投资。 如果您感觉我的文章质量不错，读后收获很大，预计能为您提高 10% 的工作效率，不妨小额捐助我一下，让我有动力继续写出更多好文章。