Discussoes de Programacao e Tecnologia

Duvida sobre String

14 respostas
D
dark_creator

Bom, estou lendo o Livro da Kathy e acabei com uma duvida sobre string.

String palavra = "nome"; //Cria um objeto string que é colocado no constant pool string (se não me engano é esse o nome)

   String palavraB = new String("sobrenome"); //Cria dois objetos Strings, um no pool e um no heap

no livro no exemplo so muda o nome das variaveis e strings.

é isso mesmo?

e outra duvida

String nome = "Silvio"; //Criei um string no pool
 String sobrenome = nome.concat(" Lucena"); //Criei um objeto string no pool " Lucena" e o objeto string no pool 
                                                                   //"Silvio Lucena"
 String nomeCompleto = sobrenome + " Junior" //Criei mais dois objetos strings no pool (Junior e Silvio Lucena Junior)

total: 5 objetos string no pool e 2 deles referenciados
é isso mesmo? estou certo?

existe diferença entre o

String sobrenome = nome.concat(" Lucena");

e o

String sobrenome = nome.+ " Lucena";

???

Alura Desenvolvimento Back-End Java Sua Carreira em desenvolvimento back-end Java: dos fundamentos à arquitetura de sistemas...

14 Respostas

blackfalcon
blackfalcon

Cara, sobre a pergunta nem consigo te responder… mas ja li a respeito que nem se usa o tipo String ( so para programinhas que nem a gente faz… ) , usa-se outras duas classes, se alguem tiver mais informação pro cara… :slight_smile:

Abraços

eduveks
eduveks

Fiz aqui um tester para poder ver melhor como a coisa funciona:

public class StringTester {
    public static void main(String[] args) {
        int iterations = 10000000;
        long time = 0;
        System.out.println();
        System.out.println("String Tester");
        System.out.println();
        System.out.println("Test 1");
        System.out.println("----------------------------------------");
        time = System.currentTimeMillis();
        for (int x = 0; x < iterations; x++) {
            String s = "test" + " 123" + "!!!";
        }
        System.out.println("Plus = " + (System.currentTimeMillis() - time) + "ms");
        time = System.currentTimeMillis();
        for (int x = 0; x < iterations; x++) {
            String s = "test".concat(" 123").concat("!!!");
        }
        System.out.println("Concat = " + (System.currentTimeMillis() - time) + "ms");
        time = System.currentTimeMillis();
        for (int x = 0; x < iterations; x++) {
            String s = new StringBuffer("test").append(" 123").append("!!!").toString();
        }
        System.out.println("StringBuffer = " + (System.currentTimeMillis() - time) + "ms");
        time = System.currentTimeMillis();
        for (int x = 0; x < iterations; x++) {
            String s = new StringBuilder("test").append(" 123").append("!!!").toString();
        }
        System.out.println("StringBuilder = " + (System.currentTimeMillis() - time) + "ms");
        System.out.println("----------------------------------------");
        System.out.println();
        System.out.println("Test 2");
        System.out.println("----------------------------------------");
        time = System.currentTimeMillis();
        String sp = "test";
        for (int x = 0; x < iterations; x++) {
            String s = sp + " 123" + "!!!";
        }
        System.out.println("Plus = " + (System.currentTimeMillis() - time) + "ms");
        time = System.currentTimeMillis();
        String sc = "test";
        for (int x = 0; x < iterations; x++) {
            String s = sc.concat(" 123").concat("!!!");
        }
        System.out.println("Concat = " + (System.currentTimeMillis() - time) + "ms");
        time = System.currentTimeMillis();
        StringBuffer sbf = new StringBuffer("test");
        for (int x = 0; x < iterations; x++) {
            String s = sbf.append(" 123").append("!!!").toString();
            sbf.setLength(0);
        }
        System.out.println("StringBuffer = " + (System.currentTimeMillis() - time) + "ms");
        time = System.currentTimeMillis();
        StringBuilder sbl = new StringBuilder("test");
        for (int x = 0; x < iterations; x++) {
            String s = sbl.append(" 123").append("!!!").toString();
            sbl.setLength(0);
        }
        System.out.println("StringBuilder = " + (System.currentTimeMillis() - time) + "ms");
        System.out.println("----------------------------------------");
        System.out.println();
    }
}

Resultado:

String Tester

