Der beste Weg, um während der Iteration aus NSMutableArray zu entfernen?

Wenn ich in Cocoa ein NSMutableArray durchlaufen und mehrere Objekte entfernen möchte, die bestimmten Kriterien entsprechen, wie kann ich dies am besten tun, ohne die Schleife jedes Mal neu zu starten, wenn ich ein Objekt entferne?

Vielen Dank,

Bearbeiten: Nur zur Verdeutlichung - Ich habe nach dem besten Weg gesucht, z. B. nach etwas Eleganterem, als den Index, an dem ich mich befinde, manuell zu aktualisieren. Zum Beispiel in C ++ kann ich tun;

iterator it = someList.begin();

while (it != someList.end())
{
    if (shouldRemove(it))   
        it = someList.erase(it);
}

Aus Gründen der Klarheit möchte ich eine erste Schleife erstellen, in der ich die zu löschenden Elemente sammle. Dann lösche ich sie. Hier ist ein Beispiel mit der Objective-C 2.0-Syntax:

NSMutableArray *discardedItems = [NSMutableArray array];

for (SomeObjectClass *item in originalArrayOfItems) {
    if ([item shouldBeDiscarded])
        [discardedItems addObject:item];
}

[originalArrayOfItems removeObjectsInArray:discardedItems];

Dann gibt es keine Frage, ob die Indizes korrekt aktualisiert werden oder andere kleine Buchhaltungsdetails.

Bearbeitet, um hinzuzufügen:

In anderen Antworten wurde festgestellt, dass die inverse Formulierung schneller sein sollte. dh wenn Sie das Array durchlaufen und ein neues Array von Objekten erstellen, die beibehalten werden sollen, anstatt Objekte, die verworfen werden sollen. Das mag wahr sein (obwohl was ist mit den Speicher- und Verarbeitungskosten für das Zuweisen eines neuen Arrays und das Verwerfen des alten Arrays?), Aber selbst wenn es schneller ist, ist es möglicherweise nicht so wichtig wie für eine naive Implementierung, weil NSArrays Verhalten Sie sich nicht wie "normale" Arrays. Sie reden, aber sie gehen einen anderen Weg. Eine gute Analyse finden Sie hier:

Die inverse Formulierung mag schneller sein, aber ich musste mich nie darum kümmern, ob dies der Fall ist, da die obige Formulierung für meine Bedürfnisse immer schnell genug war.

Für mich ist die Botschaft zum Mitnehmen, die für Sie klarste Formulierung zu verwenden. Nur bei Bedarf optimieren. Ich persönlich finde die obige Formulierung am klarsten, weshalb ich sie verwende. Aber wenn Ihnen die umgekehrte Formulierung klarer ist, machen Sie es.

Noch eine Variation. So erhalten Sie Lesbarkeit und gute Leistung:

NSMutableIndexSet *discardedItems = [NSMutableIndexSet indexSet];
SomeObjectClass *item;
NSUInteger index = 0;

for (item in originalArrayOfItems) {
    if ([item shouldBeDiscarded])
        [discardedItems addIndex:index];
    index++;
}

[originalArrayOfItems removeObjectsAtIndexes:discardedItems];

Dies ist ein sehr einfaches Problem. Sie iterieren einfach rückwärts:

for (NSInteger i = array.count - 1; i >= 0; i--) {
   ElementType* element = array[i];
   if ([element shouldBeRemoved]) {
       [array removeObjectAtIndex:i];
   }
}

Dies ist ein sehr verbreitetes Muster.

Einige der anderen Antworten hätten eine schlechte Leistung bei sehr großen Arrays, da Methoden eine lineare Suche des Empfängers mögen removeObject:und removeObjectsInArray:beinhalten, was eine Verschwendung ist, da Sie bereits wissen, wo sich das Objekt befindet. Außerdem muss jeder Aufruf von removeObjectAtIndex:Werte um jeweils einen Steckplatz vom Index bis zum Ende des Arrays kopieren.

Effizienter wäre Folgendes:

NSMutableArray *array = ...
NSMutableArray *itemsToKeep = [NSMutableArray arrayWithCapacity:[array count]];
for (id object in array) {
    if (! shouldRemove(object)) {
        [itemsToKeep addObject:object];
    }
}
[array setArray:itemsToKeep];

Da wir die Kapazität von festlegen itemsToKeep, verschwenden wir keine Zeit damit, Werte während einer Größenänderung zu kopieren. Wir ändern das Array nicht an Ort und Stelle, daher können wir Fast Enumeration verwenden. Mit setArray:auf den Inhalt ersetzt arraymit itemsToKeepwird effizient sein. Abhängig von Ihrem Code können Sie sogar die letzte Zeile durch Folgendes ersetzen:

