1 string
String: String constante, o comprimento da string é imutável.
2 StringBuffer
StringBuffer: String variável (sincronizada, isto é, segura de thread). Se você deseja modificar frequentemente o conteúdo da string, é melhor usar o StringBuffer por razões de eficiência. Se você deseja converter para o tipo String, pode chamar o método ToString () StringBuffer's ToString ().
Java.lang.StringBuffer Sequência de caracteres mutável segura para roscas. Ele contém uma certa sequência de caracteres a qualquer momento, mas o comprimento e o conteúdo da sequência podem ser alterados por algumas chamadas de método. Os buffers de string podem ser usados com segurança para vários threads.
As principais operações no StringBuffer são os métodos Apêndos e Inserir, que podem ser sobrecarregados para aceitar qualquer tipo de dados. Cada método pode efetivamente converter os dados especificados em uma string e, em seguida, anexar ou inserir os caracteres da string no buffer da string. O método Apênd sempre adiciona esses caracteres ao final do buffer; O método Insert adiciona caracteres no ponto especificado. Por exemplo, se z refere -se a um objeto de buffer de string cujo conteúdo atual é "Iniciar", esse método chama Z.append ("LE") faz com que o buffer de string contenha "Startle" e Z.Insert (4, "LE") altera o buffer de string para conter "Starlet".
3 StringBuilder
StringBuilder: String Variable (seguro não-Thread).
java.lang.stringbuilder é uma sequência de caracteres variável que é adicionada recentemente ao JDK5.0. Esta classe fornece uma API compatível com StringBuffer, mas não é garantida que seja sincronizada. Esta classe foi projetada para ser um substituto simples para StringBuffer, quando os buffers de string são usados por um único encadeamento (isso é comum). Se possível, é recomendável fazer esta aula primeiro, porque na maioria das implementações é mais rápido que o StringBuffer. Os métodos de ambos são basicamente os mesmos.
Na maioria dos casos, StringBuilder> StringBuffer.
4 A diferença entre os três
A principal diferença de desempenho entre o tipo String e StringBuffer: String é um objeto imutável. Portanto, toda vez que o tipo de string é alterado, um novo objeto de string será gerado e, em seguida, o ponteiro será apontado para um novo objeto String. Portanto, é melhor não usar string para seqüências de caracteres que geralmente alteram o conteúdo, porque toda vez que o objeto é gerado, isso terá um impacto no desempenho do sistema, especialmente quando houver muitos objetos referenciados na memória, o GC da JVM começará a funcionar e o desempenho será degradado.
Ao usar a classe StringBuffer, o próprio objeto StringBuffer é operado todas as vezes em vez de gerar um novo objeto e alterar a referência do objeto. Portanto, na maioria dos casos, o StringBuffer é recomendado, especialmente quando os objetos da string são frequentemente alterados.
Em alguns casos especiais, o splicing de string do objeto String é realmente interpretado pela JVM como um splicing do objeto StringBuffer, de modo que a velocidade do objeto String não é mais lenta que o objeto StringBuffer nesses momentos, por exemplo:
String s1 = "Este é apenas um" + "simples" + "teste"; StringBuffer sb = new StringBuilder ("Isso é apenas A"). Append ("Simple"). Append ("Test"); A geração de objetos String S1 não é mais lenta que o StringBuffer. De fato, na JVM, a seguinte conversão é executada automaticamente:
String s1 = "Este é apenas um" + "simples" + "teste";
A JVM trata diretamente a declaração acima como:
String S1 = “Este é apenas um teste simples”;
Portanto, a velocidade é muito rápida. Mas deve -se notar que, se a corda emendada vier de outro objeto de string, a JVM não será convertida automaticamente e a velocidade não será tão rápida, por exemplo:
String s2 = "Este é apenas um"; string s3 = "simples"; string s4 = "test"; string s1 = s2 + s3 + s4;
Neste momento, a JVM fará isso de maneira regular da maneira original.
Na maioria dos casos, StringBuffer> String.
4.StringBuffer e StringBuilder
Quase não há diferença entre os dois. Eles estão basicamente chamando vários métodos da classe pai. Uma diferença importante é que o StringBuffer é seguro para threads. A maioria dos métodos internos tem a palavra -chave sincronizada antes dela, o que causará certo consumo de desempenho. O StringBuilder não é seguro, por isso é mais eficiente.
public static void main (string [] args) lança exceção {string string = "0"; int n = 10000; long begin = System.currenttimemillis (); for (int i = 1; i <n; i ++) {string+= i; } long end = System.currenttimemillis (); longo entre = fim - comece; System.out.println ("tempo consumido usando a classe String:" + entre + "ms"); int n1 = 10000; StringBuffer sb = new StringBuffer ("0"); Long começo1 = System.CurrentTimemillis (); for (int j = 1; j <n1; j ++) {sb.append (j); } long end1 = System.currenttimemillis (); longo entre1 = end1 - começo1; System.out.println ("tempo consumido usando a classe StringBuffer:" + entre 1 + "ms"); int n2 = 10000; Stringbuilder sb2 = new stringbuilder ("0"); long começo2 = System.currenttimemillis (); for (int k = 1; k <n2; k ++) {sb2.append (k); } long end2 = system.currenttimemillis (); longo entre2 = end2 - começo2; System.out.println ("demorado para usar a classe StringBuilder:" + entre2 + "ms"); } Saída:
Hora de usar classe String: 982ms Hora para usar a classe StringBuffer: 2ms Hora para usar a classe StringBuilder: 1ms
Embora esse número seja diferente a cada vez, e a situação de cada máquina é diferente, existem vários pontos certos, e a classe String consome significativamente mais do que os outros dois. Outro ponto é que o StringBuffer consome mais do que o StringBuilder, embora a diferença não seja óbvia.
5 estratégias de uso
(1) Princípios básicos: se você deseja operar uma pequena quantidade de dados, use string; Se você operar uma grande quantidade de dados com um único thread, use StringBuilder; Se você opera uma grande quantidade de dados com um multi-thread, use StringBuffer.
(2) Não use o "+" da classe String para splicing frequente, porque se o desempenho for extremamente ruim, você deve usar a classe StringBuffer ou StringBuilder, que é um princípio relativamente importante na otimização de Java. Por exemplo: ao usar string, ao singular seqüências de splicing, use "+" para formar um objeto StringBuffer temporário na JVM e, ao mesmo tempo, um objeto é criado em cada string. Após a união de duas cordas, são necessários 4 objetos para ser criado! (Uma string que mantém o resultado, dois objetos de string e um objeto StringBuffer temporário). Se você usa StringBuffer, só precisará criar 2 objetos! Um objeto StringBuffer e objeto String que contém o último resultado.
(3) Para um melhor desempenho, sua capacidade deve ser especificada o máximo possível ao construir StirngBuffer ou Stirngbuilder. Obviamente, se a string que você opera não exceder 16 caracteres, você não precisará dela. Não especificar a capacidade reduzirá significativamente o desempenho.
(4) O StringBuilder é geralmente usado dentro do método para concluir as funções semelhantes "+". Porque ? é seguro para threads, ele pode ser descartado após o uso. O StringBuffer é usado principalmente em variáveis globais.
(5) O uso do StirngBuilder na mesma situação pode obter apenas uma melhoria de desempenho de cerca de 10% ~ 15% em comparação com o uso do StringBuffer, mas corre o risco de insegura com múltiplos threading. Na programação modular real, o programador responsável por um determinado módulo pode não ser capaz de determinar claramente se o módulo será colocado em um ambiente multithread. Portanto, o StringBuilder só pode ser usado, a menos que você tenha certeza de que o gargalo do sistema está no StringBuffer e você tem certeza de que seu módulo não será executado no modo multithread; Caso contrário, o StringBuffer ainda é usado.