Test 1
----------------------------------------
Plus = 31ms
Concat = 2579ms
StringBuffer = 6064ms
StringBuilder = 5063ms
----------------------------------------

Test 2
----------------------------------------
Plus = 5064ms
Concat = 2594ms
StringBuffer = 2735ms
StringBuilder = 2532ms
----------------------------------------

Moral da história… o Concat é mais fácil e mais rápido…

ViniGodoy
ViniGodoy

Por que você está chamando delete usando o StringBuilder e o StringBuffer?
Com uma operação a mais a cada loop, vai dar mais lento mesmo!

eduveks
eduveks

ViniGodoy:
Por que você está chamando delete usando o StringBuilder e o StringBuffer?
Com uma operação a mais a cada loop, vai dar mais lento mesmo!

Mudei o delete para setLength e da no mesmo… entao como resetar para usar o mesmo objeto???

E se o StringBuilder/StringBuffer estivesse dentro de um método chamado apartir do loop, seria criado N objetos a mais como demonstrado no primeiro exemplo, uma grande perda de performance, então o concat passa a ser o ideal a ser usado, ou não?

Creio q o concat em todos os casos vai se sair bem… sendo assim devemos usar o concat em vez do StringBuffer/StringBuilder? Sempre?

ViniGodoy
ViniGodoy

No caso do String Builder / Buffer você está medindo não só o tempo da concatenação, mas também o tempo que ele leva para instanciar um objeto String no final. E é justamente esse tempo que se ganha ao utiliza-lo.

Teste outro benchmark concatenando 123 !!! várias vezes numa mesma string e só ao final gerando o resultado com toString() (que é como se normalmente se trabalha com o StringBuilder e StringBuffer). Talvez você obtenha resultados diferentes.

Não seja tão apressado ao concluir coisas baseado em resultados de microbenchmarks já que, assim como o seu, muitos expressam só parcialmente o que ocorre na realidade (ou não expressam nada). Benchmarks como esse também levam em pouca consideração caches e compilações hotspot feitas pela VM.

O que o seu benchmark nos leva a concluir é que, para pequenas concatenações, o sinal de + é o mais rápido, seguido pelo concat. Mas será que isso seria válido para as grandes concatenações?

ViniGodoy
ViniGodoy

Veja só um exemplo.
Passei o StringBuilder para primeiro na ordem de execução e obtive os seguintes resultados:

Test 1

StringBuilder = 2594ms
Plus = 15ms
Concat = 1922ms
StringBuffer = 4719ms

Test 2

StringBuilder = 1781ms
Plus = 2610ms
Concat = 1890ms
StringBuffer = 2078ms

Test 1

StringBuilder = 2593ms
Plus = 0ms
Concat = 1922ms
StringBuffer = 4766ms

Test 2

StringBuilder = 1812ms
Plus = 2610ms
Concat = 1875ms
StringBuffer = 2234ms

Que tipo de maluquice será que a VM faz por trás de tudo?!? O seu resultado também mostra uma discrepancia. Como você pode concluir a respeito do concat com a aquela variação enorme no tempo do plus? Essa variação pode ter ocorrido em todos os seus resultados, afetando todo o tempo do teste.

Isso provavelmente é o garbage collector e outros mecanismos da VM rodando.

eduveks
eduveks

Mas não superou o concat…

Eu estou fazendo um novo benchmark com uma concatenação maior, e no primeiro teste mesmo o StringBuilder e o StringBuffer sendo criados varias vezes ja foram muito mais rapido…

Quando acabar o teste posto aqui o codigo e o resultado… é q esta demorando o segundo teste :stuck_out_tongue:

eduveks
eduveks

Pronto… agora sim… tive q baixar os valores por q estava demorando muitooo:

