数组与切片

数组可以存放多个同一类型数据。数组也是一种数据类型，在golang中，数组是值类型。

一、数组

1、数组的定义

var 数组名 [数组大小]数据类型

var arr [5]int

2、数组的内存布局

package main

import "fmt"

func main() {
	var intArr [3]int
	//当定义完数组后，数组的各个元素有默认值0
	fmt.Println(intArr)

	intArr[0] = 10
	intArr[1] = 20
	intArr[2] = 30
	fmt.Println(intArr)
	fmt.Printf("intArr的地址 = %p intArr[0] 地址 = %p intArr[1] 地址 = %p intArr[2] 地址 = %p", &intArr, &intArr[0], &intArr[1], &intArr[2])
}

数组的地址可以通过数组名来获取 &intArr

数组的第一个元素的地址，就是数组的首地址
数组的各个元素的地址间隔是依据数组的类型决定

3、数组的使用

访问数组元素：数组名[下标]

package main

import "fmt"

func main() {
	var score [5]float64

	for i := 0; i < len(score); i++ {
		fmt.Printf("请输入第%d个元素的值\n", i+1)
		fmt.Scanln(&score[i])
	}

	for i := 0; i < len(score); i++ {
		fmt.Printf("score[%d] = %v\n", i, score[i])
	}
}

4、四种初始化数组的方式

package main

import "fmt"

func main() {
	var numInt [3]int = [3]int{1, 2, 3}
	fmt.Println("numInt = ", numInt)

	var numFloat = [3]float64{1.0, 9.4, 8.0}
	fmt.Println("numFloat = ", numFloat)

	var numInt32 = [...]int32{8, 9, 4}
	fmt.Println("numInt32 = ", numInt32)

	var numInt64 = [...]int64{1: 800, 0: 9000, 2: 899}
	fmt.Println("numInt64 = ", numInt64)

	strArr := [...]string{2: "mary", 0: "jack", 1: "tom"}
	fmt.Println("strArr = ", strArr)
}

5、数组的遍历

(1)、传统方式

package main

import "fmt"

func main() {
	var numInt [3]int = [3]int{1, 2, 3}
	for i := 0; i < len(numInt); i++ {
		fmt.Printf("arr[%v] = %v\t", i+1, numInt[i])
	}
}

(2)、for - range

package main

import "fmt"

func main() {
	var numInt [3]int = [3]int{1, 2, 3}
	for index, value := range numInt {
		fmt.Printf("arr[%v] = %v\t", index, value)
	}

	heroes := [...]string{"宋江", "吴用", "卢俊义"}
	for i, v := range heroes {
		fmt.Printf("i = %v v = %v\n", i, v)
		fmt.Printf("heroes[%d] = %v\n", i, heroes[i])
	}

	for _, v := range heroes {
		fmt.Printf("元素的值 = %v\n", v)
	}
}

第一个返回值index是数组的下标

第二个返回值value是下标位置的值

index和value都是仅在for循环内部可见的局部变量

遍历数组的时候，如果不想使用下标index，可以直接把下标index标为下划线

index和value的名称不是固定的，可以自行定义

6、数组使用的注意事项

