Go语言 泛型

本篇文章转载自 在go中使用"泛型"

在进入泛型的话题之前, 首先实现对int 数组切片的冒泡排序:

func BubbleSort(array []int) {
   for i := 0; i < len(array); i++ {
      for j := 0; j < len(array)-i-1; j++ {
         if array[j] > array[j+1] {
            // 交换
            array[j], array[j+1] = array[j+1], array[j]
         }
      }
   }
}

如你所见, 上面的代码仅适用于对int数组进行排序, 如果想要对string数组排序, 不得不另写一个。是否可以只写一个通用的泛型程序, 以便对所有类型的数组(甚至是任意数据)进行冒泡排序?
很遗憾, go不支持java中的标记式泛型. 但是我们可以使用go的interface实现类似的功能。interface用于定义方法的集合.
在冒泡排序中, 我们可以将排序操作分解成3个方法: Len()方法负责计算长度, Less(i, j)方法负责比较大小, Swap(i, j)方法负责进行交换.

// 定义可排序接口
type Sortable interface {
   Len() int
   Less(int, int) bool
   Swap(int, int)
}

可以说, 任何实现了Sortable接口的数据类型都可进行冒泡排序, 下面是对Bubblesort方法的改造:

func BubbleSortable(arr Sortable) {
   length := arr.Len()
   for i := 0; i < length; i++ {
      for j := i; j < length-i-1; j++ {
         if arr.Less(j, j+1) {
            arr.Swap(j, j+1)
         }
      }
   }
}

BubbleSortable函数可以对所有Sortable类型的数据进行排序. 那么, 哪些数据是Sortable类型的呢? 很简单, 那些实现了Len(), Less(i, j), Swap(i, j)方法的数据类型都是Sortable的.
如果想要对int数组进行冒泡排序, 只需让int数组实现以上3个方法即可:

// 定义IntArr类型
type IntArr []int
// 给IntArr提供Len方法
func (arr IntArr) Len() int {
    return len(arr)
}
// 给IntArr提供Less方法
func (arr IntArr) Less(i int, j int) bool {
    return arr[i] < arr[j]
}
// 给IntArr提供Swap方法
func (arr IntArr) Swap(i int, j int) {
    arr[i], arr[j] = arr[j], arr[i]
}

至此, 我们定义了新的类型: IntArr(实际上就是int数组), 并为IntArr增加了Len, Less, Swap方法.
注意, 在go中, 实现接口不需要像java那样显式的说明对某个接口的implements, 只需要为类型提供所有interface中定义的方法即可. 此例中, 我们给IntArr提供了所有Sortable中定义的方法, 所以IntArr已经实现了Sortable接口. 接下来要做的是将IntArr类型的数据传递给BubbleSortable函数就可以了:

func main() {
   intarr := IntArr{2, 3, 1, -9, 0}
   // 调用排序方法
   BubbleSortable(intarr)
   // 输出排序之后的数据
   fmt.Printf("sorted int arr is: %v\n", intarr)
}

同样的, 如果想对string数组进行冒泡排序, 也只需要让string数组实现Sortable接口中定义的所有方法:

type StrArr []string
func (arr StrArr) Len() int {
    return len(arr)
}
func (arr StrArr) Less(i int, j int) bool {
    return arr[i] < arr[j]
}
func (arr StrArr) Swap(i int, j int) {
    arr[i], arr[j] = arr[j], arr[i]
}

测试代码如下:

func main() {
   strarr := StrArr{"nut", "ape", "elephant", "zoo", "go"}
   BubbleSortable(strarr)
   fmt.Printf("sorted string arr is: %v\n", strarr)
}

现在, 你可以对任意数据进行冒泡排序了, 只需要该类型实现了Len, Less, Swap方法.