Strings são imutáveis ??- Isso significa que eu nunca deve usar + = e única StringBuffer?

StackOverflow https://stackoverflow.com/questions/1635659

Pergunta

Strings são imutáveis, significado, uma vez que eles foram criados, eles não podem ser alterados.

Então, isso significa que seriam necessários mais memória se você acrescentar coisas com + = do que se você criou um StringBuffer e anexado texto para isso?

Se você usar + =, você criaria um 'objeto' novo cada vez que tem de ser guardados na memória, não é?

Foi útil?

Solução

Sim, você vai criar um novo objeto de cada vez com + =. Isso não significa que é sempre a coisa errada a fazer, no entanto. Depende se você quer que o valor como uma string, ou se você está indo só para usá-lo para construir a corda ainda mais.

Se você realmente deseja o resultado de x + y como uma string, então você pode muito bem usar concatenação. No entanto, se você está realmente indo para (digamos) de loop rodada e anexar uma outra corda, e outro, etc - necessitando apenas o resultado como uma string no final, então StringBuffer / StringBuilder são o caminho a percorrer. Na verdade, looping é realmente onde StringBuilder compensa ao longo concatenação - a diferença de desempenho para 5 ou mesmo 10 concatenations diretos vai ser muito pequeno, mas há milhares torna-se muito pior - basicamente porque você começa O (N 2 ) com a complexidade de concatenação vs S (N) com a complexidade StringBuilder.

Em Java 5 e acima, você deve, basicamente, usar StringBuilder - é não sincronizada, mas isso é quase sempre tudo bem; é muito raro querer a uma ação entre segmentos.

Eu tenho um artigo sobre tudo isso que você pode achar útil.

Outras dicas

Regra de ouro é simples:

Se você estiver executando concatenations em um loop, não use +=

Se você é não em execução concatenations em um loop, usando += simplesmente não importa. (A menos que uma aplicação crítica desempenho

Em Java 5 ou posterior, StringBuffer é thread-safe, e por isso tem alguma sobrecarga que você não deve pagar menos que você precisar dele. StringBuilder tem a mesma API, mas não é thread-safe (ou seja, você só deve usá-lo interna para um único segmento).

Sim, se você está construindo grandes cordas, é mais eficiente usar StringBuilder. Provavelmente não vale a pena passar StringBuilder ou StringBuffer em torno de como parte de sua API. Isso é muito confusa.

Eu concordo com todas as respostas postadas acima, mas vai ajudá-lo um pouco para entender mais sobre a forma como Java é implementada. A JVM utiliza StringBuffers internamente para compilar o operador de Cordas + (Do StringBuffer Javadoc ):

buffers de corda são usados ??pelo compilador para implementar o binário operador de concatenação +. Para exemplo, o código: 

     x = "a" + 4 + "c"

é compilado para o equivalente a: 

     x = new StringBuffer().append("a").append(4).append("c")
                           .toString()

Do mesmo modo, x += "some new string" é equivalente a x = x + "some new string". Você ver onde eu estou indo com isso?

Se você está fazendo um monte de concatenações de corda, usando StringBuffer irá aumentar o seu desempenho, mas se você está apenas fazendo um par de concatenações seqüência simples, o compilador Java provavelmente otimizá-lo para você, e você não vai notar uma diferença de desempenho

Sim. String é imutável. Para uso ocasional, + = é OK. Se o + = operação é intenso, você deve virar para StringBuilder.

Mas o coletor de lixo vai acabar liberando as velhas cordas uma vez não há referências a eles

Exatamente. Você deve usar um StringBuilder embora se thread-segurança não é um problema.

Como uma nota lateral: Pode haver vários objetos String usando o mesmo caractere apoio [] - por exemplo, sempre que você usar substring (), nenhum novo char [] será criado o que torna a usá-lo bastante eficiente.

Além disso, os compiladores podem fazer alguma otimização para você. Por exemplo, se você fizer 

static final String FOO = "foo";
static final String BAR = "bar"; 

String getFoobar() {
  return FOO + BAR; // no string concatenation at runtime
}

Eu não ficaria surpreso se o compilador usaria StringBuilder internamente para otimizar concatenação de String sempre que possível -. Se não já talvez no futuro

Eu acho que depende da GC para coletar a memória com a corda abandonado. Assim fazendo + = com o construtor corda será definitivamente mais rápido se você tem um monte de operação sobre a manipulação de cadeia. Mas não é deve um problema para a maioria dos casos.

Sim, você iria e é exatamente por isso que você deve usar StringBuffer para concatenar um monte de Strings.

Observe também que, desde Java 5, você também deve preferir StringBuilder maior parte do tempo. É apenas uma espécie de StringBuffer unsynchronized.

Você está certo de que strings são imutáveis, por isso, se você está tentando memória conserve ao fazer um monte de concatenação, você deve usar StringBuilder em vez de + =.

No entanto, você pode não se importar. Programas são escritos para os seus leitores humanos, para que possa ir com clareza. Se é importante que você otimizar, você deve primeiro perfil. A menos que seu programa é muito fortemente ponderada para a atividade corda, provavelmente haverá outros gargalos.

Não

Ele não vai usar mais memória. Sim, novos objetos são criados, mas os antigos são reciclados. No final, a quantidade de memória utilizada é a mesma.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top