(1)、数组是多个相同类型数据的组合,一个数组一旦声明/定义了,其长度是固定的, 不能动态变化。
(2)、数组中的元素可以是任何数据类型，包括值类型和引用类型，但是不能混用。
(3)、数组创建后，如果没有赋值，有默认值。数值类型数组:默认值为0 字符串数组: 默认值为"" bool数组: 默认值为false。
(4)、数组下标必须在指定范围内使用，否则报panic:数组越界。
(5)、go的数组属值类型，在默认情况下是值传递，因此会进行值拷贝。数组间不会相互影响。
(6)、如想在其它函数中，去修改原来的数组，可以使用引用传递(指针方式)。
(7)、长度是数组类型的一部分，在传递函数参数时 需要考虑数组的长度。

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	//1、创建一个 byte 类型的 26 个元素的数组，分别 放置'A'-'Z‘。使用 for 循环访问所有元素并打印出来。提示:字符数据运算 'A'+1 -> 'B'
	var myChars [26]byte
	for i := 0; i < 26; i++ {
		myChars[i] = 'A' + byte(i)
	}

	for i := 0; i < 26; i++ {
		fmt.Printf("%c", myChars[i])
	}
	fmt.Println()

	//2、请求出一个数组的最大值，并得到对应的下标。
	var intArr [6]int = [...]int{1, -1, 9, 90, 11, 9000}
	maxVal := intArr[0]
	maxValIndex := 0
	for i := 1; i < len(intArr); i++ {
		if maxVal < intArr[i] {
			maxVal = intArr[i]
			maxValIndex = i
		}
	}
	fmt.Printf("maxVal = %v maxValIndex = %v", maxVal, maxValIndex)

	//3、请求出一个数组的和和平均值。for-range
	var arr [5]int = [...]int{1, -1, 9, 90, 12}
	sum := 0
	for _, val := range arr {
		sum += val
	}
	fmt.Printf("sum = %v avg = %v\n", sum, float64(sum)/float64(len(arr)))

	//4、随机生成五个数，并将其反转打印
	var randArr [5]int
	len := len(randArr)
	rand.Seed(time.Now().UnixNano())
	for i := 0; i < len; i++ {
		randArr[i] = rand.Intn(100)
	}
	fmt.Println("交换前~=", randArr)

	tmp := 0
	for i := 0; i < len/2; i++ {
		tmp = randArr[len-1-i]
		randArr[len-1-i] = randArr[i]
		randArr[i] = tmp
	}
	fmt.Println("交换后~=", randArr)
}

二、切片

切片是数组的一个引用，因此切片是引用类型，在进行传递时，遵守引用传递的机制。
切片的使用和数组类似，遍历切片、访问切片的元素和求切片长度len(slice)都一样。
切片的长度是可以变化的，因此切片是一个可以动态变化数组。
切片定义的基本语法:var 切片名 []类型 比如:var a [] int

package main

import "fmt"

func main() {
	var intArr [5]int = [...]int{1, 22, 33, 66, 99}

	slice := intArr[1:3]
	fmt.Println("intArr=", intArr)
	fmt.Println("slice 的元素是", slice)
	fmt.Println("slice 的元素个数", len(slice))
	fmt.Println("slice 的容量", cap(slice))
}

slice从底层来说，其实就是一个数据结构(struct结构体)

type slice struct{

　　ptr *[2]int

　　len int

　　cap int

}

1、切片的使用

(1)、定义一个切片，然后让切片去引用一个已经创建好的数组。

package main

import "fmt"

func main() {
	var arr [5]int = [...]int{1, 2, 3, 4, 5}

	var slice = arr[1:3]
	fmt.Println("arr=", arr)
	fmt.Println("slice 的元素是", slice)
	fmt.Println("slice 的元素个数", len(slice))
	fmt.Println("slice 的容量", cap(slice))
}

(2)、通过make创建切片

var 切片名 []type=make([]type,len,[cap])

type就是数据类型；len就是大小；cap指定切片容量，可选，如果分配了cap,则要求cap>=len。

package main

import "fmt"

func main() {
	var slice []float64 = make([]float64, 5, 10)
	slice[1] = 10
	slice[3] = 20

	fmt.Println(slice)
	fmt.Println("slice size is ", len(slice))
	fmt.Println("slice capacity is ", cap(slice))
}

通过make方式创建切片可以指定切片的大小和容量

如果没有给切片的各个元素赋值，那么就会使用默认值
通过make方式创建的切片对应的数组是由make底层维护，对外不可见，即只能通过slice去访问各个元素

(3)、定义一个切片直接就指定具体数组，使用原理类似make的方式

package main

import "fmt"

func main() {
	var strSlice []string = []string{"tom", "jack", "mary"}

	fmt.Println(strSlice)
	fmt.Println("strSlice size is ", len(strSlice))
	fmt.Println("strSlice capacity is ", cap(strSlice))
}

2、切片的遍历

package main

import "fmt"

func main() {
	//传统遍历方式
	var arr [5]int = [...]int{10, 20, 30, 40, 50}
	slice := arr[1:4]
	for i := 0; i < len(slice); i++ {
		fmt.Printf("slice[%v] = %v\t", i, slice[i])
	}
	fmt.Println()

	//for - range方式遍历切片
	for i, v := range slice {
		fmt.Printf("slice[%v] = %v\n", i, v)
	}
}

3、切片使用的注意事项

