性能有很多的字符串操作比較客觀C和迅速

Question

我有很多像拼接，更換，發現大量文本（10000個字）的索引的字符串操作...

的操作是太慢了。在Java/Android中完全相同的處理速度更快。

我在問目標C中的相同是否更快。

我是一個IOS新手，只知道swift到目前爲止（所以我不能嘗試簡單），這就是爲什麼我問如果客觀C與迅速橋接可以更快？

更新 我有很多在一個循環中的子串操作（也取代），它連接了一個新的字符串。 NewText & STEXT都是字符串類型的，STEXT擁有約10000字，循環將有大約100次迭代：

NewText=NewText + sText.substring(istart,endIndex: iend); 


func substring(startIndex: Int, endIndex: Int) -> String 
{ 
    //println("substring" + self); 
    var start = advance(self.startIndex, startIndex) 
    var end = advance(self.startIndex, endIndex) 
    return self.substringWithRange(Range<String.Index>(start: start, end: end)) 
} 

更新2性能測試（替換字符串）與字符串，的NSString，CFString字符串

從所有提供的信息（非常感謝），它似乎不是Objective-C和Swift之間的區別。這是更多的Stringtype使用。 我做的同類型性能測試：字符串，的NSString和CFString字符串

func performance_test_with_strings(){ 


     var sTextNSString:NSString="<1000 character> searchstring end"; 

     var sTextString=String(sTextNSString); 
     //var sTextCFString:CFMuString=sTextNSString as CFString; 
     var stoReplace="searchstring"; 


     var sTextCFString:CFMutableStringRef=CFStringCreateMutable(nil, 0); 
     CFStringAppend(sTextCFString, sTextString as! CFMutableStringRef); 
     var stoReplaceCFString="searchstring" as CFString; 
     var stoReplaceCFString2="mynewstring" as CFString; 
     var chrono1:Chronometer=Chronometer(); 
     chrono1.start(); 



     for var i=0;i<10000;i++ { 
      var newText=sTextNSString.stringByReplacingOccurrencesOfString(stoReplace, withString: "mynewstring"); 
     } 
     chrono1.zwischenstand("after replacing with a NSString"); 

     for var i=0;i<10000;i++ { 
      var newText=sTextString.stringByReplacingOccurrencesOfString(stoReplace, withString: "mynewstring"); 
     } 
     chrono1.zwischenstand("after replacing with a String"); 
     //CFShow(cfmutablestring); 


     for var i=0;i<5000;i++ { 
      // To compare this correct I'll have to do 2 replacments in a loop of only 5000 iterations 


      specialreplace(&sTextCFString,sWhat: "searchstring",sTo: "mynewstring"); 
      specialreplace(&sTextCFString,sWhat: "mynewstring",sTo: "searchstring"); 

     } 
     chrono1.zwischenstand("after replacing with a CFString"); 
     chrono1.showMeasures(); 
     exit(0); 
    } 

    func specialreplace(inout sText:CFMutableStringRef,sWhat:String, sTo:String){ 

     var cfRange = CFStringFind(sText, sWhat as CFString, nil); 
     CFStringReplace(sText, cfRange, sTo as CFString); 

    } 



    class Chronometer: NSObject { 


    var mearures:[(String,Double)]=[(String,Double)](); 

    var starttime = NSDate(); // <<<<<<<<<< end time 
    var lasttime:Double=0; 

    func start(){ 
     starttime = NSDate(); // <<<<<<<<<< end time 

    } 
    func zwischenstand(mytext:String){ 
     var zwischenzeit = NSDate(); 
     let timeInterval: Double = zwischenzeit.timeIntervalSinceDate(starttime); 
     let actualtimeconsumed=timeInterval-lasttime; 
     mearures.append((mytext,actualtimeconsumed)); 
     var textshow=mytext + " actual : " + String(stringInterpolationSegment: actualtimeconsumed); 
     textshow=textshow + " total :" + String(stringInterpolationSegment: timeInterval); 
     println(textshow); 
     lasttime=timeInterval; 
    } 

    func showMeasures(){ 
     var total:Double=0; 
     for var i=0 ; i < mearures.count ; i++ { 
      let text=mearures[i].0; 
      let measure=mearures[i].1; 
      println(text + " : " + String(stringInterpolationSegment: measure)); 
      total = total + measure; 
     } 
     println("total : " + String(stringInterpolationSegment: total)); 
    } 

} 

用NSString的實際更換後：1.15460801124573總：1.15460801124573

與實際的字符串替換後：1.15148597955704總：2.30609399080276

與實際一CFString字符串替換後：0.323610007762909總：2.62970399856567

用的NSString替換後：1.15460801124573

用字符串替換後：1.15148597955704

與CFString字符串替換後：0.323610007762909

總：2.62970399856567

所以我對我的情況下，其最好的結論，用CFString字符串。

該測試是否正確？

Answer 1

我會用Core Foundation's CFMutableString操作。我一般傾向於發現它們比Cocoa變種快得多。

Answer 2

有一點需要注意的是，它試圖正確地處理Unicode處理。 Java和Cocoa的NSString不這樣做。他們都假定字符串是用UTF-16編碼的，每個字符只需要一個16位整數。因此字符串處理的唯一工作正常進行所謂的Basic Multilingual Plane

隨着NSString和在Java中，找到的第n個「字」很簡單，你只需索引到數組中的第n項，但很容易被第二部分的代理對。除了掃描所有以前的字符以確保它們都不是兩個單詞字符之外，您也無法分辨這是否爲第n個字符。

Swift會正確執行此操作，但會犧牲大量線性掃描（又稱慢速掃描）。