Как я могу обратить NSArray в Objective-C?


356

Мне нужно поменять местами NSArray.

Например:

[1,2,3,4,5] должен стать: [5,4,3,2,1]

Каков наилучший способ достичь этого?


1
Также стоит взглянуть на это: http://developer.apple.com/mac/library/documentation/Cocoa/Conceptual/Collections/Articles/sortingFilteringArrays.html, который говорит вам, как сортировать массив в обратном порядке (что обычно вы, например, используете массив, полученный из NSDictionary # allKeys, и вы хотите, чтобы обратный порядок даты / альфа служил группировкой для UITable на iPhone и т. д.).

Ответы:


305

Чтобы получить обратную копию массива, посмотрите на решение danielpunkass, используя reverseObjectEnumerator.

Для обращения изменяемого массива вы можете добавить в свой код следующую категорию:

@implementation NSMutableArray (Reverse)

- (void)reverse {
    if ([self count] <= 1)
        return;
    NSUInteger i = 0;
    NSUInteger j = [self count] - 1;
    while (i < j) {
        [self exchangeObjectAtIndex:i
                  withObjectAtIndex:j];

        i++;
        j--;
    }
}

@end

15
Одна из неприятностей в Fast Enumeration заключается в том, что такие новые парни, как я, не узнают о таких крутых вещах, как reverseObjectEnumerator. Довольно аккуратный способ сделать это.
Брент Роял-Гордон

4
Поскольку итераторы C ++ имеют еще худший синтаксис, они ужасны.
Георг Шолли

4
Разве вы не должны скопировать массив перед его возвратом?
CIFilter

12
@ Георг: я не согласен с вами в этом. Если я вижу метод, который возвращает неизменный объект, я ожидаю, что он на самом деле возвращает неизменный объект. По-видимому, возвращение неизменяемого объекта, но фактическое возвращение изменяемого объекта - опасная практика.
Кристина

3
Предложив reverseObjectEnumerator AllObjects не полезно , так как оно не меняет в изменяемый массив, даже добавление mutableCopy не поможет , так как до сих пор исходный массив не мутировал. Apple документирует, что неизменность не должна проверяться во время выполнения, а должна основываться на возвращаемом типе, поэтому возвращение NSMutableArray в этом случае является совершенно правильным кодом.
Питер Н Льюис

1286

Существует гораздо более простое решение, если вы используете встроенный reverseObjectEnumeratorметод NSArrayи allObjectsметод NSEnumerator:

NSArray* reversedArray = [[startArray reverseObjectEnumerator] allObjects];

allObjectsзадокументировано как возвращение массива с объектами, которые еще не были пройдены nextObject, в следующем порядке:

Этот массив содержит все остальные объекты перечислителя в порядке перечисления .



1
Что означает «неправильный набор»? Массив, который не в обратном порядке?
Симо Салминен

31
Я больше не могу воспроизвести эту ошибку. Это могло быть моей ошибкой. Это очень элегантное решение.
Мэтт Уильямсон

3
Заказ теперь гарантирован в документации.
ОАО

Я уверен, что это хороший ответ, но он не удастся для изменяемых объектов. Потому что NSEnumerator предоставляет объект типа «только для чтения» @property (только для чтения, копирование) NSArray <ObjectType> * allObjects;
Анураг Сони

49

Некоторые тесты

1. reverseObjectEnumerator allObjects

Это самый быстрый метод:

NSArray *anArray = @[@"aa", @"ab", @"ac", @"ad", @"ae", @"af", @"ag",
        @"ah", @"ai", @"aj", @"ak", @"al", @"am", @"an", @"ao", @"ap", @"aq", @"ar", @"as", @"at",
        @"au", @"av", @"aw", @"ax", @"ay", @"az", @"ba", @"bb", @"bc", @"bd", @"bf", @"bg", @"bh",
        @"bi", @"bj", @"bk", @"bl", @"bm", @"bn", @"bo", @"bp", @"bq", @"br", @"bs", @"bt", @"bu",
        @"bv", @"bw", @"bx", @"by", @"bz", @"ca", @"cb", @"cc", @"cd", @"ce", @"cf", @"cg", @"ch",
        @"ci", @"cj", @"ck", @"cl", @"cm", @"cn", @"co", @"cp", @"cq", @"cr", @"cs", @"ct", @"cu",
        @"cv", @"cw", @"cx", @"cy", @"cz"];

