本篇只进行比较！

类型比较

数组：值类型
切片：引用类型
map：引用类型

语法比较

数组的语法：var name [5]string []必须指定长度数字

var a  [10]int //声明数组

切片的语法：var name []string

var b []int    //声明切片

map的语法：var map变量名 map[key类型]vlaue类型 []中必须指定类型

var c map[string]int   //声明map类型

长度和容量规则

数组：固定长度，无容量。数组的长度在声明时就要给出
切片：动态长度，有容量，容量可以理解成可达到的最大长度
切片可以由数组构造来，不改变长度的情况下，共享内存，即切片的第一个元素发生变化，数组的第一个元素也将发生变化。

package main

import "fmt"

func main() {
 	a := [10]int{1,2,3,4,5}
	b := a[:]  //声明切片b由数组a构造
	b[4] =6 //只修改了切片b的第四个元素，数组a也将发生改变
	fmt.Println(a)
	fmt.Println(b)

}

输出结果：

[1 2 3 4 6 0 0 0 0 0]
[1 2 3 4 6 0 0 0 0 0]

上面不发生变化的只发生再数组转换成切片的情况下，如果数组与数组之间的赋值，是不会共享内存的

package main

import "fmt"

func main() {
	a := [...]string{"USA", "China", "India", "Germany", "France"}
	b := a // a的一个副本被分配给b
	b[0] = "Singapore"
	fmt.Println("a is ", a)
	fmt.Println("b is ", b)
	fmt.Printf("%T%T",a,b)
}

输出结果：

a is  [USA China India Germany France]
b is  [Singapore China India Germany France]
[5]string[5]string //都是数组类型，同类型

切片的长度可使用append参数，改变后的切片超出容量将不共享内存

package main

import "fmt"

func main() {

	a := [...]int{1,2,3,4,5} //a数组
	b := []int{6,7,8,9,10}   //b切片
	c := a[:]               //声明切片b由数组a构造
	c = append(c,b...) //必须是切片类型才能追加，并第二个切片加“...”
	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)

}

输出结果：

[1 2 3 4 5]
[6 7 8 9 10]
[1 2 3 4 5 6 7 8 9 10]

map：动态长度
map是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。

声明比较

package main

import "fmt"

func main() {
	var a  [10]int //声明数组
	var b []int    //声明切片
	var c map[string]int   //声明map类型
	fmt.Println(a)
	fmt.Println(b == nil)
	fmt.Println(c == nil)
}

输出结果：

[0 0 0 0 0 0 0 0 0 0]
true
true

数组是不能被判断是否是nil，因为数组必须在声明时申请内存
切片和map可以被判断是否是nil

初始化比较

切片和map是可以被make初始化的，数组不行，数组必须在声明时初始化。
初始化之后才能有内存地址

package main

import "fmt"

func main() {
	a := make([]int,5,10)
	b := make(map[string]int,10)
	fmt.Printf("%T\n",a)
	fmt.Printf("%T",b)
}

输出结果：

[]int
map[string]int

另外，new和make都是用于初始化的，它们两个区别在于new只能初始化值类型（int、string等），make只能初始化引用类型（切片、map、channel）

相互转换

数组可以转换成切片

package main

import "fmt"

func main() {
	var a  [10]int
	var b  = a[:] //不加[:]代表转化成数组
	fmt.Println(a)
	fmt.Println(b)
}

输出结果：

[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]

修改值的区别

package main

import "fmt"

func main() {
	a := make([]int,5,10)
	b := make(map[string]int,10)
	c := [5]int{}
	c[1]=10 //把数组c第一个元素修改成10
	a[1] = 10 //把切片a第一个元素修改成10
	b["Go语言"] = 1 // 把键值对存入到map中
	b["Go语言"] = 2  //把key是Go语言的vlaue修改成2
	fmt.Printf("a的类型：%T，a的值：%v\n",a,a)
	fmt.Printf("b的类型：%T，b的值：%v\n",b,b)
	fmt.Printf("c的类型：%T，c的值：%v\n",c,c)
}

输出结果：

a的类型：[]int，a的值：[0 10 0 0 0]
b的类型：map[string]int，b的值：map[Go语言:2]
c的类型：[5]int，c的值：[0 10 0 0 0]

遍历比较

package main

import "fmt"

func main() {
	a := make([]int,3,10)
	b := make(map[string]int,10)
	c := [3]int{}
	a[0] =99
	b["Go语言"]= 99
	c[0] =99

	for k,v :=range c{
		fmt.Println(k,v)
	}
	for k,v :=range b {
		fmt.Println(k,v)
	}
	for k,v :=range a {
		fmt.Println(k,v)
	}

}

都可以使用for-range遍历