其他分享
首页 > 其他分享> > go之切片

go之切片

作者:互联网

定义

  切片是由数组建立的一种方便、灵活且功能强大的包装,切片本身不拥有任何数据。他们只是对现有数组的引用。切片底层以来于数组,是对数组的引用

  底层数组如果发生变化,切片也变了;切片发生变化,层数组也变化

切片定义

  基于数组生成切片

package main

import "fmt"

func main() {
	var a [10]int
	var s = a[:]
	fmt.Println(s)

}
//[0 0 0 0 0 0 0 0 0 0]

  注意点

package main

import "fmt"

func main() {
	var a [10]int
	//var s = a[:]  // 把数组从第0个位置切到最后一个位置,赋值给s切片
	var s []int=a[:]  // 中括号中只要不放任何东西就是切片,放了数字就是数组
	fmt.Println(s)
}

切片定义并初始化

  切片只定义不初始化,默认0值为nil

  通过make初始化

package main

import "fmt"

func main() {
	var s []int=make([]int,3,4)
	fmt.Println(s)
}
//[0 0 0]

  直接定义并初始化

package main

import "fmt"

func main() {
	var s []int=[]int{3,4,5}
	fmt.Println(s)
}
//[3 4 5]

切片追加元素

  数组不允许追加元素,切片可以

package main

import "fmt"

func main() {
	var a [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	var b []int = a[7:8]
	//b[0]=999
	//fmt.Println(a)  //[1 2 3 4 5 6 7 999 9 10]
	//fmt.Println(b)  //[999]


	b = append(b, 888)
	fmt.Println("切片b:", b) //切片b: [8 888]
	fmt.Println("数组a:", a) //数组a: [1 2 3 4 5 6 7 8 888 10]
	fmt.Println(len(b))    //切片长度是2
	fmt.Println(cap(b))    //切片容量是3


	b = append(b, 777)
	fmt.Println("切片b:", b) //切片b: [8 888 777]
	fmt.Println("数组a:", a) //数组a: [1 2 3 4 5 6 7 8 888 777]
	fmt.Println(len(b))    //切片长度是3
	fmt.Println(cap(b))    //切片容量是3

	//现在长度是3,容量是3,如果再追加666的话久超过了底层数组大小
	//如果超过底层数组大小:1.重新申请一个底层数据,把切片的值copy过去,2.切片的容量变为原来切片容量的两倍,3.现在这个切片跟原来的数组久没有关系了
	b=append(b,666)
	fmt.Println("切片b:",b)  //切片b: [8 888 777 666]
	fmt.Println("数组a:",a)  //数组a: [1 2 3 4 5 6 7 8 888 777]
	fmt.Println(len(b))  //切片长度是4
	fmt.Println(cap(b))  //切片长度是6

	//修改切片,不会影响最原来的数组
	b[0]=9
	a[9]=7
	fmt.Println("切片b:",b)  //切片b: [9 888 777 666]
	fmt.Println("数组a:",a)  //数组a: [1 2 3 4 5 6 7 8 888 7]
}

make创建切片

import "fmt"

func main() {
	var s =make([]int,3,4)
	fmt.Println(s)  //[0 0 0]
	fmt.Println(len(s))  //3
	fmt.Println(cap(s))  //4
}

切片的零值

  切片的零值为:nil

import "fmt"

func main() {
	var s []int=make([]int,2,2)  // 定义,有初始化
	fmt.Println(s[0])  //0
	if s==nil{
		fmt.Println("我是nil")
	}else {
		fmt.Println("我不是nil")  //我不是nil
	}
}
import "fmt"

func main() {
	var s []int  // 只定义,没有初始化
	fmt.Println(s)  //[]
	if s==nil{
		fmt.Println("我是nil")  //我是nil
	}else {
		fmt.Println("我不是nil")  
	}
}

切片的参数传递

  切片是引用类型,当参数传递在函数中修改会影响原来的

  go语言的参数传递都是copy传递,因为切片是个引用(地址,指针),把切片复制了一份传入了。

  由于切片是引用,在函数中根据引用改了值,改了原来的底层数组,大家都会手影响

package main

import "fmt"

func main() {
	var s []int=[]int{3,4,5}
	testS(s)
	fmt.Println("调用之后:",s)  //调用之后: [999 4 5]
}

func testS(s []int)  {  // 在函数中追加切片,一定要注意有没有超过容量,如果超过了容量,超过后再改的值,就不会影响原来的了
	fmt.Println(s)   //[3 4 5]
	s[0]=999  //[999 3 5]
	s=append(s,888,777)  //[999 4 5 888 777]
	s[1]=666  //[999 666 5 888 777]
	fmt.Println(s)  // [999 666 5 888 777]

}
package main

import "fmt"

func main() {
	var s []int = make([]int, 3, 4)
	testS(s)
	fmt.Println("调用之后:", s) //调用之后: [999 0 0]
}
func testS(s []int) { // 在函数中追加切片,一定要注意有没有超过容量,如果超过了容量,超过后再改的值,就不会影响原来的了
	fmt.Println(s)          //[0 0 0]
	s[0] = 999              //[999 0 0]  会影响原来的
	s = append(s, 888, 777) //[999 0 0 888 777],追加了超过了底层数组,不依赖于原来的数组了
	s[1] = 666              //[999 666 0 888 777]  // 不影响原来的数组了
	fmt.Println(s)          // [999 666 0 888 777]
}

copy切片

package main

import "fmt"

func main() {
	var a [100000]int
	var b =a[:3]
	fmt.Println(b)  //[0 0 0]
	b[0]=999
	b[2]=222
	fmt.Println(b)  //[999 0 222]  使用b,虽然只用3个值,但是底层数组很大,内存占用大
	//把b这个切片,copy另一个新切片上
	var c= make([]int,2,2)  // 基于的底层数组,数组大小是3
	copy(c,b)
	fmt.Println(c)  //[999 0]
}

多维切片

  每一层都要初始化

import "fmt"

func main() {
	//var s [][]int=make([][]int,2,2)
	//var s [][]int
	//fmt.Println(s[0])  //[]
	//fmt.Println(s[0][0])  // 报错,第二层没有初始化

	// 循环切片  两层for循环,跟数组一样
	var s [][]int=[][]int{{2,3},{4,4,4,5},{6,7,8}}
	fmt.Println(s)  //[[2 3] [4 4 4 5] [6 7 8]]
	fmt.Println(s[0][1])  //3
}

  

标签:int,fmt,切片,Println,数组,go,main
来源: https://www.cnblogs.com/zhaoyuanshi/p/16699746.html