如何在Objective-C中反转NSArray？

18 回答

• 7

  NSMutableArray *objMyObject = [NSMutableArray arrayWithArray:[self reverseArray:objArrayToBeReversed]];
  
  // Function reverseArray 
  -(NSArray *) reverseArray : (NSArray *) myArray {   
      return [[myArray reverseObjectEnumerator] allObjects];
  }
  

  回复于 2024-05-05T21:25:10+08:00
• 1

  要获得数组的反转副本，请使用 reverseObjectEnumerator 查看danielpunkass' solution .

  要反转可变数组，可以在代码中添加以下类别：

  @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
  

  回复于 2024-05-05T21:25:10+08:00
• 7

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

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

  allObjects is documented返回一个数组，其中包含尚未使用 nextObject 遍历的对象，按顺序：

  此数组以枚举顺序包含枚举数的所有剩余对象 .

  回复于 2024-05-05T21:25:10+08:00
• 1248

  Some benchmarks

  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. Iterating over an reverseObjectEnumerator

  这速度在1.5x到2.5x之间：

  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

  速度在30x到40x之间（这里没有惊喜）：

  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] 在速度和轻松方面是明显的赢家 .

  回复于 2024-05-05T21:25:10+08:00
• 0

  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，就无法在适当的位置反转它，因为无法修改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 / 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.)
  }];
  

  （ Note ：2014年进行了大幅更新，基础知识经历了五年，一个或两个新的Objective-C功能，以及评论中的一些提示 . ）

  回复于 2024-05-05T21:25:10+08:00
• 2

  在查看了上面的其他答案并找到了Matt Gallagher's discussion here

  我建议这个：

  NSMutableArray * reverseArray = [NSMutableArray arrayWithCapacity:[myArray count]]; 
  
  for (id element in [myArray reverseObjectEnumerator]) {
      [reverseArray addObject:element];
  }
  

  正如马特所说：

  在上面的例子中，您可能想知道 - [NSArray reverseObjectEnumerator]是否会在循环的每次迭代中运行 - 可能会降低代码速度 . <...>

  此后不久，他回答如下：

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

  回复于 2024-05-05T21:25:10+08:00
• 48

  GeorgSchö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
  

  回复于 2024-05-05T21:25:10+08:00
• 0

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

  使用 enumerateObjectsWithOptions:NSEnumerationReverse usingBlock . 使用@ JohannesFahrenkrug上面的基准测试，这比 [[array reverseObjectEnumerator] allObjects]; 快了8倍：

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

  回复于 2024-05-05T21:25:10+08:00
• 3

  反向数组并循环遍历它：

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

  回复于 2024-05-05T21:25:10+08:00
• 0

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

  array.reverse()
  

  回复于 2024-05-05T21:25:10+08:00
• 302

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

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

  回复于 2024-05-05T21:25:10+08:00
• 0

  或Scala-way：

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

  回复于 2024-05-05T21:25:10+08:00
• 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更改为更通用的ID .

  回复于 2024-05-05T21:25:10+08:00
• 0

  如果你想做的只是反向迭代，试试这个：

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

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

  回复于 2024-05-05T21:25:10+08:00
• 19

  Swift 3语法：

  let reversedArray = array.reversed()
  

  回复于 2024-05-05T21:25:10+08:00
• 8

  试试这个：

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

  回复于 2024-05-05T21:25:10+08:00
• 8

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

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

  一世希望这可以帮助 .

  回复于 2024-05-05T21:25:10+08:00
• 1

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

  回复于 2024-05-05T21:25:10+08:00