golang知识点-数组、切片

    golang当中除了基础类型之外，还有其他的常用类型。其中能够用来同类型数据的数组，切片。
数据的大小不可变更。slice大小可变更，底层的基础数据结构也是不可变数组。在进行扩展时，是通过copy底层数组值，创建新数组来实现的。
后续将介绍这两个存放同一数据类型的容器进行介绍。包括：

•  如何定义及初始化
•  具备哪些数据属性
• 如何进行操作：存、取、删

数组

    数组是同一类型元素的集合。例如，整数集合 5,8,9,79,76 形成一个数组。Go 语言中不允许混合不同类型的元素，例如包含字符串和整数的数组。
一个数组的表示形式为 [n]T（原文格式错误）。n 表示数组中元素的数量，T 代表每个元素的类型。元素的数量 n 也是该类型的一部分

数组的声明及初始化

一个数组的表示形式为 [n]T（原文格式错误）。n 表示数组中元素的数量，T 代表每个元素的类型。元素的数量 n 也是该类型的一部分。可通过以下几个方式来声明初始化

•  var 声明变量
•  短变量声明
•  自动匹配长度声明初始化

 

示例：
VAR变量声明
package main
 
import (
    "fmt"
)
 
func main() {
    var a [3]int //数组中的所有元素都被自动赋值为数组类型的零值。
    fmt.Println(a)
}

//声明变量，初始化数组值。
package main
 
import (
    "fmt"
)
 
func main() {
    var a [3]int //int array with length 3
    a[0] = 12 // array index starts at 0
    a[1] = 78
    a[2] = 50
    fmt.Println(a)
}

简短语句声明数组
package main
 
import (
    "fmt"
)
 
func main() {
    a := [3]int{12, 78, 50} // short hand declaration to create array
    b := [3]int{30}    //在简略声明中，可以不用对每个都进行赋值。默认会自动进行初始化。
    fmt.Println(a)
}

忽略声明数组长度
以忽略声明数组的长度，并用 ... 代替（如果不带...，那么就变成了切片），让编译器为你自动计算长度。
package main
 
import (
    "fmt"
)
 
func main() {
    a := [...]int{12, 78, 50} // ... makes the compiler determine the length
    fmt.Println(a)
}

数组的属性

其中数据包含了以下几个重要的属性。

•  数据的长度不可变
•  数据声明后会自动进行初始化。初始化值为类型的默认零值。数字类型为0，string类型为“”，其他部分类型为nil.
•  数组是值类型。进行变量赋值时，通过将一个原始值复制给另一个变量。
•  数组长度是能看见的“窗口",容量是总的"大小"

值传递示例：

package main
 
import "fmt"
 
func changeLocal(num [5]int) {
    num[0] = 55
    fmt.Println("inside function ", num)   //此处已修改函数内的数组值。
}
func main() {
    num := [...]int{5, 6, 7, 8, 8}
    fmt.Println("before passing to function ", num) 
    changeLocal(num) //num is passed by value。将数据传递给函数。在函数中改变数值。
    fmt.Println("after passing to function ", num) //函数内的修改的数组值，不在这里体现。
}
输出
before passing to function  [5 6 7 8 8]
inside function  [55 6 7 8 8]
after passing to function  [5 6 7 8 8]

数组长度示例：

package main
import "fmt"
func main() {
    a := [...]float64{67.7, 89.8, 21, 78}
    fmt.Println("length of a is",len(a))
}

数组的操作

• 取下标值
• 循环取值
• 生成切片

遍历数组中的元素

package main
 
import "fmt"
 
func main() {
    a := [...]float64{67.7, 89.8, 21, 78}
    for i := 0; i < len(a); i++ { // looping from 0 to the length of the array
        fmt.Printf("%d th element of a is %.2f\n", i, a[i])
    }
}
输出
0 th element of a is 67.70  
1 th element of a is 89.80  
2 th element of a is 21.00  
3 th element of a is 78.00

for range循环
Go 提供了一种更好、更简洁的方法，通过使用 for 循环的 range 方法来遍历数组。range 返回索引和该索引处的值。让我们使用 range 重写上面的代码。我们还可以获取数组中所有元素的总和。

package main
 
import "fmt"
 
func main() {
    a := [...]float64{67.7, 89.8, 21, 78}
    sum := float64(0)
    for i, v := range a {    //range 获取索引值和value值。
        fmt.Printf("%d the element of a is %.2f\n", i, v)
        sum += v
    }
    fmt.Println("\nsum of all elements of a",sum)
}
输出：

0 the element of a is 67.70
1 the element of a is 89.80
2 the element of a is 21.00
3 the element of a is 78.00
 
sum of all elements of a 256.5

多维数组
定义多维数组的方式和定义数据无过多差异。同样会进行默认的初始化。 

package main
 
import (
    "fmt"
)
 
