Golang 数组、切片、映射

定义数组

var arr1 [5]int   //整型类型
fmt.Println(arr1) //[0 0 0 0 0]
//赋值
arr1 = [5]int{1, 2, 3, 4, 5}
fmt.Println(arr1) //[1 2 3 4 5]

var arr2 [6]*int  //整型指针数组
fmt.Println(arr2) //[<nil> <nil> <nil> <nil> <nil> <nil>]

var arr3 [2][3]int //二维数组
fmt.Println(arr3)  //[[0 0 0] [0 0 0]]

//	使用简短的格式
arr4 := [5]int{2, 4, 6, 8, 10}
fmt.Println(arr4) //[2 4 6 8 10]

//其他方式，如果长度的位置是... 表示数组长度是根据后面的数据元素个数来计算
arr5 := [...]int{2, 3, 4, 5, 6, 7}
fmt.Println(arr5, len(arr5)) //[2 3 4 5 6 7]  6

//	指定数组的索引来赋值
arr6 := [...]int{5: 10, 7: 23}
//将数组下标为5的元素赋值为10，将数组下标为7的元素赋值为23
//数组长度为8
fmt.Println(arr6, len(arr6)) //[0 0 0 0 0 10 0 23] 8

arr7 := [2][3]int{{1, 2, 3}, {4, 5, 6}}
fmt.Println(arr7) //[[1 2 3] [4 5 6]]

　　

数组访问与数组长度

arr1 := [5]int{2, 4, 6, 8, 10}
fmt.Println(arr1)                 // [2 4 6 8 10]
fmt.Println("length:", len(arr1)) //length: 5
//	arr1[5] = 100  //出错，数组越界
arr1[0] = 99
fmt.Println(arr1) //[99 4 6 8 10]

arr2 := [2][3]int{{1, 2, 3}, {4, 5, 6}}
fmt.Println(len(arr2))    //2
fmt.Println(len(arr2[0])) //3
fmt.Println(arr2[1][1])   //5

　　

数组遍历

arr1 := [5]int{2, 4, 6, 8, 10}
for i := 0; i < len(arr1); i++ {
	fmt.Println(arr1[i]) //2 4 6 8 10
}
for i, v := range arr1 {
	fmt.Print(i, "=>", v) // 0=>2,1=>4,2=>6,3=>8,4=>10
}
//	不需要索引的时候，可以将用_代替i
for _, v := range arr1 {
	fmt.Println(v) //2,4,6,8,10
}

　　

数组作为函数参数

　　数组作为函数作为参数时，如果是给形参传递数组名，那么就是传值操作，传递的是数组的副本，修改副本的内容，并不会影响实参。

　　要想在函数中对数组的修改作用到实参，可以用数组指针，即->使用指针的形式，将数组的地址传递给函数，并且函数定义时，接收一个指针类型的参数，那么就可以对数组内部进行修改，但是不能修修改数组长度。

package main

import "fmt"

func Double(arr [5]int) [5]int {
	for i := 0; i < 5; i++ {
		arr[i] *= 2
	}
	return arr
}

//接收的指针类型，即数组的地址
//注意这里的形参要写成 arr *[5]int   不要写成arr [5]*int
//arr [5]*int表示的是有五个元素的数组，每个元素是一个指针，即5个指针
//arr *[5]int表示的是一个指针，这一个指针指向一个拥有5个元素的数组，每个元素时一个int型变量
func Triple(arr *[5]int) {
	for i := 0; i < 5; i++ {
		arr[i] *= 3
	}
}
func main() {
	var arr2 [6]*int  //整型指针数组
	fmt.Println(arr2) //[<nil> <nil> <nil> <nil> <nil> <nil>]
	arr := [5]int{1, 2, 3, 4, 5}
	fmt.Println(arr) //[1 2 3 4 5]

	arr1 := Double(arr)
	fmt.Println(arr1) //[2 4 6 8 10]
	fmt.Println(arr)  //[1 2 3 4 5]

	Triple(&arr)
	fmt.Println(arr) //[3 6 9 12 15]
}

　　

