Różnice między [NSArray arrayWithArray:] i [NSArray copy]

Question

ostatnio pracuję dużo z tablicami i jestem ciekawa ... jakie są różnice między tymi dwoma liniami.

NSArray *array = [NSArray arrayWithArray:someArray]; 

i

NSArray *array = [someArray copy]; 

Który jest szybszy? Co w takim razie mamy NSMutableArray i mutableCopy?

Answer 1

Który z nich jest szybszy?

Nie martw się o to. Przedwczesna optymalizacja.

Główna różnica: pierwsze podejście skutkuje autoreleased "copy", którego nie posiadasz i nie musisz zwolnić, podczas gdy jesteś właścicielem obiektu utworzonego w drugim wierszu. Obie tablice będą niezmienne, przy okazji.

Answer 2

Jedna z nich jest prawdopodobnie szybsza. Uruchom je milion razy i zobacz, czy ktoś wygrywa.

W przypadku NSArray kontra NSMutableArray, kopiowana niezmienna tablica nie musi zwracać kopii, ponieważ nie może się zmienić. Jeśli jednak macie tablicę, którą można zmienić, trzeba ją skopiować, ponieważ można zmienić oryginał. I oczywiście robienie kopii zawsze musi zwrócić nowy obiekt.

W całej aplikacji różnica prędkości i pamięci prawdopodobnie nie będzie miała większego znaczenia niż wszystko inne, co się dzieje.

Answer 3

Różnica między tymi dwoma polega na tym, że ta ostatnia zostanie zachowana. Ta pierwsza zostanie autoreleased.

Obie wersje tworzą płytką kopię tablicy.

NSMutableArray *notMutableReally = [NSArray arrayWithArray:aMutableArray]; 

powinno dać ostrzeżenie kompilatora jak będzie próbował przypisać NSArray do NSMutableArray.

Użyj.

NSMutableArray *mutableArrayCopy = [NSMutableArray arrayWithArray:aMutableArray]; 

Który jest szybszy? Nie martw się, wszystkie są o wiele szybsze niż reszta rzeczy, które będziesz robić. Sprawdź z Instruments, czy naprawdę Ci zależy.

Answer 4

Główną różnicą jest to, że -copy wie lepiej jak kopiuje się (można to zrobić bardziej efektywnie, a może użyć bardziej dostosowaną podklasę NSArray) podczas +arrayWithArray: stworzy nową instancję NSArray (dobrze, w rzeczywistości używany beton klasy przez Foundation for arrays) i karmić go tą samą listą obiektów z początkowego obiektu. Dodaje także dodatkową autorelease.

Tak więc -copy jest (bardzo bardzo) prawdopodobnie bardziej wydajne.

W rzeczywistości za niezmienny NSArrays, -copy po prostu robi -retain, więc nawet nie przeszkadza tworzenie nowej instancji.

Answer 5

W uzupełnieniu do innych odpowiedzi, również pamiętać, że gdy someArray jest zerowa, pierwsza linia pozwoli array wskaż pustą tablicę, a drugi zrobi skierować go do zera. Może to być ważna różnica, szczególnie w tablicach zmiennych.

Answer 6

NSMutableArray *arr = [NSMutableArray array]; 
for (int i = 0; i < 10000; i ++) 
{ 
    [arr addObject:@(i*1000000ULL)]; 
} 
// MARK 
// arr = (id)[NSArray arrayWithArray:arr]; 

NSTimeInterval t = [NSDate timeIntervalSinceReferenceDate]; 
NSArray *res = nil; 
for (int i = 0; i < 10000; i ++) 
{ 
    res = [arr copy]; 
} 
NSLog(@"time A: %f", [NSDate timeIntervalSinceReferenceDate] - t); 
t = [NSDate timeIntervalSinceReferenceDate]; 
for (int i = 0; i < 10000; i ++) 
{ 
    res = [NSArray arrayWithArray:arr]; 
} 
NSLog(@"time B: %f", [NSDate timeIntervalSinceReferenceDate] - t); 

czas A: 1,572795 czas B: 1,539150 B [NSArray arrayWithArray:] zawsze szybciej, ale różnica w czasie bardzo małe. Ale jeśli odkomentowaniu „Mark” i się skopiować z NSArray zamiast NSMutableArray będziemy mieć inne wykonania A: 0,000473 B Czas: 1.548400 wynik: ~ 3200x razy szybciej

Answer 7

W Swifta, to jest zupełnie inna. Dzięki nowej Open Source Foundation dla Swift wiemy, że podczas gdy init(array:) tworzy nową tablicę z podanymi przedmiotami (jeśli są), po prostu zwraca self.

public override func copy() -> AnyObject { 
     return copyWithZone(nil) 
    } 

    public func copyWithZone(zone: NSZone) -> AnyObject { 
     return self 
    } 

^{https://github.com/apple/swift-corelibs-foundation/blob/master/Foundation/NSArray.swift#L82}

public convenience init(array: [AnyObject]) { 
     self.init(array: array, copyItems: false) 
    } 

    public convenience init(array: [AnyObject], copyItems: Bool) { 
     let optionalArray : [AnyObject?] = 
      copyItems ? 
       array.map { return Optional<AnyObject>(($0 as! NSObject).copy()) } : 
       array.map { return Optional<AnyObject>($0) } 

     // This would have been nice, but "initializer delegation cannot be nested in another expression" 
//  optionalArray.withUnsafeBufferPointer { ptr in 
//   self.init(objects: ptr.baseAddress, count: array.count) 
//  } 
     let cnt = array.count 
     let buffer = UnsafeMutablePointer<AnyObject?>.alloc(cnt) 
     buffer.initializeFrom(optionalArray) 
     self.init(objects: buffer, count: cnt) 
     buffer.destroy(cnt) 
     buffer.dealloc(cnt) 
    } 

^{https://github.com/apple/swift-corelibs-foundation/blob/master/Foundation/NSArray.swift#L116}

Tak, oczywiście, copy() jest szybsza, a teraz wiesz, jak oboje pracy! _{(Tylko w Swift)}