лучший способ удалить из nsmutablearray во время итерации?

<p>в какао, если я хочу перебрать nsmutablearray и удалить несколько объектов, которые соответствуют определенным критериям, каков наилучший способ сделать это без перезапуска цикла каждый раз, когда я удаляю объект?</p><p>спасибо,</p><p>правка: просто чтобы уточнить - я искал лучший способ, например. что-то более элегантное, чем обновление индекса вручную. например, в c++ я могу сделать;</p><pre><code>iterator it = somelist.begin(); while (it != somelist.end()) { if (shouldremove(it)) it = somelist.erase(it); } </code></pre>

<p>для ясности я хотел бы сделать начальный цикл, где я собираю элементы для удаления. затем я их удаляю. вот пример с использованием синтаксиса objective-c 2.0:</p><pre><code>nsmutablearray *discardeditems = [nsmutablearray array]; for (someobjectclass *item in originalarrayofitems) { if ([item shouldbediscarded]) [discardeditems addobject:item]; } [originalarrayofitems removeobjectsinarray:discardeditems]; </code></pre><p>тогда не возникает вопроса о том, правильно ли обновляются индексы, или о других небольших бухгалтерских деталях.</p><p>отредактировано, чтобы добавить:</p><p>в других ответах было отмечено, что обратная формулировка должна быть быстрее. т.е., если вы выполняете итерацию по массиву и создаете новый массив объектов для хранения, а не объектов для отбрасывания. это может быть правдой (хотя как насчет затрат на память и обработку при выделении нового массива и отбрасывании старого?), но даже если он быстрее, он может оказаться не таким уж сложным, как для наивной реализации, потому что nsarrays не ведите себя как "нормальные" массивы. они говорят, говорят, но ходят по-другому. <a href="http://ridiculousfish.com/blog/posts/array.html">смотрите хороший анализ здесь:</a> </p><p>обратная формулировка может быть быстрее, но мне никогда не нужно было заботиться о том, так ли это, потому что приведенная выше формулировка всегда была достаточно быстрой для моих нужд.</p><p>для меня главная идея - использовать любую формулировку, которая вам наиболее понятна. оптимизируйте только при необходимости. я лично считаю вышеизложенную формулировку более ясной, поэтому я использую ее. но если обратная формулировка вам понятнее, сделайте это.</p>

<p>еще один вариант. таким образом, вы получите удобочитаемость и хорошую производительность:</p><pre><code>nsmutableindexset *discardeditems = [nsmutableindexset indexset]; someobjectclass *item; nsuinteger index = 0; for (item in originalarrayofitems) { if ([item shouldbediscarded]) [discardeditems addindex:index]; index++; } [originalarrayofitems removeobjectsatindexes:discardeditems]; </code></pre>

<p>это очень простая проблема. вы просто повторяете в обратном направлении:</p><pre><code>for (nsinteger i = array.count - 1; i >= 0; i--) { elementtype* element = array[i]; if ([element shouldberemoved]) { [array removeobjectatindex:i]; } } </code></pre><p>это очень распространенная модель.</p>

<p>некоторые из других ответов будут иметь низкую производительность на очень больших массивах, потому что такие методы, как <code>removeobject:</code> и <code>removeobjectsinarray:</code>, включают в себя линейный поиск получателя, что является пустой тратой, потому что вы уже знаете, где находится объект. кроме того, любой вызов <code>removeobjectatindex:</code> должен будет копировать значения из индекса в конец массива на один слот за раз.</p><p>более эффективным будет следующее:</p><pre><code>nsmutablearray *array = ... nsmutablearray *itemstokeep = [nsmutablearray arraywithcapacity:[array count]]; for (id object in array) { if (! shouldremove(object)) { [itemstokeep addobject:object]; } } [array setarray:itemstokeep]; </code></pre><p>поскольку мы устанавливаем емкость <code>itemstokeep</code>, мы не тратим время на копирование значений во время изменения размера. мы не модифицируем массив на месте, поэтому мы можем использовать быстрое перечисление. использование <code>setarray:</code> для замены содержимого <code>array</code> на <code>itemstokeep</code> будет эффективным. в зависимости от вашего кода, вы можете даже заменить последнюю строку на:</p><pre><code>[array release]; array = [itemstokeep retain]; </code></pre><p>таким образом, нет даже необходимости копировать значения, а только менять указатель.</p>

<p>вы можете использовать nspredicate для удаления элементов из вашего изменяемого массива. это не требует петель.</p><p>например, если у вас есть nsmutablearray из имен, вы можете создать предикат как этот:</p><pre><code>nspredicate *caseinsensitivebnames = [nspredicate predicatewithformat:@"self beginswith[c] 'b'"]; </code></pre><p>следующая строка оставит вас с массивом, который содержит только имена, начинающиеся с b.</p><pre><code>[namesarray filterusingpredicate:caseinsensitivebnames]; </code></pre><p>если у вас возникли проблемы с созданием необходимых предикатов, воспользуйтесь этой <a href="http://developer.apple.com/documentation/cocoa/conceptual/predicates/predicates.html">ссылкой для разработчиков apple</a> .</p>

