實現目的：實現字串切片去重，只是兩個字元完全相同時，去除一個。

實現方式：考慮兩種，一種是常規的雙重迴圈去除，另一種是利用map的key的唯一性實現。

1、通過雙重迴圈來過濾重複元素

方法1，

思路：利用for雙重迴圈，新建一個slice，遍歷原slice中的每一個元素，每一次判斷這個元素和後面元素是否相同，若相同則去除，若不同則存入新slice中，判斷本元素後，再繼續判斷下一個元素，直到判斷完畢。

package main 
import "fmt" 
func main() {
 var arr = []string{"hello","hi","world","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","","yes","nihao","shijie","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,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","e","f","a","g","c"}
 sort.Strings(b)
 fmt.Println(Duplicate(b))
 c := []int{1,1,2,4,6,7,8,3,5,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
}

輸出的結果如下：

以上為個人經驗，希望能給大家一個參考，也希望大家多多支援我們。如有錯誤或未考慮完全的地方，望不吝賜教。