[TOC]
排序
Go中排序函数
一维数组排序
sort.Ints([]int{5, 4, 3})
sort.Sort(sort.Reverse(sort.IntSlice{3, 2, 1}))
sort.Sort(sort.Reverse(sort.IntSlice(cost))) // cost=[]int{3,5,2,1}
二维矩阵排序
2.1 m*n矩阵，按照m升序
// input: [ [5 10] [0 30] [15 20]]
// output: [[0 30] [5 10] [15 20]]
sort.Slice(intervals, func(i, j int) bool {
return intervals[i][0] < intervals[j][0]
})
2.2 m*n矩阵，先按m升序，m相同，按n升序
// m*n的矩阵，先按照m从小到大排序，遇到m相同的情况，按照n升序
sort.Slice(input, func(i, j int) bool {
if input[i][0] == input[j][0] { // 表示m相同，按照n升序
return input[i][1] < input[j][1]
}
return input[i][0] < input[j][0] // 按照m升序
})
// m*n的矩阵，先按照m从小到大排序，遇到m相同的情况，按照n升序
func SortAlo1(input [][]int) interface{} {
sort.Slice(input, func(i, j int) bool {
if input[i][0] == input[j][0] { // 表示m相同，按照n升序
return input[i][1] < input[j][1]
}
return input[i][0] < input[j][0] // 按照m升序
})
return input
}
结构体排序
// =================== 以下方法有点复杂 ===========
type Node struct {
dis int
worker int
bike int
}
type NodeArr []Node
func (arr NodeArr) Len() int {
return len(arr)
}
func (arr NodeArr) Swap(i, j int) {
arr[i], arr[j] = arr[j], arr[i]
}
func (arr NodeArr) Less(i, j int) bool {
if arr[i].dis == arr[j].dis {
if arr[i].worker == arr[j].worker {
return arr[i].bike < arr[j].bike
} else {
return arr[i].worker < arr[j].worker
}
} else {
return arr[i].dis < arr[j].dis
}
}
字符串包的使用
func main() {
fmt.Println("查找子串是否在指定的字符串中")
fmt.Println(" Contains 函数的用法")
fmt.Println(strings.Contains("seafood", "foo")) //true
fmt.Println(strings.Contains("seafood", "bar")) //false
fmt.Println(strings.Contains("seafood", "")) //true
fmt.Println(strings.Contains("", "")) //true 这里要特别注意
fmt.Println(strings.Contains("我是中国人", "我")) //true
fmt.Println("")
fmt.Println(" ContainsAny 函数的用法") // 查询字符串中是否包含多个字符
fmt.Println(strings.ContainsAny("team", "i")) // false
fmt.Println(strings.ContainsAny("failure", "u & i")) // true
fmt.Println(strings.ContainsAny("foo", "")) // false
fmt.Println(strings.ContainsAny("", "")) // false
fmt.Println("")
fmt.Println(" ContainsRune 函数的用法")
fmt.Println(strings.ContainsRune("我是中国", '我')) // true 注意第二个参数，用的是字符
fmt.Println("")
fmt.Println(" Count 函数的用法") // 统计字符串中有多少字符
fmt.Println(strings.Count("cheese", "e")) // 3
fmt.Println(strings.Count("five", "")) // before & after each rune result: 5 , 源码中有实现
fmt.Println("")
fmt.Println(" EqualFold 函数的用法")
fmt.Println(strings.EqualFold("Go", "go")) //大小写忽略,字符串比较是否相等,忽略大小写的比较
fmt.Println("")
fmt.Println(" Fields 函数的用法")
fmt.Println("Fields are: %q", strings.Fields(" foo bar baz ")) //["foo" "bar" "baz"] 返回一个列表 分割字符串
//相当于用函数做为参数，支持匿名函数
for _, record := range []string{" aaa*1892*122", "aaa\taa\t", "124|939|22"} {
fmt.Println(strings.FieldsFunc(record, func(ch rune) bool {
switch {
case ch > '5':
return true
}
return false
}))
}
fmt.Println("")
fmt.Println(" HasPrefix 函数的用法")
fmt.Println(strings.HasPrefix("NLT_abc", "NLT")) //前缀是以NLT开头的
fmt.Println("")
fmt.Println(" HasSuffix 函数的用法")
fmt.Println(strings.HasSuffix("NLT_abc", "abc")) //后缀是以NLT开头的
fmt.Println("")
fmt.Println(" Index 函数的用法")
fmt.Println(strings.Index("NLT_abc", "abc")) // 返回第一个匹配字符的位置，这里是4
fmt.Println(strings.Index("NLT_abc", "aaa")) // 在存在返回 -1
fmt.Println(strings.Index("我是中国人", "中")) // 在存在返回 6
fmt.Println("")
fmt.Println(" IndexAny 函数的用法")
fmt.Println(strings.IndexAny("我是中国人", "中")) // 在存在返回 6
fmt.Println(strings.IndexAny("我是中国人", "和")) // 在存在返回 -1
fmt.Println("")
fmt.Println(" Index 函数的用法")
fmt.Println(strings.IndexRune("NLT_abc", 'b')) // 返回第一个匹配字符的位置，这里是4
fmt.Println(strings.IndexRune("NLT_abc", 's')) // 在存在返回 -1
fmt.Println(strings.IndexRune("我是中国人", '中')) // 在存在返回 6
fmt.Println("")
fmt.Println(" Join 函数的用法")
s := []string{"foo", "bar", "baz"}
fmt.Println(strings.Join(s, ", ")) // 返回字符串：foo, bar, baz
fmt.Println("")
fmt.Println(" LastIndex 函数的用法")
fmt.Println(strings.LastIndex("go gopher", "go")) // 3
fmt.Println("")
fmt.Println(" LastIndexAny 函数的用法")
fmt.Println(strings.LastIndexAny("go gopher", "go")) // 4
fmt.Println(strings.LastIndexAny("我是中国人", "中")) // 6
fmt.Println("")
fmt.Println(" Map 函数的用法")
rot13 := func(r rune) rune {
switch {
case r >= 'A' && r <= 'Z':
return 'A' + (r-'A'+13)%26
case r >= 'a' && r <= 'z':
return 'a' + (r-'a'+13)%26
}
return r
}
fmt.Println(strings.Map(rot13, "'Twas brillig and the slithy gopher..."))
fmt.Println("")
fmt.Println(" Repeat 函数的用法")
fmt.Println("ba" + strings.Repeat("na", 2)) //banana
fmt.Println("")
fmt.Println(" Replace 函数的用法")
fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2))
fmt.Println(strings.Replace("oink oink oink", "oink", "moo", -1))
fmt.Println("")
fmt.Println(" Split 函数的用法")
fmt.Printf("%q\n", strings.Split("a,b,c", ","))
fmt.Printf("%q\n", strings.Split("a man a plan a canal panama", "a "))
fmt.Printf("%q\n", strings.Split(" xyz ", ""))
fmt.Printf("%q\n", strings.Split("", "Bernardo O'Higgins"))
fmt.Println("")
fmt.Println(" SplitAfter 函数的用法")
fmt.Printf("%q\n", strings.SplitAfter("/home/m_ta/src", "/")) //["/" "home/" "m_ta/" "src"]
fmt.Println("")
fmt.Println(" SplitAfterN 函数的用法")
fmt.Printf("%q\n", strings.SplitAfterN("/home/m_ta/src", "/", 2)) //["/" "home/m_ta/src"]
fmt.Printf("%q\n", strings.SplitAfterN("#home#m_ta#src", "#", -1)) //["#" "home#" "m_ta#" "src"]
fmt.Println("")
fmt.Println(" SplitN 函数的用法")
fmt.Printf("%q\n", strings.SplitN("/home/m_ta/src", "/", 1))
fmt.Printf("%q\n", strings.SplitN("/home/m_ta/src", "/", 2)) //["" "home/m_ta/src"]
fmt.Printf("%q\n", strings.SplitN("/home/m_ta/src", "/", -1)) //["" "home" "m_ta" "src"]
fmt.Printf("%q\n", strings.SplitN("home,m_ta,src", ",", 2)) //["home" "m_ta,src"]
fmt.Printf("%q\n", strings.SplitN("#home#m_ta#src", "#", -1)) //["/" "home/" "m_ta/" "src"]
fmt.Println("")
fmt.Println(" Title 函数的用法") //这个函数，还真不知道有什么用
fmt.Println(strings.Title("her royal highness"))
fmt.Println("")
fmt.Println(" ToLower 函数的用法")
fmt.Println(strings.ToLower("Gopher")) //gopher
fmt.Println("")
fmt.Println(" ToLowerSpecial 函数的用法")
fmt.Println("")
fmt.Println(" ToTitle 函数的用法")
fmt.Println(strings.ToTitle("loud noises"))
fmt.Println(strings.ToTitle("loud 中国"))
fmt.Println("")
fmt.Println(" Replace 函数的用法")
fmt.Println(strings.Replace("ABAACEDF", "A", "a", 2)) // aBaACEDF
//第四个参数小于0，表示所有的都替换， 可以看下golang的文档
fmt.Println(strings.Replace("ABAACEDF", "A", "a", -1)) // aBaaCEDF
fmt.Println("")
fmt.Println(" ToUpper 函数的用法")
fmt.Println(strings.ToUpper("Gopher")) //GOPHER
fmt.Println("")
fmt.Println(" Trim 函数的用法")
fmt.Printf("[%q]", strings.Trim(" !!! Achtung !!! ", "! ")) // ["Achtung"]
fmt.Println("")
fmt.Println(" TrimLeft 函数的用法")
fmt.Printf("[%q]", strings.TrimLeft(" !!! Achtung !!! ", "! ")) // ["Achtung !!! "]
fmt.Println("")
fmt.Println(" TrimSpace 函数的用法")
fmt.Println(strings.TrimSpace(" \t\n a lone gopher \n\t\r\n")) // a lone gopher
}
Go中Bytes包的使用
func main() {
// Compare函数：对比参数一和参数二
// 如果a==b返回0，
// 如果a<b返回-1；否则返回+1，nil参数视为空切片
fmt.Println("1、Compare的使用例子：")
fmt.Println(bytes.Compare([]byte{1, 3, 4, 5, 5}, []byte{1, 2, 3, 1, 4})) // 结果为1
fmt.Println(bytes.Compare([]byte{1, 3, 4, 5, 5}, []byte{1, 3, 4, 5, 5})) // 结果为0
fmt.Println(bytes.Compare([]byte{1, 2, 4, 5, 5}, []byte{1, 3, 4, 5, 5})) // 结果为-1
fmt.Println(bytes.Compare([]byte{}, []byte{})) // 结果为0
//Equal函数：判断两个切片的内容是否相等,Equal函数入参必须是[]byte类型
fmt.Println("2、Equal的使用例子：")
fmt.Println(bytes.Equal([]byte{1, 2, 3, 5}, []byte{1, 2, 3, 5})) // 结果为true
//EqualFold函数：判断两个utf-8编码切片是否相同
fmt.Println("3、EqualFold的使用例子：")
fmt.Println(bytes.EqualFold([]byte{'a', 'b', 'c', 'd', 'e'}, []byte{'a', 'b', 'c', 'f', 'e'})) // 结果为false
fmt.Println(bytes.EqualFold([]byte{'a', 'b', 'c', 'd', 'e'}, []byte{'a', 'b', 'c', 'd', 'e'})) // 结果为true
//Runes函数：返回与参数等价的[]rune切片
fmt.Println("4、Runes的使用例子：")
fmt.Println(bytes.Runes([]byte{'a', 'b', 'c', 'd', 'e'})) // [97 98 99 100 101]
//HasPrefix函数：判断参数一是否有前缀切片参数二
fmt.Println("5、HasPrefix的使用例子：")
fmt.Println(bytes.HasPrefix([]byte{'a', 'b', 'c', 'd', 'e'}, []byte{'a'})) // 结果为true
//HasSuffix函数：判断参数一是否有后缀切片er
fmt.Println("6、HasSuffix的使用例子：")
fmt.Println(bytes.HasSuffix([]byte{'a', 'b', 'c', 'd', 'e'}, []byte{'c'})) // 结果为false
fmt.Println(bytes.HasSuffix([]byte{'a', 'b', 'c', 'd', 'e'}, []byte{'e'})) // 结果为true
//Contains函数：判断参数一中是否包含参数二切片
fmt.Println("7、Contains的使用例子:")
fmt.Println(bytes.Contains([]byte{'a', 'b', 'c', 'd', 'e'}, []byte{'d'})) // 结果为true
//Count：计算参数一中包含多少个参数二切片
fmt.Println("8、Count的使用例子：")
fmt.Println(bytes.Count([]byte{'a', 'b', 'c', 'd', 'e', 'd'}, []byte{'d'})) // 结果为2
//Index：计算参数二第一次出现在参数一的位置，不存在返回-1
fmt.Println("8、Index的使用例子：")
fmt.Println(bytes.Index([]byte{'a', 'b', 'c', 'd', 'e'}, []byte{'d'})) // 结果为3
//IndexByte:字符参数二在参数一中第一次出现的位置，不存在返回-1
fmt.Println("9、IndexByte的使用例子：")
fmt.Println(bytes.IndexByte([]byte{'a', 'b', 'c', 'd', 'e'}, byte('c'))) // 结果为2
//IndexRune:rune类型utf-8的参数二在参数一中第一次出现的位置
fmt.Println("10、IndexRune的使用例子：")
fmt.Println(bytes.IndexRune([]byte("我来自中国"), rune('我'))) // 结果为0
//IndexAny：参数二字符串中任意一个utf-8字符出现在参数一中的位置
fmt.Println("11、IndexAny的使用例子：")
fmt.Println(bytes.IndexAny([]byte("我来自中国"), "来国")) // 结果为3
//LastIndex:参数二最后一次出现在参数一中的位置
fmt.Println("12、LastIndex的使用例子：")
fmt.Println(bytes.LastIndex([]byte("hahahahaxswl"), []byte("a"))) // 结果为7
//LastIndexAny:参数二中任意一utf-8字符在参数一中最后一次出现的位置
fmt.Println("13、LastIndexAny的使用例子：")
fmt.Println(bytes.LastIndexAny([]byte("我来自中国"), "来国")) // 结果为12
//Title：将参数中的单词首字母都改成标题格式然后返回
fmt.Println("14、Title的使用例子：")
fmt.Println(string(bytes.Title([]byte{'a', 'b', 'c', 'd', 'e'}))) // 结果为Abcde
//ToLower将参数中的所有字母都转换成小写
fmt.Println("15、ToLower的使用例子：")
fmt.Println(string(bytes.ToLower(bytes.Title([]byte{'A', 'b', 'C', 'd', 'e'})))) // 结果为abcde
//ToUpper:将参数中的字母全转换成大写
fmt.Println("16、ToUpper的使用例子：")
fmt.Println(string(bytes.ToUpper([]byte{'A', 'b', 'C', 'd', 'e'}))) // 结果为ABCDE
//ToTitle:将参数中所有的字母都转换成对应的标题版本
fmt.Println("17、ToTitle的使用例子：")
fmt.Println(string(bytes.ToTitle([]byte{'A', 'b', 'C', 'd', 'e'}))) // 结果为ABCDE
//Repeat：拷贝参数二个参数一然后组成一个新的切片
fmt.Println("18、Repeat的使用例子：")
fmt.Println(string(bytes.Repeat([]byte{'h', 'e', 'l', 'l', 'o'}, 3))) // 结果为 hellohellohello
/*Replace:切换切片中的内容，返回将s中前n个不重叠old切片序列都替换为new的新的切片拷贝
，如果n<0会替换所有old子切片
方法源码：func Replace(s, old, new []byte, n int) []byte
*/
fmt.Println("19、Replace的使用例子：")
fmt.Println(string(bytes.Replace([]byte{'h', 'e', 'l', 'l', 'o'}, []byte{'l'}, []byte{'c'}, 1))) // 结果为 heclo
//Trim:将参数一前后端包含参数二切去
fmt.Println("20、Trim的使用例子：")
fmt.Println(string(bytes.Trim([]byte{'h', 'e', 'l', 'l', 'h'}, "h"))) //结果为ell
//TrimSpace:返回将参数前后端空白都去掉的子切片
fmt.Println("21、trmSpace的使用例子：")
fmt.Println(string([]byte(" hello World "))) // 结果 hello World
fmt.Println(string(bytes.TrimSpace([]byte(" hello World ")))) // 结果为 hello World
//TrimLeft:将参数一切片前端满足参数二的部分切除返回一个新的子切片
fmt.Println("22、TrimLeft的使用例子：")
fmt.Println(string(bytes.TrimLeft([]byte("hello World"), "he"))) // 结果为 llo World
//TrimPrefix:返回去除参数一可能的前缀参数二的子切片
fmt.Println("23、TrimPrefix的使用例子：")
fmt.Println(string(bytes.TrimPrefix([]byte("hello World"), []byte("hello")))) // 结果为 World（word前有空格）
//TrimRight:将参数一后端包含参数二的部分删除并返回新切片
fmt.Println("24、TrimRight的使用例子：")
fmt.Println(string(bytes.TrimRight([]byte("hello World"), "ld"))) // hello Wor
//TrimSuffix:返回去除参数一可能的后缀参数二的子切片
fmt.Println("25、TrimSuffix的使用例子：")
fmt.Println(string(bytes.TrimSuffix([]byte("hello World"), []byte("ld")))) // hello Wor
//Fields:返回将字符串按照空白分割成多个子切片
fmt.Println("26、Fields的使用例子：")
fmt.Println(bytes.Fields([]byte("hello World"))) // [[104 101 108 108 111] [87 111 114 108 100]]
//Split：去掉参数一中出现的参数二的方式进行分割，返回一个二维切片
fmt.Println("27、Split的使用例子：")
fmt.Println(bytes.Split([]byte("hello&World"), []byte("&"))) // [[104 101 108 108 111] [87 111 114 108 100]]
//SplitAfter：用从参数一出现的参数二后面进行分割
fmt.Println("28、SplitAfter的使用例子：")
fmt.Println(bytes.SplitAfter([]byte("hello&wor&ld"), []byte("&"))) // [[104 101 108 108 111 38] [119 111 114 38] [108 100]]
//Join将参数一切片链接成一个切片，中间用参数二隔开
fmt.Println("29、Join的使用方法")
fmt.Println(string(bytes.Join([][]byte{{'h', 'e', 'l', 'l', 'o'}, {'w', 'o', 'r', 'l', 'd'}}, []byte(" ")))) // hello world
}
