Golang如何对字节数组进行唯一排序

在Go中对字节数组进行唯一排序，可以使用map来去重，然后对结果进行排序。以下是几种实现方法：

方法1：使用map和sort包

package main

import (
    "fmt"
    "sort"
)

func uniqueSortedBytes(data []byte) []byte {
    // 使用map去重
    seen := make(map[byte]bool)
    unique := []byte{}
    
    for _, b := range data {
        if !seen[b] {
            seen[b] = true
            unique = append(unique, b)
        }
    }
    
    // 排序
    sort.Slice(unique, func(i, j int) bool {
        return unique[i] < unique[j]
    })
    
    return unique
}

func main() {
    data := []byte{5, 2, 8, 2, 5, 1, 8, 9, 1}
    result := uniqueSortedBytes(data)
    fmt.Println(result) // 输出: [1 2 5 8 9]
}

方法2：使用sort和循环去重

package main

import (
    "fmt"
    "sort"
)

func uniqueSortedBytes(data []byte) []byte {
    if len(data) == 0 {
        return data
    }
    
    // 先排序
    sort.Slice(data, func(i, j int) bool {
        return data[i] < data[j]
    })
    
    // 再去重
    j := 0
    for i := 1; i < len(data); i++ {
        if data[j] != data[i] {
            j++
            data[j] = data[i]
        }
    }
    
    return data[:j+1]
}

func main() {
    data := []byte{3, 1, 4, 1, 5, 9, 2, 6, 5, 3}
    result := uniqueSortedBytes(data)
    fmt.Println(result) // 输出: [1 2 3 4 5 6 9]
}

方法3：通用函数处理任意类型切片

package main

import (
    "fmt"
    "sort"
)

func uniqueSorted[T comparable](data []T) []T {
    if len(data) == 0 {
        return data
    }
    
    // 去重
    seen := make(map[T]bool)
    unique := []T{}
    
    for _, v := range data {
        if !seen[v] {
            seen[v] = true
            unique = append(unique, v)
        }
    }
    
    // 排序需要类型约束
    sortSlice(unique)
    return unique
}

// 为可比较类型实现排序
func sortSlice[T comparable](data []T) {
    sort.Slice(data, func(i, j int) bool {
        // 这里需要根据具体类型实现比较逻辑
        // 对于byte/int等基本类型可以直接比较
        switch v := any(data[i]).(type) {
        case byte:
            return v < any(data[j]).(byte)
        case int:
            return v < any(data[j]).(int)
        case string:
            return v < any(data[j]).(string)
        default:
            return false
        }
    })
}

func main() {
    // 处理字节数组
    bytes := []byte{7, 3, 7, 1, 3, 2, 7}
    result1 := uniqueSorted(bytes)
    fmt.Println("Bytes:", result1) // 输出: [1 2 3 7]
    
    // 处理整数数组
    ints := []int{5, 2, 8, 2, 5, 1}
    result2 := uniqueSorted(ints)
    fmt.Println("Ints:", result2) // 输出: [1 2 5 8]
}

方法4：针对JSON数据的处理

根据你的JSON示例，你可能需要处理结构体数组的去重排序：

package main

import (
    "encoding/json"
    "fmt"
    "sort"
)

type Record struct {
    Timestamp  string `json:"TIMESTAMP"`
    Status     string `json:"STATUS"`
    Description string `json:"DESCRIPTION"`
}

func uniqueSortedRecords(records []Record) []Record {
    if len(records) == 0 {
        return records
    }
    
    // 使用map基于Status字段去重
    seen := make(map[string]bool)
    unique := []Record{}
    
    for _, r := range records {
        if !seen[r.Status] {
            seen[r.Status] = true
            unique = append(unique, r)
        }
    }
    
    // 按Status排序
    sort.Slice(unique, func(i, j int) bool {
        return unique[i].Status < unique[j].Status
    })
    
    return unique
}

func main() {
    jsonData := `[
        {"TIMESTAMP": "11-15-2019 at 09:35", "STATUS": " CLOSED", "DESCRIPTION": " Case closed "},
        {"TIMESTAMP": "11-15-2019 at 09:35", "STATUS": " CLOSED", "DESCRIPTION": " Case closed "},
        {"TIMESTAMP": "11-15-2019 at 09:36", "STATUS": " OPEN", "DESCRIPTION": " Case opened "},
        {"TIMESTAMP": "11-15-2019 at 09:35", "STATUS": " CLOSED", "DESCRIPTION": " Case closed "},
        {"TIMESTAMP": "11-15-2019 at 09:37", "STATUS": " PENDING", "DESCRIPTION": " Case pending "}
    ]`
    
    var records []Record
    json.Unmarshal([]byte(jsonData), &records)
    
    uniqueRecords := uniqueSortedRecords(records)
    
    for _, r := range uniqueRecords {
        fmt.Printf("Status: %s\n", r.Status)
    }
    // 输出:
    // Status:  CLOSED
    // Status:  OPEN
    // Status:  PENDING
}

这些方法可以根据你的具体需求选择使用。对于简单的字节数组，方法1和方法2最直接；如果需要处理JSON结构体数据，方法4更合适。