Performance WHILE X FOR - Qual o mais rápido?

Programação Java
#1

Fiz uma pesquisa para tentar descobrir quais das duas estruturas de repetição é a mais rápida e quando é melhor usar o while e quando é melhor usar o for.
O while é melhor utilizado quando você não sabe quantas vezes ele vai ser executado (dá para fazer com o for também), e o for é ideial quando se precisa de um contador (também é possível usando o while).
Resolvi então fazer um comparativo entre o while e o for em termos de performance e cheguei ao seguinte resultado:
o for é sempre mais rápido quando concatena String.

[code]public class TesteString {

static int fim = 12000;

public static void main(String[] args) {
    System.out.println("-------String---------");
    long time = -System.currentTimeMillis();
    stringFor();
    time += System.currentTimeMillis();
    System.out.println("For: " + ((double) time / 600));
    time = -System.currentTimeMillis();
    stringWhile();
    time += System.currentTimeMillis();
    System.out.println("While: " + ((double) time / 600));
}

public static void stringFor() {
    String texto = "";
    for (int i = 0; i < fim; i++) {
        texto += "Java";
    }
}

public static void stringWhile() {
    String texto = "";
    int i = 0;
    while (i < fim) {
        texto += "Java";
        i++;
    }
}

}
[/code]

e o while é sempre mais rápido quando se concatena StringBuffer.

public class TesteStringBuffer {
    static int fim = 4000000;

    public static void main(String[] args) {
     stringBuffer();
    }
    public static void stringBuffer() {
        System.out.println("-------StringBuffer---------");
        long time = -System.currentTimeMillis();
        stringBufferFor();
        time += System.currentTimeMillis();
        System.out.println("For: " + time);
        time = -System.currentTimeMillis();
        stringBufferWhile();
        time += System.currentTimeMillis();
        System.out.println("While: " + time);
    }

    public static void stringBufferFor() {
        StringBuffer texto = new StringBuffer("");
        for (int i = 0; i < fim; i++) {
            texto.append("Java");
        }
    }

    public static void stringBufferWhile() {
        StringBuffer texto = new StringBuffer("");
        int i = 0;
        while (i < fim) {
            texto.append("Java");
            i++;
        }
    }

}

Por que isso acontece? alguém pode me dizer?
Obrigado.

#2

http://www.guj.com.br/posts/list/204485.java

Note: não é o uso do for que deixa mais lento. É o uso da concatenação de strings com “+=”, que é super-lenta.

#3

Na minha máquina…

No primeiro teste, o [color=darkblue]for [/color]foi mais lento… por uma diferença muito pequena (e as vezes o [color=darkblue]while [/color]foi mais lento)
Troquei a ordem do teste, passando a testar o [color=darkblue]while[/color] primeiro, as vezes o [color=darkblue]for [/color]era mais lento, as vezes o [color=darkblue]while[/color]…

E é provavel que a diferença se deu pior para o primeiro loop testado, pela realocaçao de memória necessária para satisfazer tantas concatenações…

O segundo teste deu empate…

Conclusao … é tudo a mesma coisa…

A máquina virtual poderá otimizar alguns códigos, então… faça o código mais elegante e legível…

#4

Como disse o entagl., é a concatenação de objetos String. É lento, serio… tente concatenar alguns milhões de cadeias que você vai ver a diferença entre String e StringBuilder (ou Buffer).
Já ouvi até relatos de gente dizendo que resolveu problemas em empresas trocando Strings por StringBuilders e / ou byte (quando, no caso, ocorrem comparações usando números dentro das strings).

#5

A intenção é ver qual tem o melhor desempenho (While X For).
A concatenação de String eu já sabia que era mais lenta, coloquei para dar para ver o tempo de execução.
Pelo que eu vi não existe muita diferença entre usar o while e o for, mas quando usar o while? e o for?

#6

Use o que proporcionar o código mais legível…

#7

Nunca se preocupe com desempenho quando for codificar; a maioria das máquinas hoje conseguem resolver uma infinidade de problemas num tempo suficientemente bom.

E quando, num raro dia, houver REALMENTE um problema de desempenho, pode ter certeza que não vai ser a troca de for pra while que vai resolver. Aliás, qualquer alteração “brainless” que você possa imaginar, que poderia resultar em execução mais rápida, já é feito pelo compilador e pelo JIT.

Com relação à utilização, vejo o pessoal usando muito mais for do que while. Acho que a razão é que a estrutura do for não te deixa esquecer de colocar incremento e condições de parada.

#8