go语言学习——3

数组

• 数组声明

var identifier [len]type
// var arr1 [5]int
//  每个元素是一个整型值，当声明数组时所有的元素都会被自动初始化为默认值0

• 遍历数组

for i:=0; i < len(arr1); i++｛
    arr1[i] = ...
}

for index,value:= range arr1 {
...
}

• 数组常量

var arrAge = [5]int{18, 20, 15, 22, 16}
var arrLazy = [...]int{5, 6, 7, 8, 22}
var arrKeyValue = [5]string{3: "Chris", 4: "Ron"}
//几何点（或者数学向量）是一个使用数组的经典例子。为了简化代码通常使用一个别名：
type Vector3D [3]float32
var vec Vector3D

• 多维数组

package main
const (
    WIDTH  = 1920
    HEIGHT = 1080
)

type pixel int
var screen [WIDTH][HEIGHT]pixel

func main() {
    for y := 0; y < HEIGHT; y++ {
        for x := 0; x < WIDTH; x++ {
            screen[x][y] = 0
        }
    }
}

切片

• 切片长度可以在运行时修改
• 切片是一个长度可变的数组
• 切片提供了计算容量的函数cap()，可以测量切片最长可以达到多少
• 0<=len(s)<=cap(s)
• 多个切片如果表示同一个数组的片段，它们可以共享数据；因此一个切片和相关数组的其他切片是共享存储的

//声明切片
var identifier []type
//切片初始化
var slice1 []type = arr1[start:end]
//slice1等于完整的arr1数组
var slice1 []type = arr1[:]
//是arr1[0:len(arr1)]的缩写
//另一种表述方式是：
slice1=&arr1

s := [3]int{1,2,3}[:]
s := []int{1,2,3}

• 用make()创建一个切片

• 当相关数组还没有定义时，可以使用make()函数来创建一个切片同时创建好相关数组：

• var slice1 []type=make([]type , len)

• 也可以简写为slice1:=make([]type, len)

• len是数组长度也是slice的初始长度

• func make([]T, len, cap)，cap是可选参数

make([]int, 50, 100)
new([100]int)[0:50]
//生成相同的切片

• new()和make()的区别

• new(T)为每个新的类型T分配一片内存，初始化为0并且返回类型为 *T的内存地址：这种方法返回一个执行类型T，值为0的地址的指针，它适用于值类型如数组和结构体，相当于&T{}
• make(T)返回一个类型为T的初始值，它只适用于3种内建的引用类型：切片、map和channel

	s := make([]byte, 5)
	fmt.Println(len(s),":",cap(s))
	//5 5
	s1 := []byte{'p', 'o', 'e', 'm'}
	fmt.Println("s1: ",s1)
	s2 := s1[2:]
	fmt.Println("s2: ",s2)
	s2[1]='t'
	fmt.Println("s2 new: ",s2,"		s1: ",s1)
	//s1:  [112 111 101 109]
	//s2:  [101 109]
	//s2 new:  [101 116] 		s1:  [112 111 101 116]

• 多维切片

• 切片通常也是一维的，但可以由一维组合成高维，通过分片的分片（或者切片的数组），长度可以任意动态变化

• bytes包

• 类型[]byte的切片十分常见，GO中的bytes包专门用来解决这种类型的操作方法

import "bytes"

type Buffer struct {
    ...
}

var buffer bytes.Buffer
var r *bytes.Buffer = new(bytes.Buffer)
func NewBuffer(buf []byte) *Buffer

• 切片重组reslice

改变切片长度的过程称之为切片重组 reslicing

//end为新的末尾索引
s1=s1[0:end]
//扩展一位
s1=s1[0:len(s1)+1]
//可以反复扩展直到占据整个数组

• 切片复制与追加
• 拷贝copy
• 追加append

sl_from := []int{1, 2, 3}
sl_to := make([]int, 10)
n:=copy(sl_to,sl_from)
sl_to=append(sl_to,4,5,6)

• 修改字符串中的某个字符

s:="hello"
c:=[]byte(s)
c[0]='c'
s2:=string(c)//s2="cello"

• 字节数组对比函数

func Compare(a, b[]byte) int {
    for i:=0; i < len(a) && i < len(b); i++ {
        switch {
        case a[i] > b[i]:
            return 1
        case a[i] < b[i]:
            return -1
        }
    }
    // 数组的长度可能不同
    switch {
    case len(a) < len(b):
        return -1
    case len(a) > len(b):
        return 1
    }
    return 0 // 数组相等
}

• 搜索及排序

• sort包

• func Ints(a []iny) 对int类型的切片排序，sort.Ints(arri)
• IntsAreSorted(a []int) bool 判断某个数组是否已经被排序
• func Float64s(a []float64) 排序float64的元素
• func Strings(a []string)排序字符串元素
• func SearchInts(a []int, n int) int在数组或切片中搜索一个元素，该数组或切片必须先被排序，然后使用此函数进行搜索，返回对应结果的索引值