go 数组与切片

数组概念

1、数组：是同一种数据类型的固定长度的序列。

2、数组定义：var a [len]int，比如：var a[5]int，一旦定义，长度不能变

3、长度是数组类型的一部分，因此，var a[5] int和var a[10]int是不同的类型

4、数组可以通过下标进行访问，下标是从0开始，最后一个元素下标是：len-1

5、访问越界，如果下标在数组合法范围之外，则触发访问越界，会panic

6、数组是值类型，因此改变副本的值，不会改变本身的值

7、数组内的内存地址是连续的

 

数组初始化

var age0 [5]int = [5]int{1,2,3}
var age1 = [5]int{1,2,3,4,5}
var age2 = […]int{1,2,3,4,5,6}
var str = [5]string{3:”hello world”, 4:”tom”}

 

数据遍历常用两种方法：

• 方法一

for i := 0; i < len(a); i++ {
}

• 方法二

for index, val := range a {
}

 

案例一：定义一个a数组，传入函数test的数组是副本，不会改变原a数组的内容。

package main

import "fmt"

func test(arr [5]int) {
	arr[0] = 1000
}


func main() {
	var a [5]int
	test(a)
	fmt.Println(a)
}

 

案例二：定义一个a数组，传入函数test的是a数组的指针，会改变原a数组的内容

package main

import "fmt"

func test3(arr *[5]int) {
	(*arr)[0] = 1000
}

func main() {
	var a [5]int
	test3(&a)
	fmt.Println(a)
}

 

多维数组

package main

import "fmt"

func testArray() {
	var a [2][5]int = [...][5]int{{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}}

	for row, v := range a {
		for col, v1 := range v {
			fmt.Printf("(%d,%d)=%d ", row, col, v1)
		}
		fmt.Println()
	}
}

func main() {
	testArray()
}

 

切片概念

1、切片：切片是数组的一个引用，因此切片是引用类型

2、切片的长度可以改变，因此，切片是一个可变的数组

3、切片遍历方式和数组一样，可以用len()求长度

4、cap可以求出slice最大的容量，0 <= len(slice) <= (array)，其中array是slice引用的数组

5、切片的定义：var 变量名 []类型，比如 var str []string var arr []int

切片初始化：var slice []int = arr[start:end]，包含start到end之间的元素，但不包含end 
var slice []int = arr[0:end]可以简写为 var slice []int=arr[:end]
var slice []int = arr[start:len(arr)] 可以简写为 var slice[]int = arr[start:]
var slice []int = arr[0, len(arr)] 可以简写为 var slice[]int = arr[:]
如果要切片最后一个元素去掉，可以这么写： slice = slice[:len(slice)-1]

• nil切片和空切片

var nilSlice []int  //nil切片
slice:=[]int{} //空切片

它们的长度和容量都是0，但是它们指向底层数组的指针不一样，nil切片意味着指向底层数组的指针为nil，而空切片对应的指针是个地址。

• 切片的内存布局：

 

• 通过make创建切片语法如下：

var slice []type = make([]type, len)
slice  := make([]type, len)
slice  := make([]type, len, cap)

func testSliceCap() {
	a := make([]int, 5, 10)
	a[4] = 100
	b := a[2:3]
	fmt.Printf("a=%#v, len(a) = %d, cap(a)=%d\n", a, len(a), cap(a))
	fmt.Printf("b=%#v, len(b) = %d, cap(b)=%d\n", b, len(b), cap(b))
}

• 用append内置函数操作切片

func testAppend() {
	var a []int
	a = make([]int, 5)
	var b []int = []int{10, 11, 12, 14}
	a = append(a, b...)
	fmt.Printf("a:%#v\n", a)
}

• 遍历切片

for index, val := range slice {
}

•  切片拷贝copy

func testCopy() {
	var a []int = []int{1, 2, 3, 4, 5, 6}
	b := make([]int, 10)
	copy(b, a)
	fmt.Println(b)
}

• string底层就是一个byte的数组，因此，也可以进行切片操作

• string本身是不可变的，因此要改变string中字符，需要如下操作：

字符串转成字符切片，改完后再转成字符串

func testStrSlice() {
	var str = "hello world"
	var b []byte = []byte(str)
	b[0] = 'a'
	str1 := string(b)
	fmt.Printf("str1:%s, %d\n", str1, len(str))
}

 

排序和查找操作

排序操作主要都在 sort包中，导入就可以使用

• sort.Ints对整数进行排序， sort.Strings对字符串进行排序, sort.Float64s对浮点数进行排序

func testIntSort() {
	var a = [...]int{1, 8, 38, 2, 348, 484}
	sort.Ints(a[:])
	fmt.Println(a)
}

• sort.SearchInts(a []int, b int) 从数组a中查找b，前提是a必须有序

func testIntSearch() {
	var a = [...]int{1, 8, 38, 2, 348, 484}
	sort.Ints(a[:])
	index := sort.SearchInts(a[:], 348)
	fmt.Println(index)
}

• sort.SearchFloats(a []float64, b float64) 从数组a中查找b，前提是a必须有序

• sort.SearchStrings(a []string, b string) 从数组a中查找b，前提是a必须有序