objective-c - 如何在 Objective-C 中反转 NSArray？

Question

我需要扭转我的NSArray.

举个例子：

[1,2,3,4,5]必须变成：[5,4,3,2,1]

实现这一目标的最佳方法是什么？

Answer 1

如果您利用 on 的内置reverseObjectEnumerator方法NSArray和 的allObjects方法，则有一个更简单的解决方案NSEnumerator：

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

allObjects被记录为返回一个数组，其中包含尚未遍历的对象nextObject，按顺序：

该数组按枚举顺序包含枚举器的所有剩余对象。

Answer 2

要获得数组的反向副本，请查看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

Answer 3

一些基准

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]在速度和易用性方面，明显的赢家也是如此。

Answer 4

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' 将变为 'self'。）如果需要，您还可以通过[array count]在循环之前分配给变量并使用该变量来优化它。

如果您只有一个常规的 NSArray，则无法将其反转，因为 NSArray 无法修改。但是您可以制作反向副本：

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/in循环[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 特性，以及来自评论的一些提示。）

Answer 5

在查看了上面其他人的答案并在此处找到 Matt Gallagher 的讨论之后

我提出这个：

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

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

正如马特所说：

在上述情况下，您可能想知道 -[NSArray reverseObjectEnumerator] 是否会在循环的每次迭代中运行 - 可能会减慢代码速度。<...>

不久之后，他这样回答：

<...> "collection" 表达式仅在 for 循环开始时计算一次。这是最好的情况，因为您可以安全地将昂贵的函数放在“集合”表达式中，而不会影响循环的每次迭代性能。

Answer 6

Georg Schölly 的分类非常好。但是，对于 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

Answer 7

反向枚举数组的最有效方法：

使用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);

Answer 8

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

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

Answer 9

反转数组并循环遍历它：

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

Answer 10

要更新这一点，在 Swift 中可以通过以下方式轻松完成：

array.reverse()

Answer 11

至于我，您是否首先考虑过数组是如何填充的？我正在将许多对象添加到数组中，并决定在开头插入每个对象，将任何现有对象向上推。在这种情况下，需要一个可变数组。

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

Answer 12

或 Scala 方式：

-(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 @[];
}

Answer 13

有一种简单的方法可以做到这一点。

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

我希望这有帮助。

Answer 14

我不知道任何内置方法。但是，手工编码并不太难。假设您正在处理的数组元素是整数类型的 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 更改为更通用的 id，这是由于 Brent 回答中的建议。

Answer 15

试试这个：

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

Answer 16

如果您只想反向迭代，请尝试以下操作：

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

您可以执行一次 [myArrayCount] 并将其保存到局部变量中（我认为它很昂贵），但我也猜测编译器几乎会使用上面编写的代码做同样的事情。

Answer 17

斯威夫特 3 语法：

let reversedArray = array.reversed()

Answer 18

这是一个很好的宏，适用于 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);