其他分享
首页 > 其他分享> > GOGOUP-8.数组和切片

GOGOUP-8.数组和切片

作者:互联网

万丈高楼平地起-数组和切片

一、数组

  1. 数组的特点:数组一旦声明后,其元素类型和长度就不在变化,如果要存储更多的值,只能创建新的数组,让后把原来的数组复制过去
  2. golang 数组在函数调用是值传递,这个和其他语言有区别
  3. 数组的声明方式
  4. 数组代码展示
    package main
    
    import "fmt"
    
    //数组的声明
    func main() {
    	//指定数组的类型 int  指定数组长度5
    	var myArray1 [5]int
    	//由于声明了数组myArray1、但是没初始化,这是时候数组里面对于的是元素类型的零值
    	for _, v := range myArray1 {
    		fmt.Println(v)
    	}
    	//重新赋值
    	myArray1 = [5]int{1, 2, 3, 4, 5}
    	for _, v := range myArray1 {
    		fmt.Println(v)
    	}
    	//定义并初始化 一个长度为10的数组,由于后五没有赋值所有都是零值
    	myArray2 := [10]int{1, 2, 3, 4, 5}
    	for _, v := range myArray2 {
    		fmt.Println(v)
    	}
    
    	//自动推导数组长度
    	fmt.Println("自动推导数组长度--------------")
    	myArray3 := [...]int{1, 2, 3}
    	for _, v := range myArray3 {
    		fmt.Println(v)
    	}
    
    	//多维数组
    	fmt.Println("多维数组--------------")
    	dArray1 := [...][3]int{{1, 2, 3}, {3, 5}}
    	for _, v := range dArray1 {
    		for _, item := range v {
    			fmt.Println(item)
    		}
    	}
    
    }
    

二、切片

  1. 切片是基于数组的
  2. 切片是一个很小的对象,它对底层的数组(内部是通过数组保存数据的)进行了抽象,并提供相关的操作方法。切片是一个有三个字段的数据结构,这些数据结构包含 Golang 需要操作底层数组的元数据
  3. 切片的声明
    package main
    
    import "fmt"
    
    func main() {
    
    	//声明要个长度,和容量都是1的切片s1
    	s1 := make([]int, 1)
    	//切片元素赋值
    	s1[0] = 10
    	fmt.Println("s1[0]= ", s1[0])
    	fmt.Println("s1 length= ", len(s1), "s1 cap= ", cap(s1))
    
    	//按需增加切片的容量。Golang 内置的 append() 函数会处理增加长度时的所有操作细节
    	s1 = append(s1, 10)
    	fmt.Println("s1 length= ", len(s1), "s1 cap= ", cap(s1))
    
    	//声明要个长度3、容量是5的切片
    	s2 := make([]int, 3, 5)
    	fmt.Println("s2 length= ", len(s2), "s2 cap= ", cap(s2))
    
    	//声明一个长度和容量都是4的切片
    	s3 := []int{10, 20, 30, 40}
    	fmt.Println("s3 length= ", len(s3), "s3 cap= ", cap(s3))
    
    	//切片声明切片
    	s5 := make([]int, 10)
    	s5[0] = 0
    	s5[1] = 1
    	s5[2] = 2
    	s5[3] = 3
    	s5[4] = 4
    	fmt.Println("s5 length= ", len(s5), "s5 cap= ", cap(s5))
    
    	//这里注意下cap()的计算,是从切片开始指针所指向的数组下标到数组结尾的长度
    	s6 := s5[:3]
    	fmt.Println("s6 length= ", len(s6), "s6 cap= ", cap(s6)) //cap(s6)=10 s6切片指针指向了数组最小下标0
    
    	s7 := s5[2:4]
    	fmt.Println("s7 length= ", len(s7), "s7 cap= ", cap(s7)) //cap(s7)=8 s7切片指针指向了数组下标2 实际底层数组长度是10
    
    	//定义一个nil 切片
    	var s8 []int
    	fmt.Println("s8 is nil= ", (s8 == nil), "s8 length= ", len(s8), "cap= ", cap(s8))
    
    	//切片Copy
    	s9 := []int{10, 20, 30}
    	s10 := make([]int, 5)
    	count := copy(s10, s9) //copy(目标,源)
    	fmt.Println(count)
    	fmt.Println(s10)
    
    }
    
  4. 切片在函数调用时候 是copy的切片对象本身,即切片指针 长度 容量。而底层的数组是不会拷贝。故而有很好的效率

标签:fmt,cap,GOGOUP,切片,数组,Println,s1
来源: https://www.cnblogs.com/nextworld/p/14981041.html