从数组中删除重复的元素

我可能有一个如下所示的数组:

[1, 4, 2 , 2 , 6 , 24, 15 , 2, 60, 15 , 6 ] 

或者,实际上,数据的相似部分的任何序列。 我想要做的是确保每个相同的元素只有一个。 例如,上面的数组将变成:

 [1, 4, 2 , 6 , 24, 15 , 60] 

请注意,删除了2,6和15的副本,以确保每个相同元素只有一个。 Swift是否提供了一个简单的方法,或者我必须自己做?

你可以推出你自己的,例如像这样( 更新Swift 1.2和Set ):

 func uniq<S : SequenceType, T : Hashable where S.Generator.Element == T>(source: S) -> [T] { var buffer = [T]() var added = Set<T>() for elem in source { if !added.contains(elem) { buffer.append(elem) added.insert(elem) } } return buffer } let vals = [1, 4, 2, 2, 6, 24, 15, 2, 60, 15, 6] let uniqueVals = uniq(vals) // [1, 4, 2, 6, 24, 15, 60] 

你可以很容易地转换成一个集合,并返回到一个数组:

 let unique = Array(Set(originals)) 

这不保证保持数组的原始顺序。

这里有很多答案,但是我错过了这个简单的扩展,适合Swift 2以上:

 extension Array where Element:Equatable { func removeDuplicates() -> [Element] { var result = [Element]() for value in self { if result.contains(value) == false { result.append(value) } } return result } } 

使它非常简单。 可以这样调用:

 let arrayOfInts = [2, 2, 4, 4] print(arrayOfInts.removeDuplicates()) // Prints: [2, 4] 

基于属性进行过滤

要根据属性过滤数组,可以使用以下方法:

 extension Array { func filterDuplicates(@noescape includeElement: (lhs:Element, rhs:Element) -> Bool) -> [Element]{ var results = [Element]() forEach { (element) in let existingElements = results.filter { return includeElement(lhs: element, rhs: $0) } if existingElements.count == 0 { results.append(element) } } return results } } 

你可以调用如下:

 let filteredElements = myElements.filterDuplicates { $0.PropertyOne == $1.PropertyOne && $0.PropertyTwo == $1.PropertyTwo } 

这需要一些本页面已经提供的良好信息,并尽可能使用Hashable / Set方法,否则将返回到Equatable代码。

Swift 3

 public extension Sequence where Iterator.Element: Hashable { var uniqueElements: [Iterator.Element] { return Array( Set(self) ) } } public extension Sequence where Iterator.Element: Equatable { var uniqueElements: [Iterator.Element] { return self.reduce([]){ uniqueElements, element in uniqueElements.contains(element) ? uniqueElements : uniqueElements + [element] } } } 

Swift 2

 public extension SequenceType where Generator.Element: Hashable { var uniqueElements: [Generator.Element] { return Array( Set(self) ) } } public extension SequenceType where Generator.Element: Equatable { var uniqueElements: [Generator.Element] { return self.reduce([]){uniqueElements, element in uniqueElements.contains(element) ? uniqueElements : uniqueElements + [element] } } } 

将数组元素约束为Equatable,您可以使用它包含:

 extension Array where Element: Equatable { var orderedSet: Array { var array: [Element] = [] return flatMap { if array.contains($0) { return nil } else { array.append($0) return $0 } } } } 

另一种选择是将数组元素约束为Hashable,并使用一组来控制哪些元素必须映射到结果中:

 extension Array where Element: Hashable { var orderedSet: Array { var set = Set<Element>() return flatMap { set.insert($0).inserted ? $0 : nil } } } 

使用过滤器:

 extension Array where Element: Hashable { var orderedSet: Array { var set = Set<Element>() return filter { set.insert($0).inserted } } } 

