实现目的：实现字符串切片去重，只是两个字符完全相同时，去除一个。

实现方式：考虑两种，一种是常规的双重循环去除，另一种是利用map的key的唯一性实现。

1、通过双重循环来过滤重复元素

方法1，

思路：利用for双重循环，新建一个slice，遍历原slice中的每一个元素，每一次判断这个元素和后面元素是否相同，若相同则去除，若不同则存入新slice中，判断本元素后，再继续判断下一个元素，直到判断完毕。

package main 
import "fmt" 
func main() {
 var arr = []string{"hello", "hi", "world", "hi", "china", "hello", "hi"}
 fmt.Println(RemoveRepeatedElement(arr))
}
 
//去除重复字符串
func RemoveRepeatedElement(arr []string) (newArr []string) {
 newArr = make([]string, 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 newArr
}

方法2，

思路：先对原slice使用sort进行排序，后面思路同方法1。

package main 
import(
 "fmt"
 "sort"
)
 
 //去除重复字符串和空格
func RemoveDuplicatesAndEmpty(a []string) (ret []string){
 a_len := len(a)
 for i:=0; i < a_len; i++{
  if (i > 0 && a[i-1] == a[i]) || len(a[i])==0{
   continue;
  }
  ret = append(ret, a[i])
 }
 return
}
 
func main(){
 a := []string{"hello", "", "world", "yes", "hello", "nihao", "shijie", "hello", "yes", "nihao","good"}
 sort.Strings(a)
 fmt.Println(a)
 fmt.Println(RemoveDuplicatesAndEmpty(a))
}

2、通过字典来过滤

思路：因为字典的主键唯一，所以可以用来判断元素是否重复。

package main 
import (
 "fmt"
)
 
func main() {
 testStr := make([]string, 0)
 testStr = append(testStr, "haha", "hehe", "hoho", "hehe") 
 afterStr := removeDuplicate(testStr)
 fmt.Println(afterStr)
}
 
// 通过map主键唯一的特性过滤重复元素
func removeDuplicate(arr []string) []string {
 resArr := make([]string, 0)
 tmpMap := make(map[string]interface{})
 for _, val := range arr {
  //判断主键为val的map是否存在
  if _, ok := tmpMap[val]; !ok {
   resArr = append(resArr, val)
   tmpMap[val] = nil
  }
 } 
 return resArr
}

3、效率考虑

程序算法有两个指标：运行时间、内存消耗（即：时间复杂度、空间复杂度）。

以上两个方法，当数据量小和数据量大时分别考虑用双重for循环方法和map主键唯一方法。具体需要数据验证。

补充：Golang中如何删除切片的重复元素

思想如下：利用map中key唯一的特性将slice中的数据保存到map的key中

但是要注意key的类型,有些数值不能做为key

Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。

Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的

Golang中map中key的类型

golang中的map，其中的 key 可以是很多种类型，比如 bool, 数字，string, 指针, channel , 还有只包含前面几个类型的 interface types, structs, arrays

显然，slice， map 还有 function 是不可以了，因为这几个没法用 == 来判断

原文如下：

As mentioned earlier, map keys may be of any type that is comparable. The language spec defines this precisely, but in short, comparable types are boolean, numeric, string, pointer, channel, and interface types, and structs or arrays that contain only those types. Notably absent from the list are slices, maps, and functions; these types cannot be compared using ==, and may not be used as map keys.

// 删除切片中重复的数据
package main
import (
 "fmt"
 "reflect"
 "sort"
)
func main() {
 b := []string{"a", "b", "c", "c", "e", "f", "a", "g", "b", "b", "c"}
 sort.Strings(b)
 fmt.Println(Duplicate(b))
 c := []int{1, 1, 2, 4, 6, 7, 8, 4, 3, 2, 5, 6, 6, 8}
 sort.Ints(c)
 fmt.Println(DeleteDuplicateValue(c))
}
func Duplicate(a interface{}) (ret []interface{}) {
 fmt.Printf("a : %+v\n", a)
 va := reflect.ValueOf(a)
 fmt.Printf("va : %+v\n", va)
 for i := 0; i < va.Len(); i++ {
 if i > 0 && reflect.DeepEqual(va.Index(i-1).Interface(), va.Index(i).Interface()) {
 continue
 }
 ret = append(ret, va.Index(i).Interface())
 }
 return ret
}
// 这种方式比较容易理解
func DeleteDuplicateValue(s []int) (ret []int) {
 fmt.Printf("s :%+v\n", s)
 tmpM := make(map[int]int) // key的类型要和切片中的数据类型一致
 for _, v := range s {
 tmpM[v] = 1
 }
 // 先清空s
 s = []int{}
 for i, _ := range tmpM {
 s = append(s, i)
 }
 return s
}

输出的结果如下：