¿La mejor manera de eliminar de NSMutableArray mientras itera?

En Cocoa, si quiero recorrer un NSMutableArray y eliminar varios objetos que cumplan un determinado criterio, ¿cuál es la mejor manera de hacerlo sin reiniciar el ciclo cada vez que elimino un objeto?

Gracias,

Editar: solo para aclarar: estaba buscando la mejor manera, por ejemplo, algo más elegante que actualizar manualmente el índice en el que estoy. Por ejemplo en C ++ puedo hacer;

iterator it = someList.begin();

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

Para mayor claridad, me gusta hacer un bucle inicial donde recopilo los elementos para eliminar. Luego los elimino. Aquí hay una muestra usando la sintaxis de Objective-C 2.0:

NSMutableArray *discardedItems = [NSMutableArray array];

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

[originalArrayOfItems removeObjectsInArray:discardedItems];

Entonces no hay dudas sobre si los índices se están actualizando correctamente u otros pequeños detalles de contabilidad.

Editado para agregar:

Se ha observado en otras respuestas que la formulación inversa debería ser más rápida. es decir, si itera por la matriz y compone una nueva matriz de objetos para guardar, en lugar de objetos para descartar. Eso puede ser cierto (aunque ¿qué pasa con la memoria y el costo de procesamiento de asignar una nueva matriz y descartar la anterior?) Pero incluso si es más rápida, puede no ser tan importante como lo sería para una implementación ingenua, porque NSArrays no se comporten como matrices "normales". Hablan la charla pero caminan un camino diferente. Vea un buen análisis aquí:

La formulación inversa puede ser más rápida, pero nunca he tenido que preocuparme si es así, porque la formulación anterior siempre ha sido lo suficientemente rápida para mis necesidades.

Para mí, el mensaje final es usar cualquier formulación que sea más clara para usted. Optimice solo si es necesario. Personalmente, considero que la formulación anterior es más clara, por eso la uso. Pero si la formulación inversa es más clara para usted, hágalo.

Una variante más. Entonces obtienes legibilidad y buen rendimiento:

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

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

[originalArrayOfItems removeObjectsAtIndexes:discardedItems];

Este es un problema muy simple. Simplemente iteras hacia atrás:

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

Este es un patrón muy común.

Algunas de las otras respuestas tendrían malos resultados en las matrices muy grandes, ya que los métodos como removeObject:e removeObjectsInArray:implican hacer una búsqueda lineal del receptor, que es una pérdida debido a que ya sabe dónde está el objeto. Además, cualquier llamada aremoveObjectAtIndex: tendrá que copiar valores desde el índice hasta el final de la matriz en una ranura a la vez.

Más eficiente sería lo siguiente:

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

Debido a que establecemos la capacidad de itemsToKeep, no perdemos el tiempo copiando valores durante un cambio de tamaño. No modificamos la matriz en su lugar, por lo que somos libres de usar la enumeración rápida. Usar setArray:para reemplazar el contenido de arraycon itemsToKeepserá eficiente. Dependiendo de su código, incluso podría reemplazar la última línea con:

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

Por lo tanto, ni siquiera es necesario copiar valores, solo intercambiar un puntero.

Puede usar NSpredicate para eliminar elementos de su matriz mutable. Esto requiere no para bucles.

Por ejemplo, si tiene un NSMutableArray de nombres, puede crear un predicado como este:

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

La siguiente línea lo dejará con una matriz que contiene solo nombres que comienzan con b.

[namesArray filterUsingPredicate:caseInsensitiveBNames];

Si tiene problemas para crear los predicados que necesita, use este enlace de desarrollador de Apple .

Hice una prueba de rendimiento con 4 métodos diferentes. Cada prueba recorrió todos los elementos en una matriz de 100,000 elementos y eliminó cada quinto elemento. Los resultados no variaron mucho con / sin optimización. Estos se hicieron en un iPad 4:

(1) removeObjectAtIndex:- 271 ms

(2) removeObjectsAtIndexes:- 1010 ms (porque construir el conjunto de índices lleva ~ 700 ms; de lo contrario, esto es básicamente lo mismo que llamar a removeObjectAtIndex: para cada elemento)

(3) removeObjects:- 326 ms

(4) hacer una nueva matriz con objetos que pasan la prueba - 17 ms

Por lo tanto, crear una nueva matriz es, con mucho, el más rápido. Los otros métodos son todos comparables, excepto que usar removeObjectsAtIndexes: será peor con más elementos para eliminar, debido al tiempo necesario para construir el conjunto de índices.

Utilice el ciclo de cuenta regresiva sobre los índices:

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

o haga una copia con los objetos que desea conservar.

En particular, no use un for (id object in array)bucle o NSEnumerator.

Para iOS 4+ u OS X 10.6+, Apple agregó passingTestseries de API en NSMutableArray, como – indexesOfObjectsPassingTest:. Una solución con dicha API sería:

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

Hoy en día puede usar la enumeración inversa basada en bloques. Un código de ejemplo simple:

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];
}];

Resultado:

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

Otra opción con solo una línea de código:

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

De una manera más declarativa, dependiendo de los criterios que coincidan con los elementos a eliminar, podría usar:

[theArray filterUsingPredicate:aPredicate]

@Nathan debería ser muy eficiente

Aquí está la manera fácil y limpia. Me gusta duplicar mi matriz directamente en la llamada de enumeración rápida:

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

De esta manera, enumera a través de una copia de la matriz que se está eliminando, ambos con los mismos objetos. Un NSArray contiene punteros de objetos solo, por lo que es una memoria / rendimiento totalmente buena.

Agregue los objetos que desea eliminar a una segunda matriz y, después del ciclo, use -removeObjectsInArray :.

esto debería hacerlo:

    NSMutableArray* myArray = ....;

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

espero que esto ayude...

¿Por qué no agrega los objetos que se eliminarán a otro NSMutableArray? Cuando termine de iterar, puede eliminar los objetos que ha recopilado.

¿Qué tal intercambiar los elementos que desea eliminar con el 'n' elemento, 'n-1' elemento y así sucesivamente?

Cuando haya terminado, cambia el tamaño de la matriz a 'tamaño anterior: número de intercambios'

Si todos los objetos en su matriz son únicos o si desea eliminar todas las apariciones de un objeto cuando se encuentra, puede enumerar rápidamente en una copia de matriz y usar [NSMutableArray removeObject:] para eliminar el objeto del original.

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

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

La respuesta anterior de benzado es lo que debe hacer para el preformado. En una de mis aplicaciones, removeObjectsInArray tomó un tiempo de ejecución de 1 minuto, solo agregar a una nueva matriz tomó 0.023 segundos.

Defino una categoría que me permite filtrar usando un bloque, como este:

@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

que luego se puede usar así:

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

Una implementación más agradable podría ser usar el método de categoría a continuación en NSMutableArray.

@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

El bloque de predicados se puede implementar para procesar en cada objeto de la matriz. Si el predicado devuelve verdadero, el objeto se elimina.

Un ejemplo de una matriz de fechas para eliminar todas las fechas anteriores:

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

Iterar hacia atrás fue mi favorito durante años, pero durante mucho tiempo nunca me encontré con el caso en el que primero se eliminó el objeto 'más profundo' (conteo más alto). Momentáneamente antes de que el puntero pase al siguiente índice, no hay nada y se bloquea.

El camino de Benzado es el más cercano a lo que hago ahora, pero nunca me di cuenta de que habría una reorganización de la pila después de cada eliminación.

bajo Xcode 6 esto funciona

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];