或者使用NSOrderedSet:

 extension Array where Element: Hashable { var orderedSet: Array { return NSOrderedSet(array: self).array as? Array ?? [] } } 

 let integers = [1, 4, 2, 2, 6, 24, 15, 2, 60, 15, 6] let integersOrderedSet = integers.orderedSet // [1, 4, 2, 6, 24, 15, 60] 

从这里使用不可变类型而不是变量的替代(如果不是最优的)解决方案:

 func deleteDuplicates<S: ExtensibleCollectionType where S.Generator.Element: Equatable>(seq:S)-> S { let s = reduce(seq, S()){ ac, x in contains(ac,x) ? ac : ac + [x] } return s } 

包括比较Jean-Pillippe的强制性方法和功能性方法。

作为一个奖金,这个函数与字符串以及数组一起工作!

迅速2

uniq功能回答:

 func uniq<S: SequenceType, E: Hashable where E==S.Generator.Element>(source: S) -> [E] { var seen: [E:Bool] = [:] return source.filter({ (v) -> Bool in return seen.updateValue(true, forKey: v) == nil }) } 

使用:

 var test = [1,2,3,4,5,6,7,8,9,9,9,9,9,9] print(uniq(test)) //1,2,3,4,5,6,7,8,9 

Swift 3.0

 let uniqueUnordered = Array(Set(array)) let uniqueOrdered = Array(NSOrderedSet(array: array)) 

这是SequenceType上的一个类别,它保留了数组的原始顺序,但使用Set来执行contains查找,以避免Array的contains(_:)方法的O(n)开销。

 public extension Sequence where Iterator.Element: Hashable { public func unique() -> [Iterator.Element] { var buffer: [Iterator.Element] = [] var lookup = Set<Iterator.Element>() for element in self { guard !lookup.contains(element) else { continue } buffer.append(element) lookup.insert(element) } return buffer } } 

或者如果你没有Hashable,你可以这样做:

 public extension Sequence where Iterator.Element: Equatable { public func unique() -> [Iterator.Element] { var buffer: [Iterator.Element] = [] for element in self { guard !buffer.contains(element) else { continue } buffer.append(element) } return buffer } } 

你可以将这两个都粘贴到你的应用中,Swift会根据你的序列的Iterator.Element类型来选择正确的。

您可以直接使用set集合来删除重复,然后将其转换回数组

 var myArray = [1, 4, 2, 2, 6, 24, 15, 2, 60, 15, 6] var mySet = Set<Int>(myArray) myArray = Array(mySet) // [2, 4, 60, 6, 15, 24, 1] 

然后你可以按你的意愿来订购你的数组

 myArray.sort{$0 < $1} // [1, 2, 4, 6, 15, 24, 60] 

Daniel Krom的Swift 2答案稍微简洁一些,使用了一个尾随的闭包和速记参数名,这个名字看起来是基于Airspeed Velocity的原始答案的 :

 func uniq<S: SequenceType, E: Hashable where E == S.Generator.Element>(source: S) -> [E] { var seen = [E: Bool]() return source.filter { seen.updateValue(true, forKey: $0) == nil } } 