<p>я сделал тест производительности, используя 4 разных метода. каждый тест проходил через все элементы в массиве из 100 000 элементов и удалял каждый 5-й элемент. результаты не сильно изменились с/без оптимизации. это было сделано на ipad 4:</p><p>(1) <code>removeobjectatindex:</code> -<strong> 271 мс </strong></p><p>(2) <code>removeobjectsatindexes:</code> -<strong> 1010 мс </strong>(поскольку создание набора индексов занимает ~ 700 мс; в противном случае это в основном то же самое, что и вызов removeobjectatindex: для каждого элемента)</p><p>(3) <code>removeobjects:</code> -<strong> 326 мс </strong></p><p>(4) создать новый массив с объектами, прошедшими тестирование -<strong> 17 мс </strong></p><p>таким образом, создание нового массива является самым быстрым. все остальные методы сопоставимы, за исключением того, что при использовании removeobjectsatindexes: будет хуже с удалением большего количества элементов из-за времени, необходимого для построения набора индексов.</p>

<p>либо используйте цикл обратного отсчета по индексам:</p><pre><code>for (nsinteger i = array.count - 1; i >= 0; --i) { </code></pre><p>или сделайте копию с объектами, которые вы хотите сохранить.</p><p>в частности, не используйте цикл <code>for (id object in array)</code> или <code>nsenumerator</code>.</p>

<p>для ios 4+ или os x 10.6+ apple добавила серию api <code>passingtest</code> в <code>nsmutablearray</code>, например <code>– indexesofobjectspassingtest:</code>. решение с таким api будет:</p><pre><code>nsindexset *indexestoberemoved = [somelist indexesofobjectspassingtest: ^bool(id obj, nsuinteger idx, bool *stop) { return [self shouldremove:obj]; }]; [somelist removeobjectsatindexes:indexestoberemoved]; </code></pre>

<p>в настоящее время вы можете использовать обратное перечисление на основе блоков. простой пример кода:</p><pre><code>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]; }]; </code></pre><p>результат:</p><pre><code>( { name = b; shoulddelete = 0; }, { name = d; shoulddelete = 0; } ) </code></pre><hr><p>другой вариант с одной строкой кода:</p><pre><code>[array filterusingpredicate:[nspredicate predicatewithformat:@"shoulddelete == no"]]; </code></pre>

<p>в более декларативной форме, в зависимости от критериев, соответствующих удаляемым элементам, вы можете использовать:</p><pre><code>[thearray filterusingpredicate:apredicate] </code></pre><p>@ натан должен быть очень эффективным</p>

<p>вот простой и чистый способ. мне нравится дублировать мой массив прямо в вызове быстрого перечисления:</p><pre><code>for (lineitem *item in [nsarray arraywitharray:self.lineitems]) { if ([item.toberemoved boolvalue] == yes) { [self.lineitems removeobject:item]; } } </code></pre><p>таким образом, вы перечисляете копию удаляемого массива, в котором хранятся одинаковые объекты. nsarray содержит только объектные указатели, так что это совершенно нормально с точки зрения памяти и производительности.</p>

<p>добавьте объекты, которые вы хотите удалить, во второй массив и после цикла используйте -removeobjectsinarray :.</p>

<p>это должно сделать это:</p><pre><code> nsmutablearray* myarray = ....; int i; for(i=0; i<[myarray count]; i++) { id element = [myarray objectatindex:i]; if(element == ...) { [myarray removeobjectatindex:i]; i--; } } </code></pre><p>надеюсь это поможет...</p>

<p>хорошей реализацией может быть использование метода категории ниже в nsmutablearray.</p><pre><code>@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 </code></pre><p>блок предикатов может быть реализован для обработки каждого объекта в массиве. если предикат возвращает true, объект удаляется.</p><p>пример массива дат для удаления всех дат, которые были в прошлом:</p><pre><code>nsmutablearray *dates = ...; [dates removeobjectswithpredicate:^bool(id obj) { nsdate *date = (nsdate *)obj; return [date timeintervalsincenow] < 0; }]; </code></pre>

<p>почему бы вам не добавить объекты для удаления в другой nsmutablearray. когда вы закончите итерацию, вы можете удалить объекты, которые вы собрали.</p>

<p>как насчет замены элементов, которые вы хотите удалить, на «n'th element», «n-1» и т.д.?</p><p>когда вы закончите, вы измените размер массива на «предыдущий размер - количество свопов»</p>

<p>если все объекты в вашем массиве уникальны или вы хотите удалить все вхождения объекта при обнаружении, вы можете быстро перечислить копию массива и использовать [nsmutablearray removeobject:], чтобы удалить объект из оригинала.</p><pre><code>nsmutablearray *myarray; nsarray *myarraycopy = [nsarray arraywitharray:myarray]; for (nsobject *anobject in myarraycopy) { if (shouldremove(anobject)) { [myarray removeobject:anobject]; } } </code></pre>

<p>я определяю категорию, которая позволяет мне фильтровать, используя блок, например так:</p><pre><code>@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 </code></pre><p>который затем можно использовать так:</p><pre><code>[mymutablearray filterusingtest:^bool(id obj, nsuinteger idx) { return [self doiwanttokeepthisobject:obj atindex:idx]; }]; </code></pre>

<p>ответ benzado выше, что вы должны сделать для производительности. в одном из моих приложений метод removeobjectsinarray занял 1 минуту, просто добавление в новый массив заняло 0,023 секунды. </p>

<p>итерации в обратном направлении были моими любимыми годами, но долгое время я никогда не сталкивался со случаем, когда самый глубокий (самый высокий счет) объект был удален первым. за мгновение до того, как указатель переходит к следующему индексу, ничего не происходит, и он падает. </p><p>путь бензадо - самый близкий к тому, что я делаю сейчас, но я никогда не думал, что после каждого удаления будет перестановка стека.</p><p>под xcode 6 это работает</p><pre><code>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]; </code></pre>