func printarray(a [3][2]string) {
    for _, v1 := range a {
        for _, v2 := range v1 {
            fmt.Printf("%s ", v2)
        }
        fmt.Printf("\n")
    }
}
 
func main() {
    a := [3][2]string{
        {"lion", "tiger"},
        {"cat", "dog"},
        {"pigeon", "peacock"}, // this comma is necessary. The compiler will complain if you omit this comma
    }
    printarray(a)
    var b [3][2]string
    b[0][0] = "apple"
    b[0][1] = "samsung"
    b[1][0] = "microsoft"
    b[1][1] = "google"
    b[2][0] = "AT&T"
    b[2][1] = "T-Mobile"
    fmt.Printf("\n")
    printarray(b)
}
输出：
lion tiger
cat dog
pigeon peacock
 
apple samsung
microsoft google
AT&T T-Mobile

用简略语法声明一个二维字符串数组 a 。20 行末尾的逗号是必需的。这是因为根据 Go 语言的规则自动插入分号。

切片

    数组看上去似乎足够灵活，但是它们具有固定长度的限制，不可能增加数组的长度。这就要用到切片。事实上，在 Go 中，切片比传统数组更常见。
切片是由数组建立的一种方便、灵活且功能强大的包装（Wrapper）。切片本身不拥有任何数据。它们只是对现有数组的引用。
主要介绍以下内容

•  切片的初始化
•  切片的属性
•  切片的操作

切片的初始化

切片同样只存储同类型的一组数据。
可以使用以下几种方式进行定义及初始化

• var a []int{}
•  var a = []int{6,7}
•  a := b[1:3]
• a = make([]int,6,7) 

各种方式的示例如下：

package main
 
import (  
    "fmt"
)
 
func main() {  
    c := []int{6, 7, 8}  // 通过简略声明创建一个切片。  这里和数组的方式很接近，容易混淆。  c := [...]int{6,7,8} <- 这是定义一个数组。
    var d = []int{6, 7, 8}  // var声明并初始化
    a := [...]int{1,2,3,4,5,6}  //使用现有的数组，创建切片。 
    b := a[2:3]                   //此时对切片的修改会体现在底层数组上。
    fmt.Println(b)
    fmt.Println(a)
    b[0]++
    fmt.Println(b)
    fmt.Println(a)
    fmt.Println(c)
    fmt.Println(d)
}
输出：
[3]
[1 2 3 4 5 6]   //原有底层数组
[4]
[1 2 4 4 5 6]    //底层数组已被改变
[6 7 8]
[6 7 8]

使用make创建切片
 

func make（[]T，len，cap）[]T 通过传递类型，长度和容量来创建切片。容量是可选参数, 默认值为切片长度。make 函数创建一个数组，并返回引用该数组的切片。
package main
 
import (
    "fmt"
)
 
func main() {
    i := make([]int, 5, 5)
    fmt.Println(i)
}

使用 make 创建切片时默认情况下这些值为零。上述程序的输出为 [0 0 0 0 0]。

切片的属性

•  切片只存储同一类数据。
•  切片是一个指针类型
•  切片本身是没有存储任何数据的。 
•  使用数组创建切片，切片的修改会体现到数组中
•  切片长度和容量。长度为可见元素。容量为：底层数据大小（从数组开始位置到结束位置）。
•  切片容量会自动进行扩展。
•  切片的零值为nil 

切片的操作

当多个切片共用相同的底层数组时，每个切片所做的更改将反映在数组中。

package main
 
import (
    "fmt"
)
 
func main() {
    numa := [3]int{78, 79 ,80}
    nums1 := numa[:] // creates a slice which contains all elements of the array
    nums2 := numa[:] //缺少位置时，表示的是从开始在结束的位置。
    fmt.Println("array before change 1", numa)
    nums1[0] = 100
    fmt.Println("array after modification to slice nums1", numa)
    nums2[1] = 101
    fmt.Println("array after modification to slice nums2", numa)
    var e =[]int{}  //定义了一个零值的切片
}

切片的长度和容量

切片的长度是切片中的元素数。切片的容量是从创建切片索引开始的底层数组中元素数。

package main
 
import (
    "fmt"
)
 
func main() {
    fruitarray := [...]string{"apple", "orange", "grape", "mango", "water melon", "pine apple", "chikoo"}
    fruitslice := fruitarray[1:3]
    fmt.Printf("length of slice %d capacity %d", len(fruitslice), cap(fruitslice)) // length of is 2 and capacity is 6
}

 

追加切片

    切片是动态的，使用 append 可以将新元素追加到切片上。append 函数的定义是 func append（s[]T，x ... T）[]T。
如果切片由数组支持，并且数组本身的长度是固定的，那么切片如何具有动态长度。以及内部发生了什么，当新的元素被添加到切片时，会创建一个新的数组。现有数组的元素被复制到这个新数组中，并返回这个新数组的新切片引用。现在新切片的容量是旧切片的两倍。

package main
import (
    "fmt"
)
 
