Diferença entre string e stringbuilder em java

A classe String é usada para criar uma string imutável, enquanto StringBuffer e StringBuilder são usados ​​para criar strings que são mutáveis.

Além disso, o StringBuffer é sincronizado, enquanto o StringBuilder não é sincronizado.

Sequência: É imutável, final e segura para discussão. Mas cada operação criará um objeto String, portanto, custará mais memória.

StringBuffer: É mutável, não final, é seguro para threads.

StringBuilder: é mutável, não final, não é seguro para threads.

Desempenho: StringBuilder é mais rápido que StringBuffer, StringBuffer é mais rápido que String.

O artigo abaixo fornece explicações detalhadas sobre as diferenças entre eles.

Diferença entre Java String, StringBuffer e StringBuilder - Tutorial em Java, Tutorial em Selenium

Tanto o StringBuffer quanto o StringBuilder parecem, mas essa é uma das perguntas de entrevista irregulares. A seguir, alguns pontos precisam ser lembrados. mesmo para ser

StringBuffer é sincronizado onde, como StringBuilder, não está sincronizado.

StringBuffer é seguro para threads, o que significa que por vez apenas um único thread pode operar.

O StringBuilder não é seguro para threads, o que significa que por vez vários threads podem operar.

O desempenho do StringBuffer é lento quando comparado ao StringBuilder porque, porque um encadeamento precisa aguardar em um StringBuffer.

StringBuffer foi introduzido na versão 1.0, onde StringBuilder foi introduzido na versão 1.5.

H

String é a classe básica para criar seqüências de texto. É imutável, o que significa que você não pode alterá-lo depois que ele é criado. Isso torna incrivelmente difícil alterar caracteres ou inserir itens no meio.

StringBuilder permite alterar e anexar facilmente a uma string. Use-o se você tiver uma sequência que deseja montar passo a passo ou altere facilmente caracteres individuais.

StringBuffer é idêntico ao StringBuilder, exceto que é seguro para threads. Isso significa que, se você tiver vários threads (programas / processos) tentando alterá-lo no momento seguro, não há chances de que ele seja corrompido. No entanto, é muito mais lento. Sempre use StringBuilder, se possível.

Diferença de mutabilidade: String é imutável; se você tentar alterar seus valores, outro objeto será criado, enquanto StringBuffer e StringBuilder são mutáveis ​​para que possam alterar seus valores. Diferença de segurança de thread: a diferença entre StringBuffer e StringBuilder é que StringBuffer é seguro para threads. Portanto, quando o aplicativo precisar ser executado apenas em um único encadeamento, é melhor usar o StringBuilder. StringBuilder é mais eficiente que StringBuffer. Situações:

  • Se sua string não for alterada, use uma classe String porque um objeto String é imutável.
  • Se sua string puder mudar (exemplo: muita lógica e operações na construção da string) e somente será acessada a partir de um único encadeamento, o uso de um StringBuilder é bom o suficiente.
  • Se sua string puder mudar e será acessada a partir de vários threads, use um StringBuffer porque StringBuffer é síncrono para que você tenha segurança de thread.

Estes são os seguintes

diferença entre String e StringBuilder

.

MUTABILIDADE:

String é imutável (após a criação, não pode ser modificado).

Vamos ver o exemplo de String:

String str = "Diário Técnico";str = str + “Blog mais emergente do Estado Unidos";

Podemos ver que o valor de str foi alterado de "Diário Técnico" para "Blog mais emergente no Estado Unidos". Por isso, parece que String é mutável (modificável), mas a verdade é que é imutável (uma vez criado, não pode ser modificado). Na verdade, na primeira instrução, um objeto é criado usando a string literal “Technical Diary” e na segunda instrução quando atribuímos a nova string literal (“Blog mais emergente no Estados Unidos”) à variável str. Nesse caso, o objeto em si não foi alterado porque um novo objeto foi criado usando a nova string literal (“Blog técnico mais recente do blog no estado americano”). E a referência a ele (novo objeto) é atribuída à variável str. Portanto, ambos os literais ou objetos de string existem com referências diferentes.

StringBuilder é mutável (após a criação, ele pode ser modificado).

Vamos ver o exemplo do StringBuilder:

StringBuilder str = new StringBuilder (“Diário Técnico”);Str.Append (": Primeira escolha de usuários da Microsoft");

No exemplo acima, podemos ver que na primeira instrução um objeto é criado usando a string literal "Technical Diary". Na segunda declaração, o valor do objeto é alterado de "

Diário Técnico

”Para“ Diário Técnico: Primeira Escolha dos Usuários da Microsoft ”após concatenação. Então aqui o objeto foi modificado em vez de criar um novo objeto como String.

atuação

:

O StringBuilder é preferido sobre o String para concatenação de strings, porque é mais rápido. No caso de String, quando você concatena cordas, na verdade você está criando um novo objeto sempre que é imutável e isso o torna mais lento que o StringBuilder.

using System;using System.Text;espaço para nome StringVsStringBuilder{ Programa de aula { static void Main (string [] args) { long startTime = DateTime.Now.Ticks; StringConcat (); Console.WriteLine ("Tempo gasto para StringConcat:" + (DateTime.Now.Ticks - startTime) / (decimal) TimeSpan.TicksPerMillisecond + "ms"); startTime = DateTime.Now.Ticks; StringBuilderConcat (); Console.WriteLine ("Tempo gasto para StringBuilderConcat:" + (DateTime.Now.Ticks - startTime) / (decimal) TimeSpan.TicksPerMillisecond + "ms"); } public static String StringConcat () { String str = "Diário Técnico"; for (int i = 0; i <10000; i ++) { str = str + "S Sharif"; } return str; } public static String StringBuilderConcat () { StringBuilder strBuilder = novo StringBuilder ("Diário Técnico"); for (int i = 0; i <10000; i ++) { strBuilder.Append ("S Sharif"); } retornar strBuilder.ToString (); } }}

Resultado:

Na imagem acima, você pode ver que o tempo gasto pela String é 383.344ms. E para o mesmo tempo de operação gasto pelo StringBuilder é 1.0009ms. Portanto, isso prova que o StringBuilder é mais rápido que o String.

Isto é do meu fim. Se você quiser mais explicações, pode consultar meu blog:

Qual é a diferença entre String e Stringbuilder?

. Feliz codificação…. :)

Diferença entre String e StringBuffer

  • As strings criadas pela classe String são imutáveis, enquanto que as strings criadas pela StringBuffer são mutáveis.
  • Para saber mais sobre as diferenças entre as classes String e StringBuffer, consulte Diferença entre String e StringBuffer

Diferença entre String e StringBuilder

  • Tentar modificar a string criada pela classe String leva ao desperdício de memória, enquanto que, modificar uma string criada pelo objeto StringBuilder não gera desperdício de memória.
  • Para mais diferenças entre String e StringBuilder com exemplos de código, consulte Diferença entre String e StringBuilder- Decodejava.com

Diferenças entre StringBuilder e StringBuffer

  • A classe StringBuffer é mais lenta que a classe StringBuilder.
  • A classe StringBuffer não é segura para threads, enquanto a classe StringBuilder é segura para threads.
  • Para obter mais diferenças entre as classes StringBuffer e StringBuilder com exemplos fáceis de código, consulte Diferença entre StringBuffer e StringBuilder

Boa sorte!