19

假设我有一个 Event 类，它有 2 个属性：action (NSString) 和 date (NSDate)。

假设我有一个 Event 对象数组。问题是“日期”属性可以匹配。

我需要删除重复项，这意味着具有相同日期的 2 个不同对象是重复项。

我可以删除任何字符串或 nsdate 数组中的重复项，它们很容易比较。但是如何处理复杂的对象，它们的属性要在哪里进行比较呢？

不要问我到目前为止我做了什么，因为我唯一想到的就是冒泡排序，但它是一个新手解决方案，而且速度很慢。

非常感谢任何帮助（链接，tuts，代码）。

提前致谢。

编辑

感谢dasblinkenlight，我做了一个自定义方法：

- (NSArray *)removeDuplicatesInArray:(NSArray*)arrayToFilter{

    NSMutableSet *seenDates = [NSMutableSet set];
    NSPredicate *dupDatesPred = [NSPredicate predicateWithBlock: ^BOOL(id obj, NSDictionary *bind) {
        YourClass *e = (YourClass*)obj;
        BOOL seen = [seenDates containsObject:e.propertyName];
        if (!seen) {
            [seenDates addObject:e.when];
        }
        return !seen;
    }];
    return [arrayToFilter filteredArrayUsingPredicate:dupDatesPred];
}

这YourClass是对象所属的类的名称，也是propertyName您要比较的对象的属性。

假设 self.arrayWithObjects 包含 YourClass 的对象。

填充后，使用

self.arrayWithObjects = [self removeDuplicatesInArray:self.arrayWithObjects];

你就完成了。

dasblinkenlight 的所有学分。干杯!

4

6 回答 6

26

您可以创建一个NSMutableSet日期，迭代您的事件列表，并仅添加您之前没有遇到的日期的事件。

NSMutableSet *seenDates = [NSMutableSet set];
NSPredicate *dupDatesPred = [NSPredicate predicateWithBlock: ^BOOL(id obj, NSDictionary *bind) {
    Event *e = (Event*)obj;
    BOOL seen = [seenDates containsObject:e.date];
    if (!seen) {
        [seenDates addObject:e.date];
    }
    return !seen;
}];
NSArray *events = ... // This is your array which needs to be filtered
NSArray *filtered = [events filteredArrayUsingPredicate:dupDatesPred];
于 2012-11-21T18:10:11.603 回答
3

这不适用于kvc。我想以下解决方案可能适用于您的情况；

Event *event1 = [[Event alloc] init];
event1.name = @"Event1";
event1.date = [NSDate distantFuture];
Event *event2 = [[Event alloc] init];
event2.name = @"Event2";
event2.date = [NSDate distantPast];
Event *event3 = [[Event alloc] init];
event3.name = @"Event1";
event3.date = [NSDate distantPast];
NSArray *array = @[event1, event2, event3];

NSArray *filteredEvents =  [array valueForKeyPath:@"@distinctUnionOfObjects.name"];
于 2012-11-21T22:43:02.027 回答
2 
NSMutableArray *leftObjects = [duplicateArray mutableCopy];
NSMutableArray *nonDuplicates = [NSMutableArray new];
while (leftObjects.count > 0)
{
    YourClass *object = [leftObjects objectAtIndex:0];

    // find all objects matching your comaprison equality definition for YourClass
    NSArray *matches = [leftObjects filteredArrayUsingPredicate:
                        [NSPredicate predicateWithBlock:^BOOL(YourClass *evaluatedObject, NSDictionary *bindings)
                         {
                             return (evaluatedObject.name == object.name);
                         }] ];
    [leftObjects removeObjectsInArray:matches];

    // add first object (arbitrary, may decide which duplicate to pick)
    [nonDuplicates addObject:matches.firstObject];
}
于 2016-02-04T02:36:05.213 回答
0

我认为最有效的方法是NSDictionary将对象存储为值，将属性值存储为键，在将任何对象添加到字典之前检查它是否存在，这是 O(1) 操作，即整个过程将取 O(n)

这是代码

- (NSArray *)removeDuplicatesFromArray:(NSArray *)array onProperty:(NSString *)propertyName {
    NSMutableDictionary *dictionary = [[NSMutableDictionary alloc] init];

    for (int i=0; i<array.count; i++) {

        NSManagedObject *currentItem = array[i];
        NSString *propertyValue = [currentItem valueForKey:propertyName];

        if ([dictionary valueForKey:propertyValue] == nil) {
            [dictionary setValue:currentItem forKey:propertyValue];
        }
    }

    NSArray *uniqueItems = [dictionary allValues];

    return uniqueItems;
}

您可以将其用作以下内容

self.arrayWithObjects = [self removeDuplicatesFromArray:self.arrayWithObjects onProperty:@"when"];
于 2015-09-15T08:24:54.943 回答
0

这是 NSArray 类的 Swift 扩展，它删除了指定属性的重复项：

extension NSArray {
/**
 - parameter property: the name of the property to check for duplicates

 - returns: an array of objects without objects that share an identical value of the specified property
*/
  func arrayWithoutObjectsOfDuplicateProperty(property : String) -> [AnyObject] {
    var seenInstances = NSMutableSet()

    let predicate = NSPredicate { (obj, bind) -> Bool in
      let seen = seenInstances.containsObject(obj.valueForKey(property)!)

      if !seen {
        seenInstances.addObject(obj.valueForKey(property)!)
      }
        return !seen
      }      
      return self.filteredArrayUsingPredicate(predicate)
  }
}
于 2016-04-12T05:19:49.827 回答
0

这是工作中的 Swift 代码片段，它确实删除了重复项，同时保持了元素的顺序。

// 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

如果你想知道这个 reduce 魔法是如何工作的——这里完全一样，但是使用了更多扩展的 reduce 语法

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 中，然后到处玩。

于 2016-07-13T11:49:37.110 回答