charAt（）或子字符串？哪個更快？

Question

我想遍歷字符串中的每個字符，並將字符串的每個字符作爲字符串傳遞給另一個函數。

String s = "abcdefg"; 
for(int i = 0; i < s.length(); i++){ 
    newFunction(s.substring(i, i+1));} 

或

String s = "abcdefg"; 
for(int i = 0; i < s.length(); i++){ 
    newFunction(Character.toString(s.charAt(i)));} 

最終結果必須是一個字符串。那麼任何想法會更快或更高效？

Answer 1

像往常一樣：它並不重要，但如果你堅持花時間在微優化或者如果你真的想優化的非常特殊的使用情況，試試這個：

import org.junit.Assert; 
import org.junit.Test; 

public class StringCharTest { 

    // Times: 
    // 1. Initialization of "s" outside the loop 
    // 2. Init of "s" inside the loop 
    // 3. newFunction() actually checks the string length, 
    // so the function will not be optimized away by the hotstop compiler 

    @Test 
    // Fastest: 237ms/562ms/2434ms 
    public void testCacheStrings() throws Exception { 
     // Cache all possible Char strings 
     String[] char2string = new String[Character.MAX_VALUE]; 
     for (char i = Character.MIN_VALUE; i < Character.MAX_VALUE; i++) { 
      char2string[i] = Character.toString(i); 
     } 

     for (int x = 0; x < 10000000; x++) { 
      char[] s = "abcdefg".toCharArray(); 
      for (int i = 0; i < s.length; i++) { 
       newFunction(char2string[s[i]]); 
      } 
     } 
    } 

    @Test 
    // Fast: 1687ms/1725ms/3382ms 
    public void testCharToString() throws Exception { 
     for (int x = 0; x < 10000000; x++) { 
      String s = "abcdefg"; 
      for (int i = 0; i < s.length(); i++) { 
       // Fast: Creates new String objects, but does not copy an array 
       newFunction(Character.toString(s.charAt(i))); 
      } 
     } 
    } 

    @Test 
    // Very fast: 1331 ms/ 1414ms/3190ms 
    public void testSubstring() throws Exception { 
     for (int x = 0; x < 10000000; x++) { 
      String s = "abcdefg"; 
      for (int i = 0; i < s.length(); i++) { 
       // The fastest! Reuses the internal char array 
       newFunction(s.substring(i, i + 1)); 
      } 
     } 
    } 

    @Test 
    // Slowest: 2525ms/2961ms/4703ms 
    public void testNewString() throws Exception { 
     char[] value = new char[1]; 
     for (int x = 0; x < 10000000; x++) { 
      char[] s = "abcdefg".toCharArray(); 
      for (int i = 0; i < s.length; i++) { 
       value[0] = s[i]; 
       // Slow! Copies the array 
       newFunction(new String(value)); 
      } 
     } 
    } 

    private void newFunction(String string) { 
     // Do something with the one-character string 
     Assert.assertEquals(1, string.length()); 
    } 

} 

Answer 2

請問newFunction真的需要一個String？它會更好，如果你可以讓newFunction採取char並調用它像這樣：

newFunction(s.charAt(i)); 

這樣一來，就避免了創建一個臨時String對象。

回答你的問題：很難說哪一個更有效。在這兩個示例中，必須創建一個僅包含一個字符的String對象。哪一個更有效率取決於在您的特定Java實現中如何實現String.substring(...)和Character.toString(...)。找到它的唯一方法是通過分析器運行你的程序，並查看哪個版本使用更多的CPU和/或更多的內存。通常情況下，你不應該擔心這樣的微觀優化 - 只有當你發現這是造成性能和/或內存問題的原因時，纔會在這方面花費時間。

Answer 3

答案是：it doesn't matter。

配置您的代碼。這是你的瓶頸嗎？

Answer 4

我首先使用String.toCharArray（）從源字符串中獲取底層字符[]，然後繼續調用newFunction。

但我與加斯帕認爲，這將是最好的，如果你可以只處理字符，避免所有的字符串函數...

Answer 5

您已經發布兩個片斷，我不想說。我同意Will的觀點，認爲它幾乎可以肯定與代碼的整體性能無關 - 如果不是這樣，那麼您可以直接進行更改，並確定硬件上的JVM數據對於您的數據最快。

也就是說，如果首先將字符串轉換爲char數組，然後在數組上執行迭代，則第二個代碼段可能會更好。這樣做會執行一次字符串開銷（轉換爲數組）而不是每次調用。此外，您可以將數組直接傳遞給帶有一些索引的String構造函數，這比使用數組的char out單獨傳遞它（然後變成單字符數組）更有效：

String s = "abcdefg"; 
char[] chars = s.toCharArray(); 
for(int i = 0; i < chars.length; i++) { 
    newFunction(String.valueOf(chars, i, 1)); 
} 

但是爲了強化我的第一點，當你在String.charAt()的每個調用中查看實際避免的內容時 - 它是兩個邊界檢查，一個（懶惰）布爾OR或一個加法。這不會有什麼明顯的差異。在String構造函數中也沒有區別。基本上，這兩個成語在性能方面都很好（既不立即明顯效率低下），所以除非分析器顯示這佔用了大量應用程序的運行時間，否則不應該花更多時間在它們上面工作。即使這樣，您幾乎可以肯定會通過重組您的支持代碼來獲得更多的性能提升（例如，newFunction佔用了整個字符串本身）。 java.lang.String在這一點上已經很好的優化了。