数组类型、数组比较

　　数组的长度一旦确定，就不能再改变。如果要改变，只能转换为slice，但是用了slice之后，改变的是slice的长度，但是数组长度始终不变。

　　数组长度不同，那么数组就不是同一个类型，不能相互赋值-->参数传递。

　　相同类型的数组可以进行比较，这里的类型不只是数组元素的类型，也包括数组的长度都要相同，才能进行比较。

package main
import "fmt"
func Double(arr [5]int) [5]int {
	for i := 0; i < 5; i++ {
		arr[i] *= 2
	}
	return arr
}

func main() {
	arr1 := [5]int{1, 2, 3, 4, 5}
	Double(arr1) //正确   形参和实参都是[5]int类型，注意[5]int是一个类型

	arr2 := [6]int{1, 2, 3, 4, 5, 6}
	Double(arr2) //错误，不能将类型为[6]int的实参，赋值给类型为[5]int的形参
	//[5]int和[6]int是两个不同的类型
}

　　

　　

创建切片

var slice []int
//定义一个空切片，注意上面[]中没有指定长度，如果指定长度，就代表是数组了
fmt.Println(slice) //[]

slice1 := []int{1, 2, 3, 4, 5}
//创建一个长度和容量为5的切片
fmt.Println(slice1)                   //[1 2 3 4 5]
fmt.Println(len(slice1), cap(slice1)) //5 5

slice2 := []int{5: 10}
//创建一个长度和容量为6的切片
fmt.Println(slice2)                   //[0 0 0 0 0 10]
fmt.Println(len(slice2), cap(slice2)) //6 6

//使用make创建切边
//make(type,len,cap)，未指定cap是，cap和len相等
slice3 := make([]int, 5, 10)
fmt.Println(slice3, len(slice3), cap(slice3)) //[0 0 0 0 0] 5 10
slice4 := make([]int, 6)
fmt.Println(slice4, len(slice4), cap(slice4)) //[0 0 0 0 0 0] 6 6

//	利用数组创建切片
//[strat:end]左闭右开，start省略时，默认为0；end省略时默认为数组或者切片长度
arr := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
slice5 := arr[3:]
fmt.Println(slice5)  //[3 4 5 6 7 8 9]

slice6 := arr[:7]
fmt.Println(slice6)  //[0 1 2 3 4 5 6]

slice7 := arr[4:8]
fmt.Println(slice7)  //[4 5 6 7]

slice8 := arr[:]
fmt.Println(slice8)  //[0 1 2 3 4 5 6 7 8 9]

　　通过len函数求的切片长度，判断是否为空。

 

append函数

　　使用append函数后，返回的是一个slice类型，不是数组类型

slice := []int{1, 2, 3, 4, 5}
fmt.Println(slice) //[1 2 3 4 5]

//追加元素
slice = append(slice, 6)
fmt.Println(slice) //[1 2 3 4 5 6]

//追加切片
s1 := []int{99, 100}
//注意下面的...表示解构，即，将切片的内容展开后填充到该位置
slice = append(slice, s1...)
fmt.Println(slice)

　　不能对数组调用append函数，即，append函数的第一个参数必须是slice。

 

copy函数

　　copy(destination，resource)，复制之后，dest的长度并不会改变，即使复制给他的切片长度远大于它。

//长的slice复制到短的slice
s1 := []int{1, 2, 3, 4, 5}
s2 := []int{10, 20, 30, 40}
copy(s2, s1)
fmt.Println(s2) //[1 2 3 4]

//短的slice复制到长的slice
s3 := []int{2, 3, 4}
s4 := []int{9, 8, 7, 6, 5}
copy(s4, s3)
fmt.Println(s4) //[2 3 4 6 5]

//相同长度的slice进行复制
s5 := []int{1, 2, 3}
s6 := []int{4, 5, 6}
copy(s6, s5)
fmt.Println(s6) //[1 2 3]

　　不能使用copy进行数组的复制操作，即，copy的两个参数都必须是slice。

 

slice作为函数参数