NSDate *methodStart = [NSDate date];

NSArray *reversed = [[anArray reverseObjectEnumerator] allObjects];

NSDate *methodFinish = [NSDate date];
NSTimeInterval executionTime = [methodFinish timeIntervalSinceDate:methodStart];
NSLog(@"executionTime = %f", executionTime);

Результат: executionTime = 0.000026

2. Итерация по reverseObjectEnumerator

Это в 1,5–2,5 раза медленнее:

NSDate *methodStart = [NSDate date];
NSMutableArray *array = [NSMutableArray arrayWithCapacity:[anArray count]];
NSEnumerator *enumerator = [anArray reverseObjectEnumerator];
for (id element in enumerator) {
    [array addObject:element];
}
NSDate *methodFinish = [NSDate date];
NSTimeInterval executionTime = [methodFinish timeIntervalSinceDate:methodStart];
NSLog(@"executionTime = %f", executionTime);

Результат: executionTime = 0.000071

3. sortedArrayUsingComparator

Это в 30–40 раз медленнее (здесь никаких сюрпризов):

NSDate *methodStart = [NSDate date];
NSArray *reversed = [anArray sortedArrayUsingComparator: ^(id obj1, id obj2) {
    return [anArray indexOfObject:obj1] < [anArray indexOfObject:obj2] ? NSOrderedDescending : NSOrderedAscending;
}];

NSDate *methodFinish = [NSDate date];
NSTimeInterval executionTime = [methodFinish timeIntervalSinceDate:methodStart];
NSLog(@"executionTime = %f", executionTime);

Результат: executionTime = 0.001100

Так [[anArray reverseObjectEnumerator] allObjects]же, как и скорость, и легкость.


И я могу представить, что это будет намного более чем в 30-40 раз медленнее для большего количества объектов. Я не знаю, какова сложность алгоритма сортировки (в лучшем случае O (n * logn)?), Но он также вызывает indexOfObject, который, вероятно, O (n). С сортировкой это может быть O (n ^ 2 * logn) или что-то. Не хорошо!
Джозеф Хамфри

1
Как насчет использования теста enumerateObjectsWithOptions:NSEnumerationReverse?
brandonscript

2
Я только что сделал бенчмаркинг с использованием enumerateObjectsWithOptions:NSEnumerationReverse- самый верхний завершился за 0.000072считанные секунды, блочный метод за 0.000009секунды
brandonscript

Хорошее наблюдение, это имеет смысл для меня, но я думаю, что время выполнения слишком короткое, чтобы сделать вывод, что алгоритм X в Y раз быстрее, чем другие. Чтобы измерить производительность выполнения алгоритма, нам нужно позаботиться о нескольких вещах, например: есть ли какой-то процесс, который выполняется одновременно? Например, возможно, при запуске первого алгоритма у вас будет больше доступной кэш-памяти и так далее. Кроме того, существует только один набор данных, я думаю, что мы должны работать с несколькими наборами данных (с разными размерами составов), чтобы сделать вывод.
pcambre

21

У DasBoot правильный подход, но в его коде есть несколько ошибок. Вот полностью обобщенный фрагмент кода, который перевернет любой NSMutableArray на месте:

/* Algorithm: swap the object N elements from the top with the object N 
 * elements from the bottom. Integer division will wrap down, leaving 
 * the middle element untouched if count is odd.
 */
for(int i = 0; i < [array count] / 2; i++) {
    int j = [array count] - i - 1;

    [array exchangeObjectAtIndex:i withObjectAtIndex:j];
}

Вы можете обернуть это в функцию C, или для бонусных баллов, используйте категории, чтобы добавить его в NSMutableArray. (В этом случае «массив» станет «я».) Вы также можете оптимизировать его, назначив [array count]переменную перед циклом и используя эту переменную, если хотите.

Если у вас есть только обычный NSArray, нет способа отменить его на месте, потому что NSArrays нельзя изменить. Но вы можете сделать обратную копию:

NSMutableArray * copy = [NSMutableArray arrayWithCapacity:[array count]];