实现可以与uniq(_:)一起使用的自定义类型的示例(必须符合Hashable ,因此Equatable ,因为Hashable扩展了Equatable ):

 func ==(lhs: SomeCustomType, rhs: SomeCustomType) -> Bool { return lhs.id == rhs.id // && lhs.someOtherEquatableProperty == rhs.someOtherEquatableProperty } struct SomeCustomType { let id: Int // ... } extension SomeCustomType: Hashable { var hashValue: Int { return id } } 

在上面的代码中…

==的重载中使用的id可以是任何的Equatable类型(或返回Equatable类型的方法,例如someMethodThatReturnsAnEquatableType() )。 注释代码演示如何扩展相等检查,其中someOtherEquatablePropertyEquatable类型的另一个属性(但也可以是返回Equatable类型的方法)。

hashValue计算属性(要求符合Hashable )中使用的id可以是任何Hashable (也Equatable )属性(或返回Hashable类型的方法)。

使用uniq(_:)示例:

 var someCustomTypes = [SomeCustomType(id: 1), SomeCustomType(id: 2), SomeCustomType(id: 3), SomeCustomType(id: 1)] print(someCustomTypes.count) // 4 someCustomTypes = uniq(someCustomTypes) print(someCustomTypes.count) // 3 

另外一个Swift 3.0解决方案可以从数组中删除重复项。 这个解决方案改进了许多其他的解决方案,

  • 保留输入数组中元素的顺序
  • 线性复杂度O(n):单通滤波器O(n)+集合插入O(1)

给定整数数组:

 let numberArray = [10, 1, 2, 3, 2, 1, 15, 4, 5, 6, 7, 3, 2, 12, 2, 5, 5, 6, 10, 7, 8, 3, 3, 45, 5, 15, 6, 7, 8, 7] 

功能代码:

 func orderedSet<T: Hashable>(array: Array<T>) -> Array<T> { var unique = Set<T>() return array.filter { element in return unique.insert(element).inserted } } orderedSet(array: numberArray) // [10, 1, 2, 3, 15, 4, 5, 6, 7, 12, 8, 45] 

数组扩展代码:

 extension Array where Element:Hashable { var orderedSet: Array { var unique = Set<Element>() return filter { element in return unique.insert(element).inserted } } } numberArray.orderedSet // [10, 1, 2, 3, 15, 4, 5, 6, 7, 12, 8, 45] 

这段代码利用了在O(1)上执行的Set上的insert操作返回的结果,并返回一个元组,指示该元素是否被插入,或者是否已经存在于该集合中。

如果项目在设置中,则filter将从最终结果中排除它。

您可以随时使用字典,因为字典只能保存唯一的值。 例如:

 var arrayOfDates: NSArray = ["15/04/01","15/04/01","15/04/02","15/04/02","15/04/03","15/04/03","15/04/03"] var datesOnlyDict = NSMutableDictionary() var x = Int() for (x=0;x<(arrayOfDates.count);x++) { let date = arrayOfDates[x] as String datesOnlyDict.setValue("foo", forKey: date) } let uniqueDatesArray: NSArray = datesOnlyDict.allKeys // uniqueDatesArray = ["15/04/01", "15/04/03", "15/04/02"] println(uniqueDatesArray.count) // = 3 

正如你所看到的,结果数组并不总是按照“顺序”。 如果您想对数组进行排序/排序,请添加以下内容:

 var sortedArray = sorted(datesOnlyArray) { (obj1, obj2) in let p1 = obj1 as String let p2 = obj2 as String return p1 < p2 } println(sortedArray) // = ["15/04/01", "15/04/02", "15/04/03"] 

我使用@ Jean-Philippe Pellet的答案,并做了一个数组扩展,在数组上进行类似操作,同时保持元素的顺序。

 /// Extensions for performing set-like operations on lists, maintaining order extension Array where Element: Hashable { func unique() -> [Element] { var seen: [Element:Bool] = [:] return self.filter({ seen.updateValue(true, forKey: $0) == nil }) } func subtract(takeAway: [Element]) -> [Element] { let set = Set(takeAway) return self.filter({ !set.contains($0) }) } func intersect(with: [Element]) -> [Element] { let set = Set(with) return self.filter({ set.contains($0) }) } } 

让我建议一个类似于斯科特·加德纳的答案的答案,但更简洁的语法使用减少。 此解决方案从自定义对象数组中删除重复项(保持初始顺序)

 // Custom Struct. Can be also class. // Need to be `equitable` in order to use `contains` method below struct CustomStruct : Equatable { let name: String let lastName : String } // conform to Equatable protocol. feel free to change the logic of "equality" func ==(lhs: CustomStruct, rhs: CustomStruct) -> Bool { return (lhs.name == rhs.name && lhs.lastName == rhs.lastName) } let categories = [CustomStruct(name: "name1", lastName: "lastName1"), CustomStruct(name: "name2", lastName: "lastName1"), CustomStruct(name: "name1", lastName: "lastName1")] print(categories.count) // prints 3 // remove duplicates (and keep initial order of elements) let uniq1 : [CustomStruct] = categories.reduce([]) { $0.contains($1) ? $0 : $0 + [$1] } print(uniq1.count) // prints 2 - third element has removed 

而且如果你想知道如何减少魔法的作用 – 这里是完全一样的,但使用更多的扩展减少语法

 let uniq2 : [CustomStruct] = categories.reduce([]) { (result, category) in var newResult = result if (newResult.contains(category)) {} else { newResult.append(category) } return newResult } uniq2.count // prints 2 - third element has removed 

你可以简单地将这段代码复制粘贴到一个Swift Playground中,然后玩耍。

这只是一个非常简单和方便的实现。 在具有可相等元素的数组的扩展中计算的属性。

 extension Array where Element: Equatable { /// Array containing only _unique_ elements. var unique: [Element] { var result: [Element] = [] for element in self { if !result.contains(element) { result.append(element) } } return result } } 

对于元素既不是Hasable也不Comparable的数组(例如复杂的对象,字典或结构体),这个扩展提供了一个删除重复的通用方法:

 extension Array { func filterDuplicate<T>(_ keyValue:(Element)->T) -> [Element] { var uniqueKeys = Set<String>() return filter{uniqueKeys.insert("\(keyValue($0))").inserted} } } // example usage: (for a unique combination of attributes): peopleArray = peopleArray.filterDuplicate{ ($0.name, $0.age, $0.sex) } 

你不必费心使Hashable值,它可以让你使用不同的字段组合的唯一性。

这是我搜索网络后找到的答案,没有找到我正在寻找的东西。 使用一个Set,你可以添加所有的元素与减少。 然后我把结果,并将其转换为一个排序的数组。

 let initialArray = [1, 4, 2, 2, 6, 24, 15, 2, 60, 15, 6] let distinct2 = initialArray.reduce(Set<Int>(), combine: { (set, current) -> Set<Int> in var tmp = set tmp.insert(current) return tmp }) // distinct2 is now a set containing {2, 4, 60, 6, 15, 24, 1} // Make it into a sorted array let sorted = Array(distinct2).sorted(<) // Returns [1, 2, 4, 6, 15, 24, 60] 

在这里我已经为对象做了一些O(n)解决方案。 不是几行解决方案,但…

 struct DistinctWrapper <T>: Hashable { var underlyingObject: T var distinctAttribute: String var hashValue: Int { return distinctAttribute.hashValue } } func distinct<S : SequenceType, T where S.Generator.Element == T>(source: S, distinctAttribute: (T) -> String, resolution: (T, T) -> T) -> [T] { let wrappers: [DistinctWrapper<T>] = source.map({ return DistinctWrapper(underlyingObject: $0, distinctAttribute: distinctAttribute($0)) }) var added = Set<DistinctWrapper<T>>() for wrapper in wrappers { if let indexOfExisting = added.indexOf(wrapper) { let old = added[indexOfExisting] let winner = resolution(old.underlyingObject, wrapper.underlyingObject) added.insert(DistinctWrapper(underlyingObject: winner, distinctAttribute: distinctAttribute(winner))) } else { added.insert(wrapper) } } return Array(added).map( { return $0.underlyingObject } ) } func == <T>(lhs: DistinctWrapper<T>, rhs: DistinctWrapper<T>) -> Bool { return lhs.hashValue == rhs.hashValue } // tests // case : perhaps we want to get distinct addressbook list which may contain duplicated contacts like Irma and Irma Burgess with same phone numbers // solution : definitely we want to exclude Irma and keep Irma Burgess class Person { var name: String var phoneNumber: String init(_ name: String, _ phoneNumber: String) { self.name = name self.phoneNumber = phoneNumber } } let persons: [Person] = [Person("Irma Burgess", "11-22-33"), Person("Lester Davidson", "44-66-22"), Person("Irma", "11-22-33")] let distinctPersons = distinct(persons, distinctAttribute: { (person: Person) -> String in return person.phoneNumber }, resolution: { (p1, p2) -> Person in return p1.name.characters.count > p2.name.characters.count ? p1 : p2 } ) // distinctPersons contains ("Irma Burgess", "11-22-33") and ("Lester Davidson", "44-66-22") 

我相信提供一个uniq()uniqInPlace()函数来删除数组的值是很好的。 这与Swift提供的sort()sortInPlace()函数类似。 此外,因为它是一个数组,它应该保持它的元素的原始顺序。

 extension Array where Element: Equatable { public func uniq() -> [Element] { var arrayCopy = self arrayCopy.uniqInPlace() return arrayCopy } mutating public func uniqInPlace() { var seen = [Element]() var index = 0 for element in self { if seen.contains(element) { removeAtIndex(index) } else { seen.append(element) index++ } } } } 

你只能在变量数组(即var uniqInPlace()上使用uniqInPlace() ,因为你不能改变一个常量数组(即let )。

一些使用示例:

 var numbers = [1, 6, 2, 2, 4, 1, 5] numbers.uniqInPlace() // array is now [1, 6, 2, 4, 5] let strings = ["Y", "Z", "A", "Y", "B", "Y", "Z"] let uniqStrings = strings.uniq() // uniqStrings is now ["Y", "Z", "A", "B"] 

Swift 3

基于Jean-Philippe Pellet的回答 ,我更新了Swift 3的语法。

 func uniq<S : Sequence, T : Hashable where S.Iterator.Element == T>(source: S) -> [T] { var buffer = [T]() var added = Set<T>() for elem in source { if !added.contains(elem) { buffer.append(elem) added.insert(elem) } } return buffer } let vals = [1, 4, 2, 2, 6, 24, 15, 2, 60, 15, 6] let uniqueVals = uniq(source: vals) // [1, 4, 2, 6, 24, 15, 60] 

在Swift 3.0中,我发现在保持顺序的同时消除了重复的元素,这是最简单,最快速的解决方案:

 extension Array where Element:Hashable { var unique: [Element] { var set = Set<Element>() //the unique list kept in a Set for fast retrieval var arrayOrdered = [Element]() //keeping the unique list of elements but ordered for value in self { if !set.contains(value) { set.insert(value) arrayOrdered.append(value) } } return arrayOrdered } } 
 func removeDublicate (ab: [Int]) -> [Int] { var answer1:[Int] = [] for i in ab { if !answer1.contains(i) { answer1.append(i) }} return answer1 } 

用法:

 let f = removeDublicate(ab: [1,2,2]) print(f) 

斯威夫特4

 public extension Array where Element: Hashable { func uniqued() -> [Element] { var seen = Set<Element>() return filter{ seen.insert($0).inserted } } } 
  1. 转换为设置
  2. 检查元素数是否等于之前的数组
  3. 如果没有,则从Set创建Array

保留唯一的值并保留数组中的排序

(使用Swift 3)

  var top3score: [Int] = [] outerLoop: for i in 0..<top10score.count { dlog(message: String(top10score[i])) if top3score.count == 3 { break } for aTop3score in top3score { if aTop3score == top10score[i] { continue outerLoop } } top3score.append(top10score[i]) } print("top10score is \(top10score)") //[14, 5, 5, 5, 3, 3, 2, 2, 2, 2] print("top3score is \(top3score)") //[14, 5, 3] 

Swift 3.0

 extension Array where Element: Equatable { func withoutDuplicates() -> [Element] { return self.reduce([], { (objects, object) -> [Element] in var objects = objects if !objects.contains(object) { objects.append(object) } return objects }) } }