[array release];
array = [itemsToKeep retain];

Sie müssen also nicht einmal Werte kopieren, sondern nur einen Zeiger austauschen.

Mit NSpredicate können Sie Elemente aus Ihrem veränderlichen Array entfernen. Dies erfordert kein for-Schleifen.

Wenn Sie beispielsweise ein NSMutableArray mit Namen haben, können Sie ein Prädikat wie dieses erstellen:

NSPredicate *caseInsensitiveBNames = 
[NSPredicate predicateWithFormat:@"SELF beginswith[c] 'b'"];

In der folgenden Zeile erhalten Sie ein Array, das nur Namen enthält, die mit b beginnen.

[namesArray filterUsingPredicate:caseInsensitiveBNames];

Wenn Sie Probleme beim Erstellen der benötigten Prädikate haben, verwenden Sie diesen Apple-Entwicklerlink .

Ich habe einen Leistungstest mit 4 verschiedenen Methoden durchgeführt. Jeder Test durchlief alle Elemente in einem Array mit 100.000 Elementen und entfernte jedes fünfte Element. Die Ergebnisse variierten mit / ohne Optimierung nicht sehr. Diese wurden auf einem iPad 4 durchgeführt:

(1) removeObjectAtIndex:- 271 ms

(2) removeObjectsAtIndexes:- 1010 ms (da das Erstellen des Indexsatzes ~ 700 ms dauert; ansonsten entspricht dies im Grunde dem Aufruf von removeObjectAtIndex: für jedes Element)

(3) removeObjects:- 326 ms

(4) Erstellen Sie ein neues Array mit Objekten, die den Test bestehen - 17 ms

Das Erstellen eines neuen Arrays ist also bei weitem am schnellsten. Die anderen Methoden sind alle vergleichbar, mit der Ausnahme, dass die Verwendung von removeObjectsAtIndexes: aufgrund der zum Erstellen des Indexsatzes erforderlichen Zeit mit mehr zu entfernenden Elementen schlechter ist.

Verwenden Sie entweder eine Schleife, die über Indizes herunterzählt:

for (NSInteger i = array.count - 1; i >= 0; --i) {

oder erstellen Sie eine Kopie mit den Objekten, die Sie behalten möchten.

Verwenden Sie insbesondere keine for (id object in array)Schleife oder NSEnumerator.

Für iOS 4+ oder OS X 10.6+ hat Apple eine passingTestReihe von APIs hinzugefügt NSMutableArray, z – indexesOfObjectsPassingTest:. Eine Lösung mit einer solchen API wäre:

NSIndexSet *indexesToBeRemoved = [someList indexesOfObjectsPassingTest:
    ^BOOL(id obj, NSUInteger idx, BOOL *stop) {
    return [self shouldRemove:obj];
}];
[someList removeObjectsAtIndexes:indexesToBeRemoved];

Heutzutage können Sie die umgekehrte blockbasierte Aufzählung verwenden. Ein einfacher Beispielcode:

NSMutableArray *array = [@[@{@"name": @"a", @"shouldDelete": @(YES)},
                           @{@"name": @"b", @"shouldDelete": @(NO)},
                           @{@"name": @"c", @"shouldDelete": @(YES)},
                           @{@"name": @"d", @"shouldDelete": @(NO)}] mutableCopy];

[array enumerateObjectsWithOptions:NSEnumerationReverse usingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
    if([obj[@"shouldDelete"] boolValue])
        [array removeObjectAtIndex:idx];
}];

Ergebnis:

(
    {
        name = b;
        shouldDelete = 0;
    },
    {
        name = d;
        shouldDelete = 0;
    }
)

Eine weitere Option mit nur einer Codezeile:

[array filterUsingPredicate:[NSPredicate predicateWithFormat:@"shouldDelete == NO"]];

Je nach den Kriterien, die den zu entfernenden Elementen entsprechen, können Sie deklarativer Folgendes verwenden:

[theArray filterUsingPredicate:aPredicate]

@ Nathan sollte sehr effizient sein

Hier ist der einfache und saubere Weg. Ich möchte mein Array direkt im Aufruf der schnellen Aufzählung duplizieren:

for (LineItem *item in [NSArray arrayWithArray:self.lineItems]) 
{
    if ([item.toBeRemoved boolValue] == YES) 
    {
        [self.lineItems removeObject:item];
    }
}

Auf diese Weise führen Sie eine Kopie des Arrays auf, aus dem gelöscht wird, wobei beide dieselben Objekte enthalten. Ein NSArray enthält nur Objektzeiger, sodass dies in Bezug auf Speicher und Leistung völlig in Ordnung ist.

