Eu costumava ver discussões sobre a emenda de cordas Java e outros aspectos na Internet. Vi alguns desenvolvedores de Java em suas sugestões a programadores iniciantes como o seguinte:
Não use o sinal + para unir strings, use o método Append () do StringBuffer ou StringBuilder para unir strings.
No entanto, é realmente tão irritante unir cordas com + sinais. Não há nada de bom em usar + sinais para unir strings?
Ao procurar algum conteúdo sobre a classe String na documentação da API Java, podemos ver o seguinte snippet:
"O idioma Java fornece suporte especial para símbolos de concatenação de string ("+") e convertendo outros objetos em strings. A concatenação da string é implementada através da classe StringBuilder (ou StringBuffer) e seu método de apêndice. A conversão da string é implementada através do método do tostring, que é definido pela classe de objeto e pode ser inérfia por todas as classes.
Esta passagem nos diz claramente que em Java, o uso de strings de splicing + de sinal é realmente implementado pelo StringBuffer ou StringBuilder e seu método Apênd.
Além da documentação da API Java, também podemos usar a ferramenta para visualizar o comando bytecode do arquivo de classe para obter a resposta acima. Por exemplo, código:
public static void main (string [] args) {string a = "hello"; String b = "mundo"; String str = a + b + "!"; System.out.println (str);} O comando para visualizar o bytecode correspondente através da ferramenta é o seguinte:
No comando bytecode, podemos ver claramente que o seguinte código que escrevemos
String str = a + b + "!";
Foi convertido em uma declaração semelhante ao seguinte:
String str = new StringBuilder (String.ValueOf (a)). Append (B) .Append ("!"). ToString ();Além disso, o compilador Java também é um compilador relativamente inteligente. Quando o splicing de sinal + é de todos os literais de string, o compilador Java o converterá de forma inteligente em uma string completa durante a compilação. Por exemplo:
public static void main (string [] args) {string str = "hello" + "World" + ", java!"; System.out.println (str);} O compilador Java esou diretamente esse tipo de string que é literal e a converte em uma string completa quando compilada.
Mesmo se houver variáveis na corda emendada com o sinal +, o compilador Java mesclará os literais da sequência frontal em uma string.
public static void main (string [] args) {string java = ", java!"; String str = "Hello" + "World" + Java; System.out.println (str);}Do exposto, pode -se observar que, para uma operação como String str = str1 + str2 + str3 + str4, não há problema em unir várias seqüências de cordas ao mesmo tempo.
Em Java, os objetos de string são imutáveis (imutáveis). No código, você pode criar vários aliases para um determinado objeto de string. Mas as referências desses aliases são iguais.
Por exemplo, S1 e S2 são alias para objetos "droidyue.com", e os alias são armazenados em referências ao objeto real. Então S1 = S2
String s1 = "dRoidyue.com"; string s2 = s1; system.out.println ("s1 e s2 tem a mesma referência =" + (s1 == s2));E em Java, o único operador sobrecarregado está relacionado ao splicing de string. +,+=. Além disso, os designers de Java não permitem a sobrecarga de outros operadores.
Em Java, o único operador sobrecarregado está relacionado ao splicing de string. +,+=. Além disso, os designers de Java não permitem a sobrecarga de outros operadores.
Como todos sabemos, antes do Java 1.4, a costura de cordas poderia ser usada para unir cordas. A partir do Java 1.5, podemos usar o StringBuilder para unir strings. A principal diferença entre StringBuffer e StringBuilder é que o StringBuffer é seguro para threads e é adequado para a operação de strings com vários tacos; O StringBuilder é seguro para threads e é adequado para operar strings sob um único thread. No entanto, a maioria das nossas operações de costura de cordas é realizada em um único thread; portanto, o uso do StringBuilder é benéfico para o desempenho.
Antes do Java 1.4, o compilador usava o StringBuffer para manusear strings com + strings emendado por sinal; A partir do Java 1.5, o compilador usou o StringBuilder para lidar com strings com strings emendadas + sinais na maioria dos casos.
Quando escrevemos código no ambiente JDK 1.4, recomenda -se que o sinal + seja usado para lidar com a situação acima, onde várias seqüências de cordas são emendas de uma só vez. Dessa forma, quando o JDK é atualizado para 1,5 e acima, o compilador o converterá automaticamente em stringbuilder para splice strings, melhorando assim a eficiência do splicing de cordas.
Obviamente, o uso recomendado de + strings de splicing de sinal é limitado apenas ao uso ao unir várias strings em uma declaração. Se você ceder uma string em várias instruções, ainda é recomendável usar StringBuffer ou StringBuilder. Por exemplo:
public static void main (string [] args) {string java = ", java!"; String str = ""; str += "Olá"; str += "mundo"; str += java; System.out.println (str);} Os comandos de bytes compilados do compilador são os seguintes:
A partir da imagem acima, podemos saber que cada instrução de splicing de sinal + cria um novo objeto Stringbuilder. Essa situação é particularmente evidente nas condições do ciclo, resultando em perdas de desempenho relativamente grandes. Portanto, é altamente recomendável usar StringBuffer ou StringBuilder para lidar com strings em várias instruções.
Sobre a otimização trazida usando StringBuilder
Além disso, ao usar StringBuffer ou StringBuilder, também podemos usar o seguinte método para melhorar ainda mais o desempenho (o código a seguir toma o StringBuilder como exemplo, o StringBuffer é semelhante a isso).
1. Preveja o comprimento máximo da sequência final obtida.
O comprimento padrão da matriz de char dentro do StringBuilder é 16. Quando anexamos a string e excedemos esse comprimento, o StringBuilder expandirá a capacidade da matriz interna para atender às necessidades. Nesse processo, o StringBuilder cria uma nova matriz de char de maior capacidade e copia os dados da matriz original para a nova matriz. Se pudermos prever aproximadamente o comprimento máximo da string que finalmente é emendado, podemos especificar a capacidade inicial do tamanho apropriado ao criar o objeto StringBuilder. Por exemplo, precisamos unir para obter uma string contendo 100 letras a. Você pode escrever o seguinte código:
StringBuilder SB = new StringBuilder (100); for (int i = 0; i <100; i ++) {sb.append ('a');} system.out.println (sb);Balance de acordo com as condições reais para criar um StringBuilder adequado para a capacidade inicial.
2. Para caracteres individuais, use o tipo de char em vez do tipo de string o máximo possível.
Às vezes, precisamos anexar um único caractere após a string (por exemplo: a), e devemos usá -la o máximo possível no momento.
sb.append ('a');Em vez de usar:
sb.append ("A");