Yineleme sırasında NSMutableArray'den kaldırmanın en iyi yolu?

Kakao, bir NSMutableArray döngü ve belirli bir ölçütlere uyan birden çok nesne kaldırmak istiyorsanız, bir nesneyi her kaldırdığınızda döngü yeniden başlatmadan bunu yapmanın en iyi yolu nedir?

Teşekkürler,

Düzenleme: Sadece açıklığa kavuşturmak için - Ben en iyi yolu, örneğin elle indeks güncelleme daha zarif bir şey arıyordu. Örneğin C ++ ile yapabilirim;

iterator it = someList.begin();

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

Açıklık için silinecek öğeleri topladığım bir başlangıç ​​döngüsü oluşturmayı seviyorum. Sonra onları silerim. İşte Objective-C 2.0 sözdizimini kullanan bir örnek:

NSMutableArray *discardedItems = [NSMutableArray array];

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

[originalArrayOfItems removeObjectsInArray:discardedItems];

Ardından, endekslerin doğru bir şekilde güncellenip güncellenmediği veya diğer küçük defter tutma detaylarıyla ilgili bir soru yoktur.

Eklemek için düzenlendi:

Diğer cevaplarda ters formülasyonun daha hızlı olması gerektiği belirtilmiştir. yani dizi boyunca yineleme yapar ve atılacak nesneler yerine saklanacak yeni bir nesne dizisi oluşturursanız. Bu doğru olabilir (yeni bir dizi ayırmanın ve eski diziyi atmanın bellek ve işleme maliyeti ne olursa olsun), ancak daha hızlı olsa bile, saf bir uygulama için olduğu kadar büyük bir anlaşma olmayabilir, çünkü NSArrays "normal" diziler gibi davranmayın. Konuşmayı konuşuyorlar ama farklı bir yürüyüş yapıyorlar. Burada iyi bir analize bakın:

Ters formülasyon daha hızlı olabilir, ancak bunun olup olmadığına hiç dikkat etmemeliydim, çünkü yukarıdaki formülasyon her zaman ihtiyaçlarım için yeterince hızlıydı.

Benim için eve götüren mesaj size en açık formülasyonu kullanmaktır. Yalnızca gerekirse optimize edin. Kişisel olarak yukarıdaki formülasyonu en açık şekilde buluyorum, bu yüzden kullanıyorum. Ancak ters formülasyon sizin için daha açıksa, bunun için gidin.

Bir varyasyon daha. Böylece okunabilirlik ve iyi performans elde edersiniz:

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

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

[originalArrayOfItems removeObjectsAtIndexes:discardedItems];

Bu çok basit bir problem. Sadece geriye doğru yineliyorsunuz:

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

Bu çok yaygın bir örüntüdür.

Diğer cevapların bazıları çok büyük dizilerde düşük performans gösterecektir, çünkü yöntemler alıcının doğrusal bir arama yapmasını içerir removeObject:ve removeObjectsInArray:içerir, bu da bir israftır, çünkü nesnenin nerede olduğunu zaten biliyorsunuzdur. Ayrıca, yapılacak herhangi bir çağrının removeObjectAtIndex:değerleri dizinden dizinin sonuna kadar her seferinde bir yuva kadar kopyalaması gerekir.

Daha verimli şunlar olabilir:

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

Kapasitesini ayarladığımızdan, itemsToKeepyeniden boyutlandırma sırasında değerleri kopyalamak için zaman kaybetmeyiz. Diziyi yerinde değiştirmiyoruz, bu nedenle Hızlı Numaralandırma'yı kullanmakta özgürüz. Kullanılması setArray:içeriğini değiştirmek için arraybirlikte itemsToKeepverimli olacaktır. Kodunuza bağlı olarak, son satırı şununla da değiştirebilirsiniz:

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

Bu yüzden değerleri kopyalamaya bile gerek yok, sadece bir işaretçiyi değiştirin.

Değiştirilebilir dizinizden öğeleri kaldırmak için NSpredicate'i kullanabilirsiniz. Bunun için döngüler gerekmez.

Örneğin, bir NSMutableArray adınız varsa, bunun gibi bir yüklem oluşturabilirsiniz:

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

Aşağıdaki satırda yalnızca b ile başlayan isimler içeren bir dizi bırakılır.

[namesArray filterUsingPredicate:caseInsensitiveBNames];

İhtiyacınız olan tahminleri oluşturmakta sorun yaşıyorsanız, bu elma geliştirici bağlantısını kullanın .

4 farklı yöntem kullanarak performans testi yaptım. Her test, 100.000 öğe dizisindeki tüm öğeler arasında yinelendi ve her 5. öğeyi kaldırıldı. Sonuçlar optimizasyon ile / optimizasyon olmadan çok fazla değişmedi. Bunlar bir iPad 4'te yapıldı:

(1) removeObjectAtIndex:- 271 ms

(2) removeObjectsAtIndexes:- 1010 ms (çünkü dizin kümesinin oluşturulması ~ 700 ms sürer; aksi takdirde bu temel olarak her öğe için removeObjectAtIndex çağrılmasıyla aynıdır)

(3) removeObjects:- 326 ms

(4) testi geçen nesnelerle yeni bir dizi oluşturun - 17 ms

Yani, yeni bir dizi oluşturmak çok hızlı. Diğer yöntemlerin tümü karşılaştırılabilir, ancak removeObjectsAtIndexes: dizininin oluşturulması için gereken süre nedeniyle kaldırılacak daha fazla öğe kullanıldığında daha kötü olacaktır.

Endekslerde geri sayım döngüsünü kullanın:

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

veya saklamak istediğiniz nesnelerle bir kopyasını oluşturabilirsiniz.

Özellikle, bir for (id object in array)döngü kullanmayın NSEnumerator.

İOS 4+ veya OS X 10.6+ için Apple , gibi bir passingTestdizi API ekledi . Bu tür bir API ile bir çözüm şöyle olacaktır:NSMutableArray– indexesOfObjectsPassingTest:

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

Günümüzde tersine blok tabanlı numaralandırma kullanabilirsiniz. Basit bir örnek kod:

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

Sonuç:

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

sadece bir satır kod içeren başka bir seçenek:

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

Daha açıklayıcı bir şekilde, kaldırılacak öğelerle eşleşen ölçütlere bağlı olarak şunları kullanabilirsiniz:

[theArray filterUsingPredicate:aPredicate]

@Nathan çok verimli olmalı

İşte kolay ve temiz yol. Hızlı numaralandırma çağrısında dizimi çoğaltmak istiyorum:

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

Bu şekilde, her ikisi de aynı nesneleri tutan, silinen dizinin bir kopyası aracılığıyla numaralandırırsınız. NSArray yalnızca nesne işaretçileri tutar, böylece bu tamamen iyi bir bellek / performans açısından akıllıca olur.

Kaldırmak istediğiniz nesneleri ikinci bir diziye ekleyin ve döngüden sonra -removeObjectsInArray: öğesini kullanın.

bunu yapmalı:

    NSMutableArray* myArray = ....;

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

Bu yardımcı olur umarım...

Kaldırılacak nesneleri neden başka bir NSMutableArray'e eklemiyorsunuz? Yinelemeyi tamamladığınızda, topladığınız nesneleri kaldırabilirsiniz.

Silmek istediğiniz öğeleri 'n'th öğesi,' n-1'th öğesi vb. İle değiştirmeye ne dersiniz?

İşiniz bittiğinde diziyi 'önceki boyut - takas sayısı' olarak yeniden boyutlandırırsınız

Dizinizdeki tüm nesneler benzersizse veya bulunduğunda bir nesnenin tüm örneklerini kaldırmak istiyorsanız, bir dizi kopyasında hızlı numaralandırma yapabilir ve nesneyi orijinalden kaldırmak için [NSMutableArray removeObject:] kullanabilirsiniz.

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

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

benzado'nun yukarıdaki anwser preformace için yapmanız gereken şeydir. Uygulamalarımdan birinde removeObjectsInArray 1 dakikalık bir çalışma süresi aldı, sadece yeni bir diziye ekleme .023 saniye sürdü.

Ben şöyle bir blok kullanarak filtre sağlayan bir kategori tanımlamak:

@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

daha sonra şu şekilde kullanılabilir:

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

NSMutableArray'de aşağıdaki kategori yöntemini kullanmak daha iyi bir uygulama olabilir.

@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

Yüklem bloğu dizideki her bir nesne üzerinde işlem yapmak için uygulanabilir. Yüklem doğru döndürürse nesne kaldırılır.

Geçmişteki tüm tarihleri ​​kaldırmak için bir tarih dizisi örneği:

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

Yıllarca geriye doğru tekrarlamak benim favorimdi, ancak uzun bir süre önce 'en derin' (en yüksek sayım) nesnenin kaldırıldığı durumla hiç karşılaşmadım. İşaretçi bir sonraki dizine geçmeden önce hiçbir şey yok ve çöküyor.

Benzado'nun yolu şu anda yaptığım şeye en yakın olanıdır, ancak her kaldırmadan sonra yığın değişikliği olacağını asla fark etmedim.

Xcode 6 altında bu işe yarıyor

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