Go语言 数组、切片、map的区别

摘要

本篇只进行比较！

类型比较

数组：值类型
切片：引用类型
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"funcmain(){
     a :=[10]int{1,2,3,4,5}
    b := a[:]//声明切片b由数组a构造
    b[4]=6//只修改了切片b的第四个元素，数组a也将发生改变
    fmt.Println(a)
    fmt.Println(b)}

输出结果：

[1234600000][1234600000]

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

package main

import"fmt"funcmain(){
    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"funcmain(){

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

输出结果：

[12345][678910][12345678910]

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

声明比较

package main

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

输出结果：

[0000000000]truetrue

数组是不能被判断是否是

nil

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

nil

初始化比较

切片和map是可以被

make

初始化的，数组不行，数组必须在声明时初始化。
初始化之后才能有内存地址

package main

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

输出结果：

[]intmap[string]int

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

相互转换

数组可以转换成切片

package main

import"fmt"funcmain(){var a  [10]intvar b  = a[:]//不加[:]代表转化成数组
    fmt.Println(a)
    fmt.Println(b)}

输出结果：

[0000000000][0000000000]

修改值的区别

package main

import"fmt"funcmain(){
    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的值：[010000]
b的类型：map[string]int，b的值：map[Go语言:2]
c的类型：[5]int，c的值：[010000]

遍历比较

package main

import"fmt"funcmain(){
    a :=make([]int,3,10)
    b :=make(map[string]int,10)
    c :=[3]int{}
    a[0]=99
    b["Go语言"]=99
    c[0]=99for 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

遍历