Найкращий спосіб видалити з NSMutableArray під час ітерації?

Якщо в какао, якщо я хочу пройти цикл через NSMutableArray та видалити декілька об'єктів, що відповідають певним критеріям, який найкращий спосіб зробити це, не перезавантажуючи цикл кожного разу, коли я видаляю об'єкт?

Дякую,

Редагувати: Просто для уточнення - я шукав найкращий спосіб, наприклад, щось більш елегантне, ніж оновлення індексу вручну вручну. Наприклад, на C ++ я можу зробити;

iterator it = someList.begin();

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

Для наочності я люблю робити початковий цикл, де я збираю елементи, які потрібно видалити. Потім я видаляю їх. Ось зразок із використанням синтаксису Objective-C 2.0:

NSMutableArray *discardedItems = [NSMutableArray array];

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

[originalArrayOfItems removeObjectsInArray:discardedItems];

Тоді не виникає сумнівів у тому, чи правильно оновлюються індекси, чи інші дрібні дані бухгалтерії.

Відредаговано, щоб додати:

В інших відповідях зазначалося, що зворотна формулювання повинна бути швидшою. тобто якщо ви повторюєте масив і складаєте новий масив об'єктів, який потрібно зберігати, а не об'єкти для відкидання. Це може бути правдою (хоча як щодо витрат на пам'ять та обробку на виділення нового масиву та відмову від старого?), Але навіть якщо це швидше, це може бути не настільки великою справою, як це було б для наївної реалізації, тому що NSArrays не поводяться як "нормальні" масиви. Вони говорять на розмову, але вони ходять іншою прогулянкою. Дивіться хороший аналіз тут:

Зворотна рецептура може бути швидшою, але мені ніколи не потрібно було дбати, чи є вона, тому що вищевказана рецептура завжди була досить швидкою для моїх потреб.

Для мене повідомлення з дому - використовувати будь-який склад, який вам найбільш зрозумілий. Оптимізуйте лише за потреби. Особисто я вважаю, що вищевказана рецептура є найяснішою, саме тому я її використовую. Але якщо зворотна формулювання вам зрозуміліша, ідіть до цього.

Ще одна варіація. Таким чином ви отримуєте читабельність та хорошу ефективність:

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

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

[originalArrayOfItems removeObjectsAtIndexes:discardedItems];

Це дуже проста проблема. Ви просто повторіть назад:

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

Це дуже поширена закономірність.

Деякі інші відповіді будуть мати низьку продуктивність на дуже великих масивів, так як методи , як removeObject:і removeObjectsInArray:включати в себе робити лінійний пошук приймача, який представляє собою відходи , тому що ви вже знаєте , де об'єкт. Також будь-який виклик до removeObjectAtIndex:повинен буде копіювати значення з індексу в кінець масиву вгору по одному слоту за один раз.

Більш ефективним було б таке:

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

Оскільки ми встановлюємо ємність itemsToKeep, ми не витрачаємо часу на копіювання значень під час зміни розміру. Ми не змінюємо масив на місці, тому ми можемо використовувати швидкий перелік. Використання setArray:для заміни вмісту arrayз itemsToKeepбуде ефективним. Залежно від коду, ви навіть можете замінити останній рядок на:

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

Тож навіть не потрібно копіювати значення, лише міняйте покажчик.

Ви можете використовувати NSpredicate для видалення елементів зі свого змінного масиву. Для циклів це не потрібно.

Наприклад, якщо у вас є NSMutableArray імен, ви можете створити предикат на зразок цього:

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

Наступний рядок залишить вам масив, який містить лише імена, починаючи з b.

[namesArray filterUsingPredicate:caseInsensitiveBNames];

Якщо у вас виникли проблеми зі створенням потрібних предикатів, скористайтеся цим посиланням для розробників яблук .

Я зробив тест на працездатність, використовуючи 4 різні методи. Кожен тест повторювався через усі елементи в масиві 100 000 елементів і видаляв кожен 5-й елемент. Результати не сильно відрізнялися із / без оптимізації. Це було зроблено на iPad 4:

(1) removeObjectAtIndex:- 271 мс

(2) removeObjectsAtIndexes:- 1010 мс (оскільки складання набору індексів займає ~ 700 мс; інакше це в основному те саме, що викликати RemoveObjectAtIndex: для кожного елемента)

(3) removeObjects:- 326 мс

(4) скласти новий масив з об’єктами, що проходять тест - 17 мс

Отже, створити новий масив - це найшвидше. Інші методи всі порівнянні, за винятком того, що використання RemoveObjectsAtIndexes: буде гірше, якщо видалити більше елементів, через час, необхідний для складання набору індексів.

Або використовуйте зворотний відлік циклу за показниками:

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

або зробити копію з об’єктами, які ви хочете зберегти.

Зокрема, не використовуйте for (id object in array)петлю або NSEnumerator.

Для iOS 4+ або OS X 10.6+, Apple додала passingTestряд API NSMutableArray, наприклад – indexesOfObjectsPassingTest:. Рішення з таким API буде:

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

Сьогодні ви можете використовувати зворотне перерахування на основі блоків. Простий приклад коду:

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

Результат:

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

інший варіант із лише одним рядком коду:

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

Більш декларативно, залежно від критеріїв, які відповідають елементам для видалення, ви можете використовувати:

[theArray filterUsingPredicate:aPredicate]

@Nathan має бути дуже ефективним

Ось простий і чистий спосіб. Мені подобається дублювати масив прямо під час виклику швидкого перерахування:

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

Таким чином ви перераховуєте копію масиву, що видаляється з обох, що містять однакові об'єкти. NSArray утримує лише вказівники об'єкта, так що це абсолютно чудова пам'ять / продуктивність.

Додайте об'єкти, які ви хочете видалити, до другого масиву та після циклу використовуйте -removeObjectsInArray :.

це слід зробити:

    NSMutableArray* myArray = ....;

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

сподіваюся, що це допоможе ...

Чому б вам не додати об’єкти для видалення до іншого NSMutableArray. Закінчивши ітерацію, ви можете видалити зібрані вами предмети.

Як щодо заміни елементів, які ви хочете видалити, елементами 'n'th,' n-1'th тощо?

Коли ви закінчите, ви зміните розмір масиву до "попереднього розміру - кількість підкачок"

Якщо всі об'єкти у вашому масиві унікальні або ви хочете видалити всі виникнення об'єкта при їх знаходженні, ви можете швидко перерахувати копію масиву та використати [NSMutableArray removeObject:] для видалення об'єкта з оригіналу.

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

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

Зверху бензадо - це те, що слід зробити для підготовки. В одному з моїх додатків deleteObjectsInArray зайняв час роботи 1 хвилину, просто додавання до нового масиву займало 0,023 секунди.

Я визначаю категорію, яка дозволяє мені фільтрувати за допомогою блоку, як це:

@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

які потім можна використовувати так:

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

Більш приємною реалізацією може бути використання методу категорії, наведеного нижче на 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

Блок предиката може бути реалізований для виконання обробки кожного об'єкта в масиві. Якщо предикат повертає істину, об'єкт видаляється.

Приклад масиву дат для видалення всіх дат, що були в минулому:

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

Ітерація назад була моїм улюбленим протягом багатьох років, але довгий час я ніколи не стикався з випадком, коли «глибокий» (найвищий показник) об’єкт був видалений першим. За мить до того, як вказівник перейде до наступного індексу, нічого немає, і він виходить з ладу.

Шлях Бензадо є найближчим до того, що я роблю зараз, але я ніколи не зрозумів, що буде перестановка штабу після кожного видалення.

під Xcode 6 це працює

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