Go 数组与切片

#### Go 数组与切片
***渡风渡尘缘,修行亦修心***
##### 数组
数组是可以存放多个同一类型的数据的集合,数组也是一种数据类型,它是值类型;  
数组如何定义?    
var 数组名 [数组大小]数据类型: var a [5]int 

package main

import "fmt"

func main(){
   var intArr [3]int
   intArr[0] = 10
   intArr[1] = 20
   intArr[2] = 30
   fmt.Println(intArr)
}

　　

数组在内存中的布局:  

  
1. 数组的地址可以通过数组名获取: &intArr;   
2. 数组的第一个元素地址就是数组的地址:;  
3. 数组的各个元素的地址间隔根据数组的类型决定: int64-> 8 字节,int32-> 4字节;  
4. 数组如果未给元素赋值,元素的默认值为类型的零值: int64->0,string->"",float64->0;  
5. 访问数组中的元素: 使用下标索引方式(左闭右开方式),这个与其它语言一样,超出下标索引将会出错,索引越界;
6. 数组的遍历有两种方式: for 传统方式; for range 方式 ;    

package main

import "fmt"

func main(){
   var a [5]int
   a[0] = 1
   a[1] = 2
   a[2] = 3
   // 默认值: a[3] = 0 , a[4] = 0
   // 下标越界: a[5] = 10  // 错误, 下标越界
   fmt.Println(a) //[1 2 3 0 0 ]
   fmt.Printf("a address is %p
",&a) // 0xc000078030
   fmt.Printf("a[0] address is %p
",&a[0]) //0xc000078030
   fmt.Printf("a[1] address is %p
",&a[1]) //0xc000078038
   fmt.Printf("a[2] address is %p
",&a[2]) //0xc000078040
   // 数组的遍历方式
   for i:=0;i<len(a);i++{
      fmt.Println(a[i])
   }
   // for range 方式 
   for k,v := range a {
      fmt.Println(a[k])
      fmt.Println(v)  // 这个值是元素的副本, 所以不建议在v 上操作: 取址或赋值;  
   }
}

　　

---
数组有多种初始化方式:  

import "fmt"

func main(){
   // 1. 字面量直接赋值
   var a [5]int = [5]int{1,2,3,4,5}
   var b = [5]int{6,7,8,9,0}
   // 2. 数组长度由编译器推导
   var c = [...]int{1,2,3,4,5,6}
   // 3. 根据索引位置直接赋值
   var d = [...]int{1:1,10:0,3:3}
   // 4. 类型推导
   f := [...]int{1:1,9:9,10:0}
   fmt.Println(a)
   fmt.Println(b)
   fmt.Println(c)
   fmt.Println(d)
   fmt.Println(f)
}

　　

---
数组使用注意事项
1. 数组是多个相同类型的集合,一旦声明或者定义了,数组的长度将是固定不变的,不能动态变化 ;  
2. 数组中的元素可以是任意类型,可以是值类型,也可以是引用类型,不可以混用;  
3. 数组创建后如果不赋值,将采用类型的零值 ;  
4. 数组属于值类型, 在默认情况下是传递数组是值传递,所以数组之间不会影响;  
5. 如果需要更改原数组,需要传递数组的地址(类似引用传递);  
6. 长度是数组类型的一部分,在传递参数时需要注意数组的长度;  

package main

import "fmt"

func test01(a [5]int){
   a[1] = 20
   fmt.Println(a)  //[1 20 3 4 5]
}
func test02(a *[5]int){
   a[1] = 20
   fmt.Println(*a) // [1 20 3 4 5]
}
func main(){
   var a = [5]int{1,2,3,4,5}
   test01(a)
   fmt.Println(a) // [1 2 3 4 5]
   // 如果需要修改原数组的值,需要传递数组的地址
   test02(&a)
   fmt.Println(a) // [1 20 3 4 5]
   // 传递参数时需要考虑数组的长度
   //var b = [3]int{1,2,3}
   //test01(b) // 错误, 数组的长度不正确
}

　　

在Go 编程中,数组的使用还是不太多, 因为不能动态的扩容,数组一般作为已经确定的数据使用;  
##### 切片
1. 切片是数组的一个引用, 所以切片属于引用类型,在进行参数传递时,属于引用传递;  
2. 切片的使用与数组类似: 遍历,访问等; 
3. 切片的长度是可以动态变化的,所以也可以说切片是动态变化的数组;  
4. 切片的基本语法 :
var 切片名 []类型

package main

import "fmt"

func main(){
   // 这里只演示切片如何使用,稍后再介绍切片如何声明与赋值操作
   // 声明并定义一个数组
   var a = [5]int{1,2,3,4,5}
   // 切片s 引用已经存在的数组a
   var s = a[:] // 这种方式引用所有的数组元素,也可引用一部分数组元素 var s = a[1:3]
   fmt.Printf("%T
",s)
   fmt.Println(s)
   fmt.Println(len(s)) // 5 切片的长度
   fmt.Println(cap(s)) // 5 切片的容量,容量和长度是可以动态变化;
}

　　

--- 
切片在内存中的布局

 
1. slice 是一下引用类型; 
2. 从底层上讲,slice 实际上就是一个结构体(稍后会学习到)
type slice struct {  
    ptr *[2]int  
    len   int   
    cap   int  
}
切片的初始化 

package main

import "fmt"

func main(){
   // 方式1 创建一个数组,让切片引用这个数组
   var a = [5]int{1,2,3,4,5}
   var s = a[:]
   // 同数组一样, 在赋值或取值时,仍然需要注意切片下标索引不可越界
   //s[10] = 0
   s[4] = 50
   fmt.Println(s)
   // 方式2
   // 切片是引用类型,所以声明后需要make 分配内存
   var b []int
   // make 分配内存,长度可以指定任意值,建议根据要存储的数据长度合适定义
   // make 参数,还可以定义切片的容量,如果定义了切片的容量,则要求容量大于切片的长度
   b = make([]int,5)
   fmt.Println(b)
   // 方式3
   // 字面量方式,声明后直接赋值
   var c = []int{1,2,3,4,5}
   fmt.Println(c)
}

　　

1. 方式1: 直接引用已经存在的数组,开发者对底层是可见的;  
2. 方式2: 通过make 创建的切片,程序也会创建一个数组,不过这个数组对开发者不可见,由程序自己维护;  
3. 方式3: 类似make;   
---
切片使用的注意事项:  
1. 切片的遍历与访问同数组一样, 这里就不写了;  
2. 切片定义后,不能直接使用,需要引用一个数组或make 分配内存给切片使用;  
3. 使用append 函数可以对切片进行动态扩容;  
4. 使用copy 函数可以对切片进行拷贝,拷贝后的切片是独立的, 在新的切片上操作对原切片没有影响;  
5. 切片是引用类型,在给函数传递参数(切片)时,属于引用传递;  

package main

import "fmt"

func test01(a []int){
   a[0] = 100
   fmt.Println(a)
}
func main(){
   var a = []int{1,2,3}
   fmt.Println(a)
   // 使用append 函数将切片扩容
   a = append(a,4)
   fmt.Println(a)
   // 使用copy 函数进行切片复制
   // 在使用copy 函数时需要注意以下几点:
   //1. 目标(dst)必须是已经声明并初始化过的
   //2. 如果目标的长度小于被复制的切片长度,则以目标的长度为准复制,超出部分不复制;
   var b []int
   b = make([]int,3)// 超出元素4,将不会被复制
   copy(b,a)
   fmt.Println(b)
   // 对新切片的操作不会影响到原来的切片
   b[1] = 10
   fmt.Println(a)
   fmt.Println(b)
   // 切片属于引用传递
   test01(a)
   fmt.Println(a)
}

　　

--- 
string 与slice 
在学习基本数据类型时我们学习了string 类型,知道它是由多个字节连接在一起的字符串;  
实际上string 底层是一个字节数组,所以string 也可以进行切片操作;  
但是string 是不可变的, 所以不能string[0]='x', 这种赋值操作; 如果需要更改,需要将string 转为[]byte 切片,更改完成后再转为string 类型;  

package main

import "fmt"

func main(){
   var a = "abcdef"
   // 可以进行切片处理
   fmt.Println(a[:3])
   // 不可以更改string 的值
   // a[1] = 'f' //这是错误的
   // 需要将string 转为 []byte 切片才可以操作
   var arr []byte
   arr = []byte(a)
   arr[1] = 'f'
   a = string(arr) // 更改完成后再将切片转为string 类型
   fmt.Println(a)
   // []byte 只能处理英文与数字,处理其它语言时需要将string 转为[]rune 切片
   var b = "你好啊"
   var arr2 []rune
   arr2 = []rune(b)
   arr2[0] = '我'
   b = string(arr2)
   fmt.Println(b)
}

　　个人微信公众号上有最新的文章,欢迎大家关注,一同交流学习