Fügen Sie die Objekte, die Sie entfernen möchten, zu einem zweiten Array hinzu und verwenden Sie nach der Schleife -removeObjectsInArray:.

das sollte es tun:

    NSMutableArray* myArray = ....;

    int i;
    for(i=0; i<[myArray count]; i++) {
        id element = [myArray objectAtIndex:i];
        if(element == ...) {
            [myArray removeObjectAtIndex:i];
            i--;
        }
    }

hoffe das hilft...

Warum fügen Sie die zu entfernenden Objekte nicht einem anderen NSMutableArray hinzu? Wenn Sie mit dem Iterieren fertig sind, können Sie die gesammelten Objekte entfernen.

Wie wäre es, wenn Sie die Elemente, die Sie löschen möchten, gegen das 'n'-te Element, das' n-1'-te Element usw. austauschen?

Wenn Sie fertig sind, ändern Sie die Größe des Arrays auf "vorherige Größe - Anzahl der Swaps".

Wenn alle Objekte in Ihrem Array eindeutig sind oder Sie alle Vorkommen eines Objekts entfernen möchten, wenn es gefunden wurde, können Sie eine Array-Kopie schnell auflisten und das Objekt mit [NSMutableArray removeObject:] aus dem Original entfernen.

NSMutableArray *myArray;
NSArray *myArrayCopy = [NSArray arrayWithArray:myArray];

for (NSObject *anObject in myArrayCopy) {
    if (shouldRemove(anObject)) {
        [myArray removeObject:anObject];
    }
}

Benzados Antwort oben ist das, was Sie für die Vorformung tun sollten. In einer meiner Anwendungen dauerte removeObjectsInArray eine Laufzeit von 1 Minute, das Hinzufügen zu einem neuen Array dauerte 0,023 Sekunden.

Ich definiere eine Kategorie, mit der ich mithilfe eines Blocks filtern kann:

@implementation NSMutableArray (Filtering)

- (void)filterUsingTest:(BOOL (^)(id obj, NSUInteger idx))predicate {
    NSMutableIndexSet *indexesFailingTest = [[NSMutableIndexSet alloc] init];

    NSUInteger index = 0;
    for (id object in self) {
        if (!predicate(object, index)) {
            [indexesFailingTest addIndex:index];
        }
        ++index;
    }
    [self removeObjectsAtIndexes:indexesFailingTest];

    [indexesFailingTest release];
}

@end

die dann so verwendet werden kann:

[myMutableArray filterUsingTest:^BOOL(id obj, NSUInteger idx) {
    return [self doIWantToKeepThisObject:obj atIndex:idx];
}];

Eine schönere Implementierung könnte darin bestehen, die unten stehende Kategoriemethode für NSMutableArray zu verwenden.

@implementation NSMutableArray(BMCommons)

- (void)removeObjectsWithPredicate:(BOOL (^)(id obj))predicate {
    if (predicate != nil) {
        NSMutableArray *newArray = [[NSMutableArray alloc] initWithCapacity:self.count];
        for (id obj in self) {
            BOOL shouldRemove = predicate(obj);
            if (!shouldRemove) {
                [newArray addObject:obj];
            }
        }
        [self setArray:newArray];
    }
}

@end

Der Prädikatblock kann implementiert werden, um die Verarbeitung für jedes Objekt im Array durchzuführen. Wenn das Prädikat true zurückgibt, wird das Objekt entfernt.

Ein Beispiel für ein Datumsarray zum Entfernen aller in der Vergangenheit liegenden Daten:

NSMutableArray *dates = ...;
[dates removeObjectsWithPredicate:^BOOL(id obj) {
    NSDate *date = (NSDate *)obj;
    return [date timeIntervalSinceNow] < 0;
}];

Rückwärts iterieren war jahrelang mein Favorit, aber lange Zeit bin ich nie auf den Fall gestoßen, dass das 'tiefste' Objekt (höchste Anzahl) zuerst entfernt wurde. Kurz bevor der Zeiger zum nächsten Index übergeht, gibt es nichts und es stürzt ab.

Benzados Weg kommt dem, was ich jetzt mache, am nächsten, aber ich hätte nie gedacht, dass es nach jedem Entfernen zu einer Stapelumbildung kommen würde.

unter Xcode 6 funktioniert das

NSMutableArray *itemsToKeep = [NSMutableArray arrayWithCapacity:[array count]];

    for (id object in array)
    {
        if ( [object isNotEqualTo:@"whatever"]) {
           [itemsToKeep addObject:object ];
        }
    }
    array = nil;
    array = [[NSMutableArray alloc]initWithArray:itemsToKeep];