常见的数组去重方案大概有以下几种，我们对这几种进行比较，看看谁的效率更好：
首先随机生成长度为1000的数组：

var array = [Int]()
for _ in 0...999 {
    array.append(Int.random(in: 0...10))
}

第一种，利用Set特性进行去重（速度快，但无法保证数组的顺序）

extension Array where Element : Hashable {
    var unique1: [Element] {
        return Array(Set(self))
    }
}

//运行时间
let start = CFAbsoluteTimeGetCurrent()
for _ in 0...99 {
    print(array.unique1)
}
print((CFAbsoluteTimeGetCurrent()-start)*1000)
//28.856992721557617
//[10, 3, 0, 9, 4, 6, 1, 7, 8, 2, 5]
//[6, 0, 2, 9, 4, 5, 1, 3, 8, 7, 10]
//[5, 3, 8, 10, 7, 6, 9, 4, 0, 2, 1]

第二种，利用字典进行去重（略微占用空间）

extension Array where Element: Hashable {
    var unique2: [Element] {
        var addedDict = [Element: Bool]()
 
        return filter {
            addedDict.updateValue(true, forKey: $0) == nil
        }
    }
}
//运行时间
let start = CFAbsoluteTimeGetCurrent()
for _ in 0...99 {
    print(array.unique2)
}
print((CFAbsoluteTimeGetCurrent()-start)*1000)
//36.376953125
//[2, 6, 1, 8, 9, 4, 3, 10, 0, 5, 7]

第三种，最垃圾的方案，一般不会有人这么搞吧？

extension Array where Element: Equatable {
    var unique3: [Element] {
        var result = [Element]()
        for value in self {
            if !result.contains(value) {
                result.append(value)
            }
        }
        return result
    }
}

//运行时间
let start = CFAbsoluteTimeGetCurrent()
for _ in 0...99 {
    print(array.unique3)
}
print((CFAbsoluteTimeGetCurrent()-start)*1000)
//283.6470603942871
//[10, 1, 9, 5, 6, 8, 7, 2, 0, 4, 3]

第四种，在不改变数组顺序的情况下，目前看来最优的方案：

extension Array where Element:Hashable {
    var unique4: [Element] {
        var uniq = Set<Element>()
        uniq.reserveCapacity(self.count)
        return self.filter {
            return uniq.insert($0).inserted
        }
    }
}

//运行时间
let start = CFAbsoluteTimeGetCurrent()
for _ in 0...99 {
    print(array.unique4)
}
print((CFAbsoluteTimeGetCurrent()-start)*1000)
//29.65402603149414
//[4, 6, 3, 0, 10, 5, 2, 7, 8, 1, 9]

因此最终结论，在需要保证数组顺序的情况下，第四种方案最佳，如果不需要保证数组顺序，Set是最优的方案。