func main() {
    cars := []string{"Ferrari", "Honda", "Ford"}
    fmt.Println("cars:", cars, "has old length", len(cars), "and capacity", cap(cars)) // capacity of cars is 3
    cars = append(cars, "Toyota")
    fmt.Println("cars:", cars, "has new length", len(cars), "and capacity", cap(cars)) // capacity of cars is doubled to 6
}
输出：
cars: [Ferrari Honda Ford] has old length 3 and capacity 3  
cars: [Ferrari Honda Ford Toyota] has new length 4 and capacity 6

定义一个空切片，并通过append进行追加切片内容

package main
 
import (  
    "fmt"
)
 
func main() {  
    var names []string //zero value of a slice is nil
    if names == nil {
        fmt.Println("slice is nil going to append")
        names = append(names, "John", "Sebastian", "Vinay")
        fmt.Println("names contents:",names)
    }
}

使用 ... 运算符将一个切片添加到另一个切片

package main
import (
    "fmt"
)
func main() {
    veggies := []string{"potatoes", "tomatoes", "brinjal"}
    fruits := []string{"oranges", "apples"}
    food := append(veggies, fruits...)  //通过...将一个切片追加到另外一个切片中
    fmt.Println("food:",food)
}

切片的函数传递

我们可以认为，切片在内部可由一个结构体类型表示。这也就是切片是一个指针类型。因为在切片的底层当中，实质是一个指向数组的指针。 

type slice struct {  
    Length        int
    Capacity      int
    ZerothElement *byte  //这是一个指向底层数组第一个元素的指针。
}

切片包含长度、容量和指向数组第零个元素的指针。当切片传递给函数时，即使它通过值传递，指针变量也将引用相同的底层数组。因此，当切片作为参数传递给函数时，函数内所做的更改也会在函数外可见。

package main
 
import (
    "fmt"
)
 
func subtactOne(numbers []int) {
    for i := range numbers {
        numbers[i] -= 2
    }
}
func main() {
    nos := []int{8, 7, 6}
    fmt.Println("slice before function call", nos)
    subtactOne(nos)                               // function modifies the slice
    fmt.Println("slice after function call", nos) // modifications are visible outside。在函数外部是可见。 
}
输出：
array before function call [8 7 6]  
array after function call [6 5 4]

内存优化

    基于切片本身的是引用底层的数组。所以切片在使用数据的内容空间就不可能被回收。而当一个数组很大，而我们实际需要的切片数据很小。此时通过数据创建切片的这种使用方式就不够优化。 
此时就需要在使用数组创建切片之后，再通过copy()函数，复制出来一个新的切片。这样旧的切片及数组就能够被回收了。使用copy函数 func copy(dst，src[]T)int 来生成一个切片的副本。这样我们可以使用新的切片，原始数组可以被垃圾回收。

package main
 
import (
    "fmt"
)
 
func countries() []string {
    countries := []string{"USA", "Singapore", "Germany", "India", "Australia"}
    neededCountries := countries[:len(countries)-2]
    countriesCpy := make([]string, len(neededCountries))
    copy(countriesCpy, neededCountries) //copies neededCountries to countriesCpy
    return countriesCpy
}
func main() {
    countriesNeeded := countries()
    fmt.Println(countriesNeeded)
}

在上述程序的第 9 行，neededCountries := countries[:len(countries)-2 创建一个去掉尾部 2 个元素的切片 countries，在上述程序的 11 行，将 neededCountries 复制到 countriesCpy 同时在函数的下一行返回 countriesCpy。现在 countries 数组可以被垃圾回收, 因为 neededCountries 不再被引用。

切片的遍历及删除

package main 
import (
    "fmt"
)
func main(){
    //切片的遍历操作
     var a = []string{"one","two","three","four","five"}
     for k,v := range a {
        fmt.Printf("index key:%s and value:%s",k,v)
    }
    for i=0; i <len(a);i++{
        fmt.Printf("index key:%s and value:%s",k,v)

    }
    //切片的删除操作
    b := append(a[:1],a[3:]...)  //将切片的a[2]删除掉。
}

小结：

主要介绍了数组和切片两个数据类型

•  数组和切片都只能存储统一类型的数据集合。 
•  数组长度是固定。切片容量是动态，内部结构是一个指向数组的指针。
•  数组的默认初始值为类型的零值。切片的初始值为nil。
•  数组初始化： var a [5]int，定义长度。 a := [...]{1,2,3,4} 自动识别长度。
•  切片的初始化：基于数组创建  a := b[n:m]，切片的数据变更会影响到数组。声明初始化  a := []int{1,2,3,4,5} 不指定长度。
•  切片的内存优化： 切片仅适用数组部分内容。通过copy()赋值一个新切片，释放旧数组。 
•  for的遍历：index,value

参考链接：
https://blog.csdn.net/cbmljs/article/details/83539339

转载于:https://my.oschina.net/u/4156317/blog/3071059