charAt() o subcadena? ¿Cual es mas rápido?

Question

Quiero ver cada carácter en una Cadena y pasar cada carácter de la Cadena como una Cadena a otra función.

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

o

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

El resultado final debe ser una cadena. Entonces, ¿alguna idea que sea más rápida o más eficiente?

Answer 1

Como de costumbre: no importa, pero si insiste en pasar tiempo en la micro-optimización o si realmente te gusta para optimizar su caso de uso muy especial, intente esto:

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 realmente necesita tomar un String? Sería mejor si usted podría hacer newFunction echar un char y lo llaman así:

newFunction(s.charAt(i)); 

De esa manera, se evita la creación de un objeto String temporal.

Para responder a su pregunta: es difícil decir cuál es más eficiente. En ambos ejemplos, se debe crear un objeto String que contenga solo un carácter. Lo que es más eficiente depende de cómo se implementan exactamente String.substring(...) y Character.toString(...) en su implementación de Java particular. La única forma de averiguarlo es ejecutar su programa a través de un generador de perfiles y ver qué versión usa más CPU y/o más memoria. Normalmente, no debe preocuparse por las micro optimizaciones como esta; solo dedique tiempo a esto cuando haya descubierto que esta es la causa de un problema de rendimiento y/o memoria.

Answer 3

La respuesta es: it doesn't matter.

Perfile su código. ¿Es este tu cuello de botella?

Answer 4

Primero obtendría el carácter subyacente [] de la cadena fuente usando String.toCharArray() y luego procedo a llamar a newFunction.

Pero estoy de acuerdo con Jesper que sería mejor si pudiera hacer frente a los personajes y evitar todas las funciones de cadena ...

Answer 5

De los dos fragmentos que has publicado, no me gustaría a decir. Estoy de acuerdo con Will en que es casi irrelevante en el rendimiento general de su código, y si no lo es, puede hacer el cambio y determinar por sí mismo cuál es el más rápido para sus datos con su JVM en su hardware.

Dicho esto, es probable que el segundo fragmento sea mejor si convierte primero la Cadena en una matriz de caracteres, y luego realiza sus iteraciones sobre la matriz. Si lo hiciera de esta manera, realizaría la tara de una sola vez (convirtiendo a la matriz) en lugar de cada llamada. Además, puede pasar la matriz directamente al constructor de cadenas con algunos índices, que es más eficiente que tomar un de una matriz para pasarlo individualmente (que luego se convierte en una matriz de un carácter):

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

Pero para reforzar mi primer punto, cuando miras lo que realmente estás evitando en cada llamada de String.charAt(), son dos controles de límites, un (booleano) booleano O, y una adición. Esto no hará ninguna diferencia notable. Tampoco es la diferencia en los constructores de cadenas.

Básicamente, ambos modismos están bien en términos de rendimiento (ninguno de los dos es inmediatamente ineficiente) por lo que no deberías perder más tiempo trabajando en ellos a menos que un generador de perfiles demuestre que esto consume una gran parte del tiempo de ejecución de la aplicación.Y aun así, es casi seguro que obtendrás más mejoras de rendimiento al reestructurar tu código de soporte en esta área (por ejemplo, tener newFunction tomar toda la cadena en sí); java.lang.String está bastante bien optimizado en este punto.