public class StringTester {
    public static void main(String[] args) {
        int iterations = 100;
        int subiterations = 100;
        long time = 0;
        System.out.println();
        System.out.println("String Tester");
        System.out.println();
        System.out.println("Test 1");
        System.out.println("----------------------------------------");
        time = System.currentTimeMillis();
        for (int x = 0; x < iterations; x++) {
            String s = "";
            for (int y = 0; y < subiterations; y++) {
                s += "test" + " 123" + "!!!";
            }
        }
        System.out.println("Plus = " + (System.currentTimeMillis() - time) + "ms");
        time = System.currentTimeMillis();
        for (int x = 0; x < iterations; x++) {
            String s = "";
            for (int y = 0; y < subiterations; y++) {
                s = s.concat("test").concat(" 123").concat("!!!");
            }
        }
        System.out.println("Concat = " + (System.currentTimeMillis() - time) + "ms");
        time = System.currentTimeMillis();
        for (int x = 0; x < iterations; x++) {
            StringBuffer s = new StringBuffer();
            for (int y = 0; y < subiterations; y++) {
                s.append("test").append(" 123").append("!!!");
            }
        }
        System.out.println("StringBuffer = " + (System.currentTimeMillis() - time) + "ms");
        time = System.currentTimeMillis();
        for (int x = 0; x < iterations; x++) {
            StringBuilder s = new StringBuilder();
            for (int y = 0; y < subiterations; y++) {
                s.append("test").append(" 123").append("!!!");
            }
        }
        System.out.println("StringBuilder = " + (System.currentTimeMillis() - time) + "ms");
        System.out.println("----------------------------------------");
        System.out.println();
        System.out.println("Test 2");
        System.out.println("----------------------------------------");
        time = System.currentTimeMillis();
        String sp = "";
        for (int x = 0; x < iterations; x++) {
            for (int y = 0; y < subiterations; y++) {
                sp += "test" + " 123" + "!!!";
            }
        }
        System.out.println("Plus = " + (System.currentTimeMillis() - time) + "ms");
        time = System.currentTimeMillis();
        String sc = "";
        for (int x = 0; x < iterations; x++) {
            for (int y = 0; y < subiterations; y++) {
                sc = sc.concat("test").concat(" 123").concat("!!!");
            }
        }
        System.out.println("Concat = " + (System.currentTimeMillis() - time) + "ms");
        time = System.currentTimeMillis();
        StringBuffer sbf = new StringBuffer();
        for (int x = 0; x < iterations; x++) {
            for (int y = 0; y < subiterations; y++) {
                sbf.append("test").append(" 123").append("!!!");
            }
        }
        System.out.println("StringBuffer = " + (System.currentTimeMillis() - time) + "ms");
        time = System.currentTimeMillis();
        StringBuilder sbl = new StringBuilder("test");
        for (int x = 0; x < iterations; x++) {
            for (int y = 0; y < subiterations; y++) {
                sbl.append("test").append(" 123").append("!!!");
            }
        }
        System.out.println("StringBuilder = " + (System.currentTimeMillis() - time) + "ms");
        System.out.println("----------------------------------------");
        System.out.println();
    }
}

Resultado:

String Tester

Test 1
----------------------------------------
Plus = 63ms
Concat = 31ms
StringBuffer = 16ms
StringBuilder = 0ms
----------------------------------------

Test 2
----------------------------------------
Plus = 10374ms
Concat = 6734ms
StringBuffer = 16ms
StringBuilder = 31ms
----------------------------------------

Agora é estudar quando usar cada um em cada caso explorando o ponto forte…

O q me espanta é o StringBuilder ter sido mais rápido no primeiro caso…?!

eduveks
eduveks

ok… fiz outros testes… e o:

StringBuffer = 16ms  
StringBuilder = 31ms

Não podem ser levados em consideração… é o mesmo q Zero claro :stuck_out_tongue:

ViniGodoy
ViniGodoy
Mudei um pouco o programa: 
public class StringTester {
    public static void main(String[] args) {
        int iterations = 20000;        
        long time = 0;
        System.out.println();
        System.out.println("String Tester");
        String s = "";
        for (int i = 0; i < 2; i++)
        {
            System.out.println();
            System.out.println("Test " + i);
            System.out.println("----------------------------------------");
            
            StringBuilder sbuilder = new StringBuilder();
            time = System.currentTimeMillis();
            for (int x = 0; x < iterations; x++) {
                sbuilder.append("abc").append(" 123").append("!!!").toString();
            }
            s = sbuilder.toString();
            System.out.println("StringBuilder = " + (System.currentTimeMillis() - time) + "ms");

            s = "";
            time = System.currentTimeMillis();
            for (int x = 0; x < iterations; x++) {
                s += "cde" + " 456" + "...";
            }
            System.out.println("Plus = " + (System.currentTimeMillis() - time) + "ms");
            
            s = "";
            time = System.currentTimeMillis();
            for (int x = 0; x < iterations; x++) {
                s = s.concat("efg").concat(" 789").concat("???");
            }            
            System.out.println("Concat = " + (System.currentTimeMillis() - time) + "ms");
            
            s = "";
            StringBuffer sb = new StringBuffer();
            time = System.currentTimeMillis();
            for (int x = 0; x < iterations; x++) {
                sb.append("hij").append(" lmn").append("***").toString();
            }
            s = sb.toString();
            System.out.println("StringBuffer = " + (System.currentTimeMillis() - time) + "ms");            
            System.out.println("----------------------------------------");
            System.out.println();
        }
    }
}

