Go语言数组与切片详解-优快云博客

本文链接：https://blog.youkuaiyun.com/Hello_MyDream/article/details/82973907

一.数组：

1.数组的定义

使用循环进行赋值；

使用循环进行for循环进行遍历。
使用for配合range对数组进行遍历。
使用println即可格式化输出数组元素。

package main

import "fmt"

func main(){     
        var a [10]int
	fmt.Println(len(a))
        //1.
	for i := 0; i < len(a); i++{
		a[i] = i+1
		fmt.Println(a[i])
	}
        //2.
	for _, data := range a  {
		fmt.Println(data)
	}

	for i, _ := range a  {
		fmt.Println(a[i])
	}
        //3.
        fmt.Println(a)
}

2.数组元素默认初始值

int(整型)：0

float64:0

string：空字符串

bool：false

        //int(整型):0
	var arr1[10] int
	for i, _ := range arr1 {
		fmt.Println(arr1[i])
	}

	//string:空字符串
	var arr2[10] string
	for i, _ := range arr2 {
		fmt.Println(arr2[i])
	}

	//float64:0
	var arr3[10] float64
	for i, _ := range arr3 {
		fmt.Println(arr3[i])
	}

	//bool:false
	var arr4[10] bool
	for i, _ := range arr4 {
		fmt.Println(arr4[i])
	}

3.数组的初始化

四种数组元素初始化方式：

全部初始化，使用var定义的数组
全部初始化，使用自动类型推导
部分元素初始化
指定元素初始化
通过初始化来确定数组的长度

package main

import "fmt"

func main(){

	//1.全部初始化
	var a [5]int = [5]int{0, 1, 2, 3, 4}
	for _, data := range a  {
		fmt.Println(data)
	}

	fmt.Println()

	//2.全部初始化：自动类型推导
	b := [5]int{0, 1, 2, 3, 4}
	fmt.Println(b)

	//3.部分初始化
	c := [5]int{0, 1, 2}
	fmt.Println(c)

	//4.指定元素初始化
	d := [5]int{0:5, 1:10}
	fmt.Println(d)

        //5.通过初始化来确定数组长度
	e := [...]int{1, 2, 3}
	fmt.Println(e)
}

4.同类型数组之间的直接赋值与比较

注意，赋值与比较时需要使用同类型的数组，不同类型的数组是不允许这样操作的。

package main

import "fmt"

func main(){
	//同类型的数组可以使用==、!=进行比较，以及使用=进行赋值
	arr := [3][4]int{{1}, {2}, {3}}
	fmt.Println(arr)

	var b [3][4]int = arr
	fmt.Println(b)

	//如果数组类型不同，那么IDE就会报错
	c := [3][4]int{{1}, {2}, {3}}
	fmt.Println(c == b)
}

五.多维数组

有多少个[]就是多少维度；

多少维的数组就用多少个for循环进行遍历。

二.切片：

1.切片的定义

var
自动类型推导
make(类型, 长度, 容量)，容量可以省略。
截取切片作为一个新的切片s[0 : 3 : 5]，第二个参数可以理解为以一个参数+3，而是结束位置，及不包含结束位置元素。此时容量同样可以省略，但是截取后得到的切片容量有第一个参数决定：原切片的容量减去以一个参数，含义即从首元素跳过了多少个个位置。

package main

import "fmt"

func main() {
	//1.切片的定义
	//1.
	a := []int{1, 2, 3}
	a = append(append(a, 4, 5), 6, 7)
	fmt.Println(a)
	fmt.Printf("%T", a)

	//2.
	var b []int = []int{1, 2, 3}
	fmt.Println(b)

	//3.切片类型 长度len() 容量cap()
	s := make([]int, 5, 10)
	for i := 0; i < len(s); i++ {
		s[i] = i + 1
		fmt.Println(s[i])
	}
	fmt.Println(s)
	fmt.Println(len(s))
	fmt.Println(cap(s))

	//4.切片的截取
	//5为切片的容量
	slice := s[0 : 3 : 5]
	fmt.Println(slice)

}

需要注意make的容量问题，正如上面所提到的。

操作	含义
s[n]	切片s中索引位置为n的项
s[:]	从切片s的索引位置0到len(s)-1处所获得的切片
s[low:]	从切片s的索引位置low到len(s)-1处所获得的切片
s[:high]	从切片s的索引位置0到high处所获得的切片，len=high
s[low:high]	从切片s的索引位置low到high处所获得的切片，len=high-low
s[low:high:max]	从切片s的索引位置low到high处所获得的切片，len=high-low，cap=max-low
len(s)	切片s的长度，总是<=cap(s)
cap(s)	切片s的容量，总是>=len(s)

2.切片的追加和拷贝

1.追加：append()

append函数在容量1024之前容量不足时扩容一倍，容量在1024(当然也包括1024)之后则不按照此规律扩容。

package main

import "fmt"

func main() {
	//1024之前扩容一倍
	slice := []int{1}
	old_cap := cap(slice)
	for i:=0;i<10000 ;i++  {
		slice = append(slice, i)
		if old_cap < cap(slice){
			old_cap = cap(slice)
			fmt.Println(old_cap)
		}
	}
}

以上代码输出结果数值如下：

2     4     8     16
32    64    128   256
512   1024  1280  1696
2304  3072  4096  5120
7168  9216  12288

2.拷贝：copy(dest， src)

package main

import "fmt"

func main() {
	src_slice := []int{1, 2, 3}
	dest_slice := []int{4, 5, 6, 7, 8, 9}
	//copy(dest_slice, src_slice)
	copy(src_slice, dest_slice)
	//fmt.Println(dest_slice)
	fmt.Println(src_slice)
}

另外：

结构体作为函数参数是：值传递--->使用指针解决：数组指针，区别于指针数组
数组作为函数参数是：值传递--->使用指针解决：结构体指针
切片作为函数参数是：引用传递(传地址)
map作为函数参数是：引用传递(传地址)
指针作为函数参数是：值传递