Go语言泛型使用及说明

// 联合类型约束：限定数值类型
type Numeric interface {
  int | float32 | float64
}
// 行为约束：要求实现String()方法
type Stringer interface {
  String() string
}
// 联合+行为约束
type NumericStringer interface {
  int | float64
  String() string
}

package main
import "fmt"
type Numeric interface { int | float32 | float64 }
func Sum[T Numeric](a, b T) T { return a + b }
func main() {
  fmt.Println(Sum(10,20))        // T=int → 30
  fmt.Println(Sum(1.5,2.5))      // T=float64 → 4.0
  fmt.Println(Sum[int](100,200)) // 显式指定 → 300
}

package main
import "fmt"
func RemoveDuplicate[T comparable](slice []T) []T {
  result := make([]T, 0, len(slice))
  tempMap := make(map[T]struct{}, len(slice))
  for _, val := range slice {
    if _, ok := tempMap[val]; !ok {
      tempMap[val] = struct{}{}
      result = append(result, val)
    }
  }
  return result
}
func main() {
  fmt.Println(RemoveDuplicate([]int{1,2,2,3})) // [1 2 3]
  fmt.Println(RemoveDuplicate([]string{"a","b","a"})) // [a b]
}

package main
import ("errors"; "fmt")
type Stack[T any] struct{ elements []T }
func (s *Stack[T]) Push(e T) { s.elements = append(s.elements, e) }
func (s *Stack[T]) Pop() (T, error) {
  if s.IsEmpty() { return *new(T), errors.New("栈为空") }
  topIdx := len(s.elements)-1
  top := s.elements[topIdx]
  s.elements = s.elements[:topIdx]
  return top, nil
}
func (s *Stack[T]) IsEmpty() bool { return len(s.elements) == 0 }
func main() {
  s := &Stack[int]{}
  s.Push(10); s.Push(20)
  top, _ := s.Pop()
  fmt.Println(top) // 20
}

package main
import ("fmt"; "strconv"; "strings")
type Converter[T, V any] interface { Convert(T) (V, error) }
// int转string实现
type IntToStringConverter struct{}
func (c *IntToStringConverter) Convert(t int) (string, error) {
  return strconv.Itoa(t), nil
}
// string转User实现
type User struct{ ID int; Name string }
type StringToUserConverter struct{}
func (c *StringToUserConverter) Convert(t string) (User, error) {
  parts := strings.Split(t, ",")
  if len(parts)!=2 { return User{}, fmt.Errorf("格式错误") }
  id, _ := strconv.Atoi(parts[0])
  return User{ID: id, Name: parts[1]}, nil
}
func main() {
  c1 := &IntToStringConverter{}
  fmt.Println(c1.Convert(100)) // 100 <nil>
}

package main
import "fmt"

// 泛型map合并：将map2合并到map1，key冲突时map2覆盖map1
func MergeMap[K comparable, V any](map1, map2 map[K]V) map[K]V {
    result := make(map[K]V, len(map1)+len(map2))
    // 先复制map1
    for k, v := range map1 {
        result[k] = v
    }
    // 合并map2，覆盖冲突key
    for k, v := range map2 {
        result[k] = v
    }
    return result
}

// 泛型map遍历：提取所有value组成切片
func MapValues[K comparable, V any](m map[K]V) []V {
    values := make([]V, 0, len(m))
    for _, v := range m {
        values = append(values, v)
    }
    return values
}

func main() {
    m1 := map[string]int{"a":1, "b":2}
    m2 := map[string]int{"b":3, "c":4}
    // 合并map
    merged := MergeMap(m1, m2)
    fmt.Println("合并后map：", merged) // map[a:1 b:3 c:4]
    // 提取value切片
    values := MapValues(merged)
    fmt.Println("map所有value：", values) // [1 3 4]
}

package main
import ("errors"; "fmt"; "strconv")

// 复用之前的Converter泛型接口
type Converter[T, V any] interface { Convert(T) (V, error) }

// 嵌套泛型结构体：Stack中存储转换后的V类型数据
type ConvertStack[T, V any] struct {
    stack Stack[V]      // 嵌套泛型结构体Stack
    conv  Converter[T, V] // 嵌套泛型接口Converter
}

// 构造函数
func NewConvertStack[T, V any](conv Converter[T, V]) *ConvertStack[T, V] {
    return &ConvertStack[T, V]{
        stack: Stack[V]{},
        conv:  conv,
    }
}

// 入栈前先转换数据
func (cs *ConvertStack[T, V]) PushAndConvert(t T) error {
    v, err := cs.conv.Convert(t)
    if err != nil {
        return err
    }
    cs.stack.Push(v)
    return nil
}

// 出栈（复用Stack的Pop方法）
func (cs *ConvertStack[T, V]) Pop() (V, error) {
    return cs.stack.Pop()
}

// 复用之前的Stack泛型结构体
type Stack[V any] struct{ elements []V }
func (s *Stack[V]) Push(e V) { s.elements = append(s.elements, e) }
func (s *Stack[V]) Pop() (V, error) {
    if len(s.elements) == 0 { return *new(V), errors.New("栈为空") }
    topIdx := len(s.elements)-1
    top := s.elements[topIdx]
    s.elements = s.elements[:topIdx]
    return top, nil
}

// 实现int转string的Converter
type IntToStringConverter struct{}
func (c *IntToStringConverter) Convert(t int) (string, error) {
    return strconv.Itoa(t), nil
}

func main() {
    cs := NewConvertStack[int, string](&IntToStringConverter{})
    cs.PushAndConvert(10)
    cs.PushAndConvert(20)
    val, _ := cs.Pop()
    fmt.Println("出栈值（已转换）：", val) // 20
}

package main
import "fmt"

// 泛型通道处理：从输入通道读取数据，处理后写入输出通道
func ProcessChan[T, V any](inChan <-chan T, outChan chan<- V, process func(T) V) {
    defer close(outChan)
    for t := range inChan {
        v := process(t)
        outChan <- v
    }
}

func main() {
    inChan := make(chan int, 3)
    outChan := make(chan string, 3)

    // 写入数据到输入通道
    inChan <- 10
    inChan <- 20
    inChan <- 30
    close(inChan)

    // 启动处理协程：int转string
    go ProcessChan[int, string](inChan, outChan, func(t int) string {
        return fmt.Sprintf("数值：%d", t)
    })

    // 读取输出通道数据
    for s := range outChan {
        fmt.Println(s) // 依次输出：数值：10、数值：20、数值：30
    }
}

package main
import ("fmt"; "time")

// 泛型函数包装器：统计任意函数的执行耗时
func TimeCost[T any, V any](f func(T) V) func(T) V {
    return func(t T) V {
        start := time.Now()
        res := f(t)
        cost := time.Since(start)
        fmt.Printf("函数执行耗时：%v\n", cost)
        return res
    }
}

// 测试函数1：int转string
func IntToStr(t int) string {
    time.Sleep(100 * time.Millisecond)
    return fmt.Sprintf("%d", t)
}

// 测试函数2：计算切片总和
func SliceSum(t []int) int {
    time.Sleep(50 * time.Millisecond)
    sum := 0
    for _, v := range t {
        sum += v
    }
    return sum
}

func main() {
    // 包装并调用IntToStr
    wrappedIntToStr := TimeCost(IntToStr)
    wrappedIntToStr(100) // 输出：函数执行耗时：100+ms

    // 包装并调用SliceSum
    wrappedSliceSum := TimeCost(SliceSum)
    wrappedSliceSum([]int{1,2,3,4,5}) // 输出：函数执行耗时：50+ms
}