Ver essa explicação é boa, então vou mudar isso
Existem 3 classes em Java responsáveis pelas operações de caracteres.
1. O caractere é uma operação de um único caractere.
2.String opera em uma série de caracteres, classe imutável.
3.StringBuffer também é uma operação em uma série de caracteres e é uma classe mutável.
Corda:
É um objeto, não um tipo primitivo.
É um objeto imutável e, uma vez criado, seu valor não pode ser modificado.
A modificação dos objetos de string existente é recriar um novo objeto e salvar o novo valor nele.
String é uma classe final, ou seja, não pode ser herdada.
StringBuffer:
É um objeto mutável.
Só pode ser criado por construtores,
StringBuffer sb = new StringBuffer ();
Nota: Não pode ser pago pelos símbolos de atribuição.
sb = "Bem -vindo aqui!"; // Erro
Depois que o objeto for criado, o espaço de memória será alocado na memória e um nulo será salvo inicialmente.
sb.append ("hello");
A eficiência do StringBuffer é maior que a da string na String Concatenation:
String str = new String ("Welcome to");
str += "aqui";
A etapa de processamento é realmente criando um StringBuffer, chamando Append () e finalmente
Em seguida, adicione StringBuffer tosting ();
Dessa forma, a operação de conexão de string terá algumas operações adicionais que o StringBuffer e, é claro, a eficiência será reduzida.
E como o objeto String é um objeto imutável, cada operação do Sting recriará um novo objeto para salvar o novo valor.
Dessa forma, o objeto original será inútil e será coletado de lixo.
Dê uma olhada no seguinte código:
Repita 26 cartas em inglês 5.000 vezes.
A cópia do código é a seguinte:
String tempstr = "abcdefghijklmnopqrstuvwxyz";
int times = 5000;
long lStart1 = System.currenttimemillis ();
String str = "";
para (int i = 0; i <vezes; i ++) {
str += tempstr;
}
long lend1 = system.currenttimemillis ();
longo tempo = (lind1 - lStart1);
System.out.println (tempo);
Infelizmente, meu computador não é um supercomputador, e os resultados que obtive não são necessariamente os mesmos a cada vez, geralmente em torno de 46687.
Isso é 46 segundos.
Vamos dar uma olhada no seguinte código
A cópia do código é a seguinte:
String tempstr = "abcdefghijklmnopqrstuvwxyz";
int times = 5000;
long lStart2 = System.CurrentTimemillis ();
StringBuffer sb = new StringBuffer ();
para (int i = 0; i <vezes; i ++) {
sb.append (tempstr);
}
long lend2 = System.currenttimemillis ();
longo tempo2 = (Lend2 - lStart2);
System.out.println (Time2);
O resultado é 16 e às vezes é 0
Portanto, a conclusão é óbvia, a velocidade do StringBuffer é quase dezenas de milhares de vezes a da corda. Obviamente, esses dados não são muito precisos. Como o número de ciclos é 100.000 vezes, a diferença é ainda maior. Se você não acredita em mim, tente
Se você ainda não consegue entender:
1) A diferença entre o método articular + da string e o método de apêndice de StringBuff:
Quando o operador String + executa operação de sequência, ele converte primeiro o objeto String atual em tipo StringBuff, chama seu método de apêndice e finalmente converte o objeto StringBuff gerado em uma string de string por meio de seu método de tostring, para que ele seja ineficiente.
No entanto, em termos de legibilidade, o operador de conexão da String ainda é alto.
2) StringBuff é seguro para fios
String não é segura para threads
3) String é um objeto String que não pode ser modificado, enquanto o StringBuff é modificado.
A cópia do código é a seguinte:
public static boolean filecopy (string srcstr, string deststr) {
Arquivo srcfile = null;
Arquivo Destfile = NULL;
Leitor leitor = null;
Escritor escritor = null;
bandeira booleana = false;
tentar {
srcfile = novo arquivo (srcstr);
if (! srcfile.exists ()) {
System.out.println ("O arquivo de origem não existe");
System.Exit (0);
} outro {
leitor = new FileReader (srcfile);
}
destfile = novo arquivo (deststr);
writer = new FileWriter (Destfile);
char [] buff = novo char [1024];
int len;
String str = "";
Stringbuffer sbuff = new StringBuffer ();
while ((len = leitor.read (buff))! = -1) {
// str += new string (buff, 0, len);
sbuff.append (new string (buff, 0, len));
}
// writer.write (str.toCharArray ());
writer.write (sbuff.toString (). toCharArray ());
bandeira = true;
writer.flush ();
leitor.close ();
writer.close ();
} catch (ioexception e) {
System.out.println ("Exceção de cópia do arquivo: =" + e.getMessage ());
}
bandeira de retorno;
}