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语言对数组切片去重的实现的文章就介绍到这了,更多相关GO 数组切片去重内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！