　　将数组传递给函数之后，在函数中操作的是数组的副本。虽然可以使用数组指针形式传递，但是更通用的是使用slice，使用slice之后，可以通过在函数中修改slice，来达到修改数组的目的。

package main

import "fmt"

//参数是数组类型
func Double(arr [5]int) {
	for i := 0; i < 5; i++ {
		arr[i] *= 2
	}
}

//类型是slice类型
func Triple(slice []int) {
	for i := 0; i < len(slice); i++ {
		slice[i] *= 3
	}
}
func main() {
	arr := [5]int{1, 2, 3, 4, 5}
	Double(arr)
	fmt.Println(arr)  //[1 2 3 4 5]

	//数组转换为切片
	slice := arr[:]
	Triple(slice)
	fmt.Println(arr)  //[3 6 9 12 15]
}

　　

创建map

//定义空的映射，默认值为nil
var m1 map[int]string
fmt.Println(m1) //map[]
//再进行初始化
m1 = map[int]string{
	1: "hello",
	8: "world", //注意这种写法，末尾的逗号不可省
}
fmt.Println(m1) //map[1:hello 8:world]

//使用make创建映射，注意此时最多只用两个参数，
//一个是map的映射类型，一个map的容量，容量可以省略
//但是没有len这一个参数，即不能指定长度这一项
m2 := make(map[int]string, 100)
fmt.Println(m2, len(m2))

m3 := make(map[string][]string)
m3["server"] = []string{"apache", "nginx"}
m3["language"] = []string{"php", "golang", "python"}
fmt.Println(m3) //map[server:[apache nginx] language:[php golang python]]

//创建映射，同时初始化，此时不需要使用make
m4 := map[int]string{1: "demo", 2: "test"}
fmt.Println(m4) //map[1:demo 2:test]

　　

删除map元素

//字符串映射到string类型的切片
m1 := map[string][]string{
	"server":   []string{"apache", "nginx"},
	"language": []string{"php", "python", "golang"},
}
fmt.Println(m1) //map[server:[apache nginx] language:[php python golang]]

//删除没有的key，不报错
delete(m1, "client")
fmt.Println(m1) //map[server:[apache nginx] language:[php python golang]]

delete(m1, "server")
fmt.Println(m1) //map[language:[php python golang]]

　　

查找map元素

//字符串映射到string类型的切片
m1 := map[string][]string{
	"server":   []string{"apache", "nginx"},
	"language": []string{"php", "python", "golang"},
}
fmt.Println(m1) //map[server:[apache nginx] language:[php python golang]]

//访问一个不存在的元素，不会报错，返回类型零值
fmt.Println(m1["client"]) //[]

v, exists := m1["client"]
fmt.Println(v, exists) //[] false

v, exists = m1["server"]
fmt.Println(v, exists) //[apache nginx] true

　　

遍历map

//字符串映射到string类型的切片
m1 := map[string][]string{
	"server":   []string{"apache", "nginx"},
	"language": []string{"php", "python", "golang"},
}
for key, value := range m1 {
	fmt.Println(key, "=>", value)
}
//server => [apache nginx]
//language => [php python golang]

　　映射是无序的，所以遍历多次的结果，元素的顺序不一定完全相同

 

map注意事项

　　1、map之间不能进行比较，但是可以和nil进行比较

　　2、不能对map取地址，因为map本就是引用类型

var m0 map[int]string
fmt.Println(m0 == nil) //true

var m1 map[int]string
fmt.Println(m0 == m1) //不能进行比较，会报错

m2 := map[int]string{1: "one", 2: "two"}
fmt.Println(m2 == nil) //false

　　

map作为函数参数

package main

import "fmt"

//接受一个map
func Show(m map[int]string) {
	m[1] = "three"
	m[3] = "four"
}
func main() {
	m1 := map[int]string{
		1: "one",
		2: "two",
	}
	fmt.Println(m1) //map[1:one 2:two]

	Show(m1)
	fmt.Println(m1) //map[3:four 1:three 2:two]
}

　　将map作为函数的参数，在函数中修改map，会直接影响到实参，因为map是引用类型。