字符串、数组和切片的应用

1.从字符串生成字节切片

c := []byte(s)
copy(dst []byte, s string)
获取每个元素
for i, c := range s {}
将字符串转换为rune类型的切片
r := []rune(s)

2.获取字符串的某一部分

substr := str[start:end]
可以获取字符串str从索引start到end-1位置的子字符串
字符串是不可变的，如果需要修改字符串中某个元素值，需要先将字符串转换为字节数组，修改后再转换为字符串格式

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

3.搜索及排序切片和数组

标准库提供了 sort 包来实现常见的搜索和排序操作

• func Float64s(x []float64)
• func Float64sAreSorted(x []float64) bool
• func Ints(x []int)
• func IntsAreSorted(x []int) bool
• func IsSorted(data Interface) bool
• func Search(n int, f func(int) bool) int
• func SearchFloat64s(a []float64, x float64) int
• func SearchInts(a []int, x int) int
• func SearchStrings(a []string, x string) int
• func Slice(x interface{}, less func(i, j int) bool)
• func SliceIsSorted(x interface{}, less func(i, j int) bool) bool
• func SliceStable(x interface{}, less func(i, j int) bool)
• func Sort(data Interface)
• func Stable(data Interface)
• func Strings(x []string)
• func StringsAreSorted(x []string) bool
• type Float64Slice
  • func (x Float64Slice) Len() int
  • func (x Float64Slice) Less(i, j int) bool
  • func (p Float64Slice) Search(x float64) int
  • func (x Float64Slice) Sort()
  • func (x Float64Slice) Swap(i, j int)
• type IntSlice
  • func (x IntSlice) Len() int
  • func (x IntSlice) Less(i, j int) bool
  • func (p IntSlice) Search(x int) int
  • func (x IntSlice) Sort()
  • func (x IntSlice) Swap(i, j int)
• type Interface
  • func Reverse(data Interface) Interface
• type StringSlice
  • func (x StringSlice) Len() int
  • func (x StringSlice) Less(i, j int) bool
  • func (p StringSlice) Search(x string) int
  • func (x StringSlice) Sort()
  • func (x StringSlice) Swap(i, j int)

4.append函数常见操作

1）将切片b的元素追加到切片a之后 a = append(a,b...)
2)复制切片a的元素到新的切片b之上
b = make([]T, len(a))
copy(b,a)
3)删除位于索引i的元素 a = append(a[:i], a[i+1:])
4)切除切片中从索引i至j位置的元素 a = append(a[:i], a[j:])
5)为切片a扩展j个元素长度 a = append(a, make([]T, j)...)
6)在索引i的位置插入元素x a = append(a[:i], append([]T{x}, a[i:]))
7)在索引位置插入长度为j的新切片 a = append(a[:i], append(make([]T, j), a[i:]))
8)在索引i的位置插入切片b的所有元素 a = append(a[:i], append(b, a[i:]))
9)取出位于切片a最末尾的元素x x, a = a[len(a)-1], a[:len(a)-1]
10)将元素x追加到切片a a = append(a, x)

5.切片和垃圾回收

切片的底层指向一个数组，该数组的实际容量可能要大于切片所定义的容量。只有在没有任何切片指向的时候，底层的数组内存才会被释放，这种特性有时会导致程序占用多余的内存。
一点点有用的数据却占用了整个文件的内存。
想要避免这个问题，可以通过拷贝我们需要的部分到一个新的切片

练习

1.编写一个函数，要求其接受两个参数，原始字符串 str 和分割索引 i，然后返回两个分割后的字符串。

func splitStr(str string, i int) (str1, str2 string) {
    str1 = str[:i]
    str2 = str[i:]
    return
}

2.假设有字符串 str，那么 str[len(str)/2:] + str[:len(str)/2] 的结果是什么？

    str := "abcd"
    str_new := str[len(str)/2:] + str[:len(str)/2]
    fmt.Println(str_new)
    //cdab

3.编写一个程序，要求能够反转字符串，即将 “Google” 转换成 “elgooG”（提示：使用 []byte 类型的切片）。

func byte_reverse(str string) (re string) {
    c := []byte(str)
    c1 := make([]byte, len(c))
    for i := len(c)-1; i >= 0 ; i-- {
        c1 = append(c1, c[i])
    }
    return string(c1)
}

如果您使用两个切片来实现反转，请再尝试使用一个切片（提示：使用交换法）。

func swap_reverse(str string) (re string) {
    c := []byte(str)
    l := len(c)/2
    for i := 0; i < l; i++ {
        c[i],c[len(c)-i-1] = c[len(c)-i-1],    c[i]
    }
    return string(c)
}

如果您想要反转 Unicode 编码的字符串，请使用 []int32 类型的切片。

func swapReverseString(str string) (re string) {
    c := []int32(str)
    l := len(c)/2
    for i := 0; i < l; i++ {
        c[i],c[len(c)-i-1] = c[len(c)-i-1],    c[i]
    }
    return string(c)
}

4.编写一个程序，要求能够遍历一个数组的字符，并将当前字符和前一个字符不相同的字符拷贝至另一个数组。

func stringCopy(from []byte) (to []byte){
    var flag byte = from[0]
    to = append(to, flag)
    for _, c := range from {
        if c != flag{
            to = append(to, c)
            flag = c
        }
    }
    return to
}

5.编写一个程序，使用冒泡排序的方法排序一个包含整数的切片

func bubbleSort(arr []int) ([]int) {
    for i := 0; i < len(arr); i++ {
        for j := 0; j < len(arr) - i-1 ; j++ {
            // fmt.Println(j)
            if arr[j] > arr[j+1] {
                arr[j+1], arr[j] = arr[j], arr[j+1]
            }
            if (j+1 == len(arr)-i){
                break
            }
        } 
    }
    return arr
}