go语言array, slice, map(四)

array

go语言数组，定义方法如下:

var arr [n]type

• 声明方法

var arr [10]int
arr[0] = 10
arr[1] = 2

//简短声明
a := [3]int{1, 2, 3}
b := [10]int{1, 2, 3}   //声明一个长度为10的int数组， 
                                //其中三个元素为1,2,3其他元素初始值为0
c := [...]int = {1, 2, 3} //可以省略长度，go语言会自动计算长度

• go语言也支持多维数组

doubleArray：= [2][4]int{[4]int{1, 2, 3, 4}, [4]int{5, 6, 7, 8}}
//还可以用下面的方法声明
easyArray := [2][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}}

slice

slice 是一个引用类型，并不是真正意义上的动态数组，slice总是指向一个底层array，slice的声明可以像array一样，只是不需要长度

//和声明array一样，只是少了长度
var fslice []int

• 声明并slice，并初始化数据

slice := []byte {'a', 'b', 'c', 'd'}

• slice 可以从一个数组或一个已经存在的slice再次声明，slice通过array[i:j]来获取，其中i是数组的开始位置，j是结束位置，但不包含array[j]，它的长度是 j - i

//声明数组
var ar = [10]byte {'a', 'b', 'c', 'd', 'e', 'f'}

//声明slice
var a, b []byte

a = ar[2:4]  //ar[2], ar[4]
b = ar[:4]   //ar[0] , ar[1], ar[2], ar[3]

• slice的使用注意事项和内建函数

func main() {
	//slice 指向数组，声明时不需要加长度
	var fslice, s1 []int
	//如果在初始化的时候没有赋值，用如下方法再次赋值是错误的，slice只是一个引用类型
	//声明并不会分配空间，只是一个指针，只能指向一个数组
	//改变数组或者同指向一个数组的slice中的值，数组或指向同意数组的slice的相应的值都会改变
	/*
	fslice[0] = 10
	fslice[1] = 20
	*/
	arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
	fslice = arr[2:8]
	s1 = arr[:6]
	s1[3] = 100
	arr[5] = 200
	fmt.Println(fslice)
	fmt.Println(s1)
	fmt.Println(arr)

	//slice的内置函数
	fmt.Println(len(s1))  //len 获取slice的内置函数
	s2 := append(s1, 100) //向slice中追加元素并返回新的slice
	fmt.Println(s2)
	var s3 []int
	copy(s2, s3)
	fmt.Println(s3)
	fmt.Println(cap(s1)) //cap获取slice的最多容量，slice的最多容量等于原数组的长度
}

map

• map是无序的，每次打印出来的map都会不一样，它不能通过index获取，而必须通过key获取
• map的长度是不固定的，也就是和slice一样，也是一种引用类型
• 内置的len函数也可用于map，返回map拥有的key数量
• 可以通过 m[“key”] 的方式修改map的值

package main

import "fmt"

//map 即python中字典的概念
//map 和slice一样，是一种引用类型
func main() {
	//1.声明一个map，使用之前需要用make来初始化
	var numbers map[string] int
	 numbers = make(map[string] int)
	//numbers := make(map[string]int)
	numbers["one"] = 1
	fmt.Println(numbers)

	//2.另外一种初始化方式
	m := make(map[string] int)
	m["one"] = 1
	m["two"] = 2
	m["three"] = 3
	fmt.Println(m)
	fmt.Println(m["one"])

	//2.map的内置函数
	//判断map中是否存在key，存在返回true，不存在返回false
	n, ok := m["one"]
	if ok {
		fmt.Println("one is exite", n)
	} else {
		fmt.Println("one is not exite")
	}

	//删除map中的元素
	delete(m, "three")
	fmt.Println(m)
}