(1)、切片初始化时 var slice = arr[startIndex:endIndex]
说明:从arr数组下标为startIndex，取到下标为endIndex的元素(不含 arr[endIndex])。
(2)、切片初始化时，仍然不能越界。范围在 [0-len(arr)] 之间，但是可以动态增长.
var slice = arr[0:end] 可以简写 var slice = arr[:end]
var slice = arr[start:len(arr)] 可以简写: var slice = arr[start:]
var slice = arr[0:len(arr)] 可以简写: var slice = arr[:]
(3)、cap是一个内置函数，用于统计切片的容量，即最大可以存放多少个元素。
(4)、切片定义完后，还不能使用，因为本身是一个空的，需要让其引用到一个数组，或者make一个空间供切片来使用
(5)、切片可以继续切片

package main

import "fmt"

func main() {
	var arr [5]int = [...]int{10, 20, 30, 40, 50}
	slice := arr[1:4]
	for i, v := range slice {
		fmt.Printf("slice[%v] = %v\n", i, v)
	}

	slice2 := slice[1:2]
	slice2[0] = 100 //slice和slice2指向的数据空间是同一个，因此slice2[0]=100,slice[1]=100

	fmt.Println("slice2=", slice2)
	fmt.Println("slice=", slice)
	fmt.Println("arr=", arr)
}

 (6)、用 append 内置函数，可以对切片进行动态追加

package main

import "fmt"

func main() {
	//用 append 内置函数，可以对切片进行动态追加
	var slice []int = []int{100, 200, 300}
	slice = append(slice, 400, 500, 600)
	fmt.Println("slice ", slice)

	slice = append(slice, slice...)
	fmt.Println("slice= ", slice)
}

切片append操作的底层原理分析:

切片append操作的本质就是对数组扩容
go底层会创建一下新的数组newArr(安装扩容后大小)将slice原来包含的元素拷贝到新的数组newArr
slice重新引用到newArr
注意newArr是在底层来维护的，程序员不可见

(7)、切片的拷贝操作

package main

import "fmt"

func main() {
	var slice []int = []int{1, 2, 3, 4, 5}
	var slice2 = make([]int, 10)
	copy(slice2, slice)
	fmt.Println("slice= ", slice)
	fmt.Println("slice2= ", slice2)

	var a []int = []int{1, 2, 3, 4, 5}
	var sli = make([]int, 1)
	fmt.Println(sli)
	copy(sli, a)
	fmt.Println(sli)
}

copy(para1, para2)参数的数据类型是切片

slice和slice2的数据空间是独立，相互不影响

(8)、切片是引用类型，所以在传递时，遵守引用传递机制。

package main

import "fmt"

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

func main() {
	var slice []int
	var arr [5]int = [...]int{1, 2, 3, 4, 5}

	slice = arr[:]
	var slice2 = slice
	slice2[0] = 10

	fmt.Println("slice2 ", slice2)
	fmt.Println("slice ", slice)
	fmt.Println("arr", arr)

	var sli = []int{1, 2, 3, 4}
	fmt.Println("sli= ", sli)
	test(sli)
	fmt.Println("sli= ", sli)
}

4、string和slice

string底层是一个byte数组，因此string也可以进行切片处理

package main

import "fmt"

func main() {
	str := "hello@ddd.com"
	slice := str[6:]
	fmt.Println("slice= ", slice)
}

string和切片在内存的形式，以"abcd"画出内存示意图 

string是不可变的，也就说不能通过str[0]='z'方式来修改字符串。如果需要修改字符串，可以先将string -> []byte或者[]rune -> 修改 -> 重写转成string

package main

import "fmt"

func main() {
	str := "hello@ddd.com"

	arr := []byte(str)
	arr[0] = 'z'
	str = string(arr)
	fmt.Println("str= ", str)

	arr2 := []rune(str)
	arr2[0] = '北'
	str = string(arr2)
	fmt.Println("str= ", str)
}

编写一个函数fbn(n int) ,可以接收一个n int,能够将斐波那契的数列放到切片中。

package main

import "fmt"

func fbn(n int) ([]uint64) {
	fbnSlice := make([]uint64, n)
	fbnSlice[0] = 1
	fbnSlice[1] = 1

	for i := 2; i < n; i++ {
		fbnSlice[i] = fbnSlice[i-1] + fbnSlice[i-2]
	}
	return fbnSlice
}

func main() {
	fbnSlice := fbn(20)
	fmt.Println("fbnSlice= ", fbnSlice)
}