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()
}

go 数组与切片

切片概念

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,而空切片对应的指针是个地址。

  • 切片的内存布局:

go 数组与切片

  • 通过make创建切片语法如下:
var slice []type = make([]type, len)
slice := make([]type, len)
slice := make([]type, len, cap)

go 数组与切片

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))
}

go 数组与切片

  • 用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)
}

go 数组与切片

  • 遍历切片
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)
}

go 数组与切片

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

go 数组与切片

  • 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))
}

go 数组与切片

排序和查找操作

排序操作主要都在 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必须有序
上一篇:CSS:在IE浏览器下,元素下沉一行的解决办法


下一篇:BZOJ1051:受欢迎的牛(并查集 / Tarjan)