for(int i = 0; i < [array count]; i++) {
    [copy addObject:[array objectAtIndex:[array count] - i - 1]];
}

Или используйте этот маленький трюк, чтобы сделать это в одной строке:

NSArray * copy = [[array reverseObjectEnumerator] allObjects];

Если вы просто хотите перебрать массив в обратном направлении, вы можете использовать for/ inloop с [array reverseObjectEnumerator], но это, вероятно, немного более эффективно -enumerateObjectsWithOptions:usingBlock::

[array enumerateObjectsWithOptions:NSEnumerationReverse
                        usingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
    // This is your loop body. Use the object in obj here. 
    // If you need the index, it's in idx.
    // (This is the best feature of this method, IMHO.)
    // Instead of using 'continue', use 'return'.
    // Instead of using 'break', set '*stop = YES' and then 'return'.
    // Making the surrounding method/block return is tricky and probably
    // requires a '__block' variable.
    // (This is the worst feature of this method, IMHO.)
}];

( Примечание : существенно обновлено в 2014 году благодаря пятилетнему опыту работы с Foundation, новой функции Objective-C или нескольким советам из комментариев.)


Это работает? Я не думаю, что NSMutableArray имеет setObject: atIndex: метод. Спасибо за предложенное исправление для цикла, и использование универсального идентификатора вместо NSNumber.
Химадри Чоудхури

Вы правы, я понял это, когда прочитал некоторые другие примеры. Исправлено сейчас.
Брент Роял-Гордон

2
[счетчик массивов] вызывается каждый раз, когда вы выполняете цикл. Это очень дорого. Есть даже функция, которая меняет положение двух объектов.
Георг Шолли

8

Изучив ответы других выше и найдя обсуждение Мэтта Галлахера здесь

Я предлагаю это:

NSMutableArray * reverseArray = [NSMutableArray arrayWithCapacity:[myArray count]]; 

for (id element in [myArray reverseObjectEnumerator]) {
    [reverseArray addObject:element];
}

Как заметил Мэтт:

В приведенном выше случае вы можете задаться вопросом, будет ли - [NSArray reverseObjectEnumerator] выполняться на каждой итерации цикла, что потенциально может замедлить код. <...>

Вскоре после этого он отвечает так:

<...> Выражение «collection» вычисляется только один раз, когда начинается цикл for. Это лучший случай, так как вы можете безопасно поместить дорогую функцию в выражение «collection», не влияя на производительность цикла при каждой итерации.


8

Категории Георга Шолли очень хорошие. Однако для NSMutableArray использование NSUIntegers для индексов приводит к падению, когда массив пуст. Правильный код:

@implementation NSMutableArray (Reverse)

- (void)reverse {
    NSInteger i = 0;
    NSInteger j = [self count] - 1;
    while (i < j) {
        [self exchangeObjectAtIndex:i
                  withObjectAtIndex:j];

        i++;
        j--;
    }
}

@end

8

Самый эффективный способ перечислить массив в обратном порядке:

Использование enumerateObjectsWithOptions:NSEnumerationReverse usingBlock. Используя приведенный выше бенчмарк @ JohannesFahrenkrug, это в 8 раз быстрее, чем [[array reverseObjectEnumerator] allObjects];:

NSDate *methodStart = [NSDate date];

[anArray enumerateObjectsWithOptions:NSEnumerationReverse usingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
    //
}];

NSDate *methodFinish = [NSDate date];
NSTimeInterval executionTime = [methodFinish timeIntervalSinceDate:methodStart];
NSLog(@"executionTime = %f", executionTime);

7
NSMutableArray *objMyObject = [NSMutableArray arrayWithArray:[self reverseArray:objArrayToBeReversed]];

// Function reverseArray 
-(NSArray *) reverseArray : (NSArray *) myArray {   
    return [[myArray reverseObjectEnumerator] allObjects];
}

3

Обратный массив и цикл по нему:

[[[startArray reverseObjectEnumerator] allObjects] enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
    ...
}];

2

Чтобы обновить это, в Swift это можно легко сделать с помощью:

array.reverse()

1

Что касается меня, вы рассматривали, как массив был заполнен в первую очередь? Я находился в процессе добавления МНОГИХ объектов в массив и решил вначале вставить каждый из них, увеличивая все существующие объекты на один. В этом случае требуется изменяемый массив.

