实现GO语言对数组切片去重

目录

• 1.go中没有去重方法
• 2.自定义一个适配多个切片类型的去重器
• 补充：
• 通过map键的唯一性去重(推荐)
• 通过map键的唯一性去重

Go语言是2007年由Google开发的一种静态强类型的编译型语言，其语法结构上与C非常接近。在垃圾回收、错误处理以及包库方面比C要方便的多，因此从开发速度上来讲比C要快的多，而运行速度也接近于C语言。以下实现GO语言对数组切片去重

1.go中没有去重方法

自己实现

package main

import (
    "fmt"
)

func main() {
    s := []string{"hello", "world", "hello", "golang", "hello", "ruby", "php", "java"}

    fmt.Println(removeDuplicateElement(s)) //output: hello world golang ruby php java
}

func removeDuplicateElement(languages []string) []string {
    result := make([]string, 0, len(languages))
    temp := map[string]struct{}{}
    for _, item := range languages {
        if _, ok := temp[item]; !ok {
            temp[item] = struct{}{}
            result = append(result, item)
        }
    }
    return result
}

2.自定义一个适配多个切片类型的去重器

下面对吗主要看

1.自定义sliceError结构体并实现Error方法
2.最后default中返回sliceError中自动会调用Errors使转换成error。

package common

import (
    "fmt"
)

type sliceError struct {
    msg string
}

func (e *sliceError) Error() string {
    return e.msg
}

func Errorf(format string, args ...interface{}) error {
    msg := fmt.Sprintf(format, args...)
    return &sliceError{msg}
}

func removeDuplicateElement1(originals interface{}) (interface{}, error) {
    temp := map[string]struct{}{}
    switch slice := originals.(type) {
    case []string:
        result := make([]string, 0, len(originals.([]string)))
        for _, item := range slice {
            key := fmt.Sprint(item)
            if _, ok := temp[key]; !ok {
                temp[key] = struct{}{}
                result = append(result, item)
            }
        }
        return result, nil
    case []int64:
        result := make([]int64, 0, len(originals.([]int64)))
        for _, item := range slice {
            key := fmt.Sprint(item)
            if _, ok := temp[key]; !ok {
                temp[key] = struct{}{}
                result = append(result, item)
            }
        }
        return result, nil
    default:
        err := Errorf("Unknown type: %T", slice)
        return nil, err
    }
}

补充：

通过map键的唯一性去重(推荐)

//通过map键的唯一性去重
func RemoveRepeatedElement(s []int) []int {
    result := make([]int, 0)
    m := make(map[int]bool) //map的值不重要
    for _, v := range s {
        if _, ok := m[v]; !ok {
            result = append(result, v)
            m[v] = true
        }
    }
    return result
}

通过map键的唯一性去重

定义一个新切片（数组），存放原数组的第一个元素，然后将新切片（数组）与原切片
（数组）的元素一一对比，如果不同则存放在新切片（数组）中。

func RemoveRepeatedElement(arr []int) (newArr []int) {
    newArr = make([]int, 0)
    for i := 0; i < len(arr); i++ {
        repeat := false
        for j := i + 1; j < len(arr); j++ {
            if arr[i] == arr[j] {
                repeat = true
                break
            }
        }
        if !repeat {
            newArr = append(newArr, arr[i])
        }
    }
    return
}

到此这篇关于GO语言对数组切片去重的实现的文章就介绍到这了！