Cách tốt nhất để xóa khỏi NSMutableArray trong khi lặp lại?

Trong Ca cao, nếu tôi muốn lặp qua NSMutableArray và xóa nhiều đối tượng phù hợp với một tiêu chí nhất định, cách tốt nhất để làm điều này mà không cần khởi động lại vòng lặp mỗi khi tôi xóa đối tượng?

Cảm ơn,

Chỉnh sửa: Chỉ cần làm rõ - Tôi đang tìm kiếm cách tốt nhất, ví dụ: một cái gì đó thanh lịch hơn là cập nhật thủ công chỉ mục tôi đang ở. Ví dụ trong C ++ tôi có thể làm;

iterator it = someList.begin();

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

Để rõ ràng, tôi muốn tạo một vòng lặp ban đầu nơi tôi thu thập các mục cần xóa. Sau đó tôi xóa chúng. Đây là một mẫu sử dụng cú pháp Objective-C 2.0:

NSMutableArray *discardedItems = [NSMutableArray array];

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

[originalArrayOfItems removeObjectsInArray:discardedItems];

Sau đó, không có câu hỏi về việc liệu các chỉ số đang được cập nhật chính xác, hoặc các chi tiết kế toán nhỏ khác.

Chỉnh sửa để thêm:

Nó đã được lưu ý trong các câu trả lời khác rằng công thức nghịch đảo nên nhanh hơn. tức là Nếu bạn lặp qua mảng và soạn một mảng mới của các đối tượng cần giữ, thay vì các đối tượng để loại bỏ. Điều đó có thể đúng (mặc dù về bộ nhớ và chi phí xử lý để phân bổ một mảng mới và loại bỏ mảng cũ thì sao?) Nhưng ngay cả khi nó nhanh hơn thì nó cũng không phải là vấn đề lớn đối với việc triển khai ngây thơ, bởi vì NSArrays không hành xử như mảng "bình thường". Họ nói chuyện nhưng họ đi bộ khác nhau. Xem một phân tích tốt ở đây:

Công thức nghịch đảo có thể nhanh hơn, nhưng tôi không bao giờ cần quan tâm đến việc đó, bởi vì công thức trên luôn đủ nhanh cho nhu cầu của tôi.

Đối với tôi, thông điệp mang về nhà là sử dụng bất kỳ công thức nào là rõ ràng nhất đối với bạn. Tối ưu hóa chỉ khi cần thiết. Cá nhân tôi thấy công thức trên rõ ràng nhất, đó là lý do tại sao tôi sử dụng nó. Nhưng nếu công thức nghịch đảo rõ ràng hơn với bạn, hãy tìm nó.

Thêm một biến thể. Vì vậy, bạn có được khả năng đọc và hiệu suất tốt:

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

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

[originalArrayOfItems removeObjectsAtIndexes:discardedItems];

Đây là một vấn đề rất đơn giản. Bạn chỉ cần lặp lại ngược lại:

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

Đây là một mô hình rất phổ biến.

Một số câu trả lời khác sẽ có hiệu suất kém trên các mảng rất lớn, bởi vì các phương thức như removeObject:và removeObjectsInArray:liên quan đến việc tìm kiếm tuyến tính của máy thu, điều này thật lãng phí vì bạn đã biết đối tượng ở đâu. Ngoài ra, bất kỳ lệnh gọi nào removeObjectAtIndex:cũng sẽ phải sao chép các giá trị từ chỉ mục vào cuối mảng lên theo một vị trí tại một thời điểm.

Hiệu quả hơn sẽ là như sau:

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

Vì chúng tôi đặt dung lượng itemsToKeep, chúng tôi không lãng phí bất kỳ lúc nào sao chép giá trị trong khi thay đổi kích thước. Chúng tôi không sửa đổi mảng tại chỗ, vì vậy chúng tôi có thể tự do sử dụng Bảng liệt kê nhanh. Sử dụng setArray:để thay thế nội dung arrayvới itemsToKeepsẽ có hiệu quả. Tùy thuộc vào mã của bạn, bạn thậm chí có thể thay thế dòng cuối cùng bằng:

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

Vì vậy, thậm chí không cần sao chép giá trị, chỉ trao đổi một con trỏ.

Bạn có thể sử dụng NSpredicate để xóa các mục khỏi mảng có thể thay đổi của bạn. Điều này đòi hỏi không có vòng lặp.

Ví dụ: nếu bạn có một tên NSMutableArray, bạn có thể tạo một vị từ như thế này:

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

Dòng sau sẽ để lại cho bạn một mảng chỉ chứa các tên bắt đầu bằng b.

[namesArray filterUsingPredicate:caseInsensitiveBNames];

Nếu bạn gặp khó khăn khi tạo các vị từ bạn cần, hãy sử dụng liên kết nhà phát triển apple này .

Tôi đã làm một bài kiểm tra hiệu suất bằng 4 phương pháp khác nhau. Mỗi bài kiểm tra lặp lại qua tất cả các phần tử trong một mảng phần tử 100.000 và loại bỏ mọi mục thứ 5. Kết quả không thay đổi nhiều với / không có tối ưu hóa. Những điều này đã được thực hiện trên iPad 4:

(1) removeObjectAtIndex:- 271 ms

(2) removeObjectsAtIndexes:- 1010 ms (vì việc xây dựng bộ chỉ mục mất ~ 700 ms; nếu không, điều này về cơ bản giống như cách gọi removeObjectAtIndex: cho mỗi mục)

(3) removeObjects:- 326 ms

(4) tạo một mảng mới với các đối tượng vượt qua bài kiểm tra - 17 ms

Vì vậy, tạo ra một mảng mới là nhanh nhất. Các phương thức khác đều có thể so sánh được, ngoại trừ việc sử dụng removeObjectsAtIndexes: sẽ tệ hơn với nhiều mục cần xóa hơn, vì thời gian cần thiết để xây dựng bộ chỉ mục.

Sử dụng vòng lặp đếm ngược trên các chỉ số:

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

hoặc tạo một bản sao với các đối tượng bạn muốn giữ.

Cụ thể, không sử dụng for (id object in array)vòng lặp hoặc NSEnumerator.

Đối với iOS 4+ hoặc OS X 10.6+, Apple đã thêm passingTesthàng loạt API vào NSMutableArray, như – indexesOfObjectsPassingTest:. Một giải pháp với API như vậy sẽ là:

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

Ngày nay bạn có thể sử dụng phép liệt kê dựa trên khối đảo ngược. Một mã ví dụ đơn giản:

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

Kết quả:

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

một tùy chọn khác chỉ với một dòng mã:

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

Theo cách khai báo hơn, tùy thuộc vào tiêu chí phù hợp với các mục cần loại bỏ, bạn có thể sử dụng:

[theArray filterUsingPredicate:aPredicate]

@Nathan nên rất hiệu quả

Đây là cách dễ dàng và sạch sẽ. Tôi muốn nhân đôi mảng của mình ngay trong lệnh gọi liệt kê nhanh:

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

Bằng cách này, bạn liệt kê thông qua một bản sao của mảng bị xóa khỏi, cả hai đều giữ cùng một đối tượng. Một NSArray chỉ giữ các con trỏ đối tượng nên đây là bộ nhớ / hiệu năng hoàn toàn tốt.

Thêm các đối tượng bạn muốn xóa vào mảng thứ hai và sau vòng lặp, sử dụng -removeObjectsInArray :.

điều này nên làm điều đó:

    NSMutableArray* myArray = ....;

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

hi vọng điêu nay co ich...

Tại sao bạn không thêm các đối tượng cần xóa vào NSMutableArray khác. Khi bạn kết thúc việc lặp lại, bạn có thể xóa các đối tượng mà bạn đã thu thập.

Làm thế nào về việc hoán đổi các phần tử bạn muốn xóa với phần tử thứ n, phần tử thứ 1 và vân vân?

Khi bạn hoàn tất, bạn thay đổi kích thước mảng thành 'kích thước trước - số lần hoán đổi'

Nếu tất cả các đối tượng trong mảng của bạn là duy nhất hoặc bạn muốn xóa tất cả các lần xuất hiện của một đối tượng khi tìm thấy, bạn có thể liệt kê nhanh trên một bản sao mảng và sử dụng [NSMutableArray removeObject:] để xóa đối tượng khỏi bản gốc.

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

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

anwser của benzado ở trên là những gì bạn nên làm cho khuôn mẫu. Trong một trong các ứng dụng của tôi, removeObjectsInArray mất 1 phút để chạy, chỉ cần thêm vào một mảng mới mất 0,23 giây.

Tôi xác định một danh mục cho phép tôi lọc bằng cách sử dụng một khối, như thế này:

@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

mà sau đó có thể được sử dụng như thế này:

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

Việc triển khai tốt hơn có thể là sử dụng phương thức thể loại dưới đây trên 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

Khối vị ngữ có thể được thực hiện để xử lý trên từng đối tượng trong mảng. Nếu vị ngữ trả về true, đối tượng sẽ bị xóa.

Một ví dụ cho mảng ngày để xóa tất cả các ngày nằm trong quá khứ:

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

Lặp lại ngược-ly là sở thích của tôi trong nhiều năm, nhưng trong một thời gian dài, tôi chưa bao giờ gặp phải trường hợp đối tượng 'sâu nhất' (tính cao nhất) bị loại bỏ trước tiên. Trong giây lát trước khi con trỏ chuyển sang chỉ mục tiếp theo, không có gì và nó bị hỏng.

Cách của Benzado là gần nhất với những gì tôi làm bây giờ nhưng tôi không bao giờ nhận ra rằng sẽ có sự cải tổ ngăn xếp sau mỗi lần xóa.

trong Xcode 6, công việc này

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