Agora concateno coisas diferentes, de mesmo tamanho. Assim ninguém se beneficia de strings internalizadas no pool.

Os resultados já foram mais consistentes:
Test 1
----------------------------------------
StringBuilder = 2344ms
Plus = 17609ms
Concat = 19204ms
StringBuffer = 2343ms
----------------------------------------

Test 2
----------------------------------------
StringBuilder = 2328ms
Plus = 13500ms
Concat = 19360ms
StringBuffer = 2344ms
----------------------------------------

Quer tentar rodar no seu também (além de conferir o código)? Acho que estamos conseguindo filtrar parte do ruído. :)

eduveks
eduveks

exato, deu o dobro :stuck_out_tongue:

StringBuilder = 4234ms Plus = 69749ms Concat = 31203ms StringBuffer = 4297ms

Bem mas isto é concatenação grande, concatenação curta, continua sendo o problema.

Se tenho um método q cria um StringBuilder e faz uns appends, e depois por acaso alguem chama este método dentro de um loop, e ai como ficamos?

Então sempre q for simples concactenações devemos usar o concat? Que o + só é mais rápido quando são strings estáticas, se tiver uma string como variável ai já é mais demorado que o concat, como no primeiro benchmark.

Certo?

eduveks
eduveks

Ou seja se formos fazer um return…

Isto estaria errado:

return new StringBuilder(s).append(".");

Assim é o correto:

return s.concat(".");

Se for duas strings estaticas, o certo é:

return ".." + ".";

Mas no caso de duas strings estaticas não há razão para fazer somas lol

E tudo q for concatenações massivas sempre StringBuilder e em problemas especificos de sincronismo o StringBuffer.

De acordo? :stuck_out_tongue:

ViniGodoy
ViniGodoy

De acordo. De qualquer forma, a experiência foi interessante. :smiley:

Ainda assim, a dica da Sun é válida:
Na dúvida use StringBuilder.

Em poucas concatenações curtas, a diferença de tempo não será significativa. (Afinal, elas são curtas mesmo)
Numa longa, a performance dele é muito melhor.

Claro, se você souber que existe uma série de concatenações curtas, especialmente se for baseada em valores parecidos, aí pode usar o concat.
Mas é sempre bom saber dessas diferenças. :slight_smile:

E a moral da história. Não se apressar em concluir coisas com benchmarks. O ideal é ficar atentos a diferença muito grandes de número e valores, especialmente entre 2 ou 3 execuções. Essas diferenças geralmente indicam ruídos (garbage collection, alocação de memória, etc) que tem que ser filtrados.

eduveks
eduveks

ya foi uma boa experiência!

sim, mais bom senso nos benchmarks pra próxima, vou tentar :stuck_out_tongue:

e isto de usar o concat ou StringBuilder, já vi muita gente dizendo e fazendo new StringBuilder pra tudo e mais um pouco e eu tb já fiz muito isso, e sempre fiquei com a pulga atrás da orelha em usar StringBuilder sempre.

valew a experiência, agora esta tudo mais claro :wink:

Criado 19 de maio de 2008
Ultima resposta 20 de mai. de 2008
Respostas 14
Participantes 4

Topicos relacionados

Como saber se um mes tem 4 ou 5 semanas?[RESOLVIDO] 31 respostas Como converter inteiro para string! 13 respostas Comando SELECT para selecionar intervalo de data SQL SERVER 12 respostas &, &&, |, ||. Qndo usar? 6 respostas O método split 12 respostas
Alura POO: o que é programação orientada a objetos? Aprenda os conceitos básicos da programação orientada a objetos, como classes, objetos, herança, encapsulamento e polimorfismo, com exemplos.
Casa do Codigo Inteligencia Artificial e ChatGPT: Da revolucao dos... Por Fabricio Carraro — Casa do Codigo