NSMutableArray *myMutableArray = [[NSMutableArray alloc] initWithCapacity:1];
[myMutableArray insertObject:aNewObject atIndex:0];

1

Или Скала-путь:

-(NSArray *)reverse
{
    if ( self.count < 2 )
        return self;
    else
        return [[self.tail reverse] concat:[NSArray arrayWithObject:self.head]];
}

-(id)head
{
    return self.firstObject;
}

-(NSArray *)tail
{
    if ( self.count > 1 )
        return [self subarrayWithRange:NSMakeRange(1, self.count - 1)];
    else
        return @[];
}

2
Рекурсия - ужасная идея для больших структур данных в отношении памяти.
Эран Голдин

Если он компилируется с хвостовой рекурсией, это не должно быть проблемой
simple_code

1

Есть простой способ сделать это.

    NSArray *myArray = @[@"5",@"4",@"3",@"2",@"1"];
    NSMutableArray *myNewArray = [[NSMutableArray alloc] init]; //this object is going to be your new array with inverse order.
    for(int i=0; i<[myNewArray count]; i++){
        [myNewArray insertObject:[myNewArray objectAtIndex:i] atIndex:0];
    }
    //other way to do it
    for(NSString *eachValue in myArray){
        [myNewArray insertObject:eachValue atIndex:0];
    }

    //in both cases your new array will look like this
    NSLog(@"myNewArray: %@", myNewArray);
    //[@"1",@"2",@"3",@"4",@"5"]

Надеюсь, это поможет.


0

Я не знаю ни одного встроенного метода. Но ручное кодирование не так уж сложно. Предполагая, что элементы массива, с которым вы имеете дело, являются объектами NSNumber целочисленного типа, а 'arr' - это NSMutableArray, который вы хотите сторнировать.

int n = [arr count];
for (int i=0; i<n/2; ++i) {
  id c  = [[arr objectAtIndex:i] retain];
  [arr replaceObjectAtIndex:i withObject:[arr objectAtIndex:n-i-1]];
  [arr replaceObjectAtIndex:n-i-1 withObject:c];
}

Так как вы начинаете с NSArray, вам нужно сначала создать изменяемый массив с содержимым исходного NSArray ('origArray').

NSMutableArray * arr = [[NSMutableArray alloc] init];
[arr setArray:origArray];

Редактировать: Исправлено n -> n / 2 в счетчике циклов и изменено NSNumber на более общий идентификатор из-за предложений в ответе Брента.


1
Разве это не пропустить релиз на c?
Глиняные мосты

0

Если все, что вы хотите сделать, это повторить в обратном порядке, попробуйте это:

// iterate backwards
nextIndex = (currentIndex == 0) ? [myArray count] - 1 : (currentIndex - 1) % [myArray count];

Вы можете сделать [myArrayCount] один раз и сохранить его в локальной переменной (я думаю, это дорого), но я также предполагаю, что компилятор будет делать то же самое с кодом, как написано выше.



0

Попробуй это:

for (int i = 0; i < [arr count]; i++)
{
    NSString *str1 = [arr objectAtIndex:[arr count]-1];
    [arr insertObject:str1 atIndex:i];
    [arr removeObjectAtIndex:[arr count]-1];
}

0

Вот хороший макрос , который будет работать на любом NSMutableArray ИЛИ NSArray:

#define reverseArray(__theArray) {\
    if ([__theArray isKindOfClass:[NSMutableArray class]]) {\
        if ([(NSMutableArray *)__theArray count] > 1) {\
            NSUInteger i = 0;\
            NSUInteger j = [(NSMutableArray *)__theArray count]-1;\
            while (i < j) {\
                [(NSMutableArray *)__theArray exchangeObjectAtIndex:i\
                                                withObjectAtIndex:j];\
                i++;\
                j--;\
            }\
        }\
    } else if ([__theArray isKindOfClass:[NSArray class]]) {\
        __theArray = [[NSArray alloc] initWithArray:[[(NSArray *)__theArray reverseObjectEnumerator] allObjects]];\
    }\
}

Чтобы использовать просто позвоните: reverseArray(myArray);

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.