golag如何使用sort.slice包实现对象list排序

这篇文章将为大家详细讲解有关golag如何使用sort.slice包实现对象list排序，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。

1.sort.Sort介绍

使用sort.Slice进行排序，因为slice把struct抽象化了，且slice封装过了，简单的基础类型可以使用sort,使用sort排序需要重写三个interface,不想学习sort排序的可以直接看第三步

这里将对比sort跟slice两种排序的使用方式

1.1分析内置sort包

1.2分析sort.go

要想实现自定义对象的排序功能，需要重写这三个interface

外部调用sort方法即可实现排序

func Sort(data Interface) {n := data.Len()quickSort(data, 0, n, maxDepth(n))}

通过sort源码可以看到用的快速排序，不懂快排的可以自行重温快排算法，这里就不讲解快排原理了

2.使用方法

2.1基础类型排序

基础类型的排序直接在sort.go去找就行了

package mainimport ("fmt""sort")func main() {intList := [] int {2, 4, 3, 5, 7, 6, 9, 8, 1, 0}float8List := [] float64 {4.2, 5.9, 12.3, 10.0, 50.4, 99.9, 31.4, 27.81828, 3.14}stringList := [] string {"a", "c", "b", "d", "f", "i", "z", "x", "w", "y"}sort.Ints(intList)sort.Float64s(float8List)sort.Strings(stringList)fmt.Printf("%v\n%v\n%v\n", intList, float8List, stringList)}

2.2对象排序（单一字段）

如果对一个struct对象的某一个字段进行排序就需要重写一组len,less,swap接口，如果有多组就需要重写多组接口。

下面直接看例子：

如果一个对象只有一个字段需要排序就用下面的例子比较简单

package mainimport ("fmt""sort")type Person struct {Name stringAge int}// 按照 Person.Age 从大到小排序type PersonSlice [] Personfunc (a PersonSlice) Len() int { // 重写 Len() 方法return len(a)}func (a PersonSlice) Swap(i, j int){ // 重写 Swap() 方法a[i], a[j] = a[j], a[i]}func (a PersonSlice) Less(i, j int) bool { // 重写 Less() 方法， 从大到小排序return a[j].Age < a[i].Age}func main() {people := [] Person{{"zhang san", 12},{"li si", 30},{"wang wu", 52},{"zhao liu", 26},}fmt.Println(people)sort.Sort(PersonSlice(people)) // 按照 Age 的逆序排序fmt.Println(people)sort.Sort(sort.Reverse(PersonSlice(people))) // 按照 Age 的升序排序fmt.Println(people)}

2.3对象排序（多字段）

多个了SortBy方法可以确定是升序还是降序，同时可以确定排序字段是哪个

package mainimport ("fmt""sort")type Person struct {Name stringAge int}type PersonWrapper struct {people [] Personby func(p, q * Person) bool}//用来判断升序还是降序type SortBy func(p, q *Person) boolfunc (pw PersonWrapper) Len() int { // 重写 Len() 方法return len(pw.people)}func (pw PersonWrapper) Swap(i, j int){ // 重写 Swap() 方法pw.people[i], pw.people[j] = pw.people[j], pw.people[i]}func (pw PersonWrapper) Less(i, j int) bool { // 重写 Less() 方法return pw.by(&pw.people[i], &pw.people[j])}// 封装成 SortPerson 方法func SortPerson(people [] Person, by SortBy){sort.Sort(PersonWrapper{people, by})}func main() {people := [] Person{{"zhang san", 12},{"li si", 30},{"wang wu", 52},{"zhao liu", 26},}fmt.Println(people)//推荐用封装的SortPerson方法sort.Sort(PersonWrapper{people, func (p, q *Person) bool {return q.Age < p.Age // Age 递减排序}})fmt.Println(people)//推荐用这种SortPerson(people, func (p, q *Person) bool {return p.Name < q.Name // Name 递增排序})fmt.Println(people)}

如果不喜欢用sortby方法，也可以重写多个less、len、swap方法，

下面的方法就调用起来比较简单，不用重写by跟sortby方法，但是上面的比较灵活（理解可能比下面的费劲）

package mainimport ("fmt""sort")type Person struct {Name stringWeight int}type PersonSlice []Personfunc (s PersonSlice) Len() int { return len(s) }func (s PersonSlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }type ByName struct{ PersonSlice } // 将 PersonSlice 包装起来到 ByName 中func (s ByName) Less(i, j int) bool { return s.PersonSlice[i].Name < s.PersonSlice[j].Name } // 将 Less 绑定到 ByName 上type ByWeight struct{ PersonSlice } // 将 PersonSlice 包装起来到 ByWeight 中func (s ByWeight) Less(i, j int) bool { return s.PersonSlice[i].Weight < s.PersonSlice[j].Weight } // 将 Less 绑定到 ByWeight 上func main() {s := []Person{{"apple", 12},{"pear", 20},{"banana", 50},{"orange", 87},{"hello", 34},{"world", 43},}sort.Sort(ByWeight{s})fmt.Println("People by weight:")printPeople(s)sort.Sort(ByName{s})fmt.Println("\nPeople by name:")printPeople(s)}func printPeople(s []Person) {for _, o := range s {fmt.Printf("%-8s (%v)\n", o.Name, o.Weight)}}

3.sort.Slice介绍

3.1使用方法

很明显将对象抽象成interface,而上面对对象的排序，只能是person这种特定对象

调用的时候有点类似java的重写compare方法

package mainimport ("fmt""sort")type Person struct {Name stringWeight int}func main() {s := []Person{{"apple", 12},{"pear", 20},{"banana", 50},{"orange", 87},{"hello", 34},{"world", 43},}//可以向上面一样对排序字段封装，加一个sortby字段传递sort.Slice(s,func(i,j int)bool{return s[i].Weight < s[j].Weight})fmt.Println("People by weight:")printPeople(s)sort.Slice(s,func(i,j int)bool{return s[i].Name < s[j].Name})fmt.Println("\nPeople by name:")printPeople(s)}func printPeople(s []Person) {for _, o := range s {fmt.Printf("%-8s (%v)\n", o.Name, o.Weight)}}

3.2运行

关于“golag如何使用sort.slice包实现对象list排序”这篇文章就分享到这里了，希望以上内容可以对大家有一定的帮助，使各位可以学到更多知识，如果觉得文章不错，请把它分享出去让更多的人看到。