Quelle est la différence entre la chaîne et StringBuffer en Java?

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

Question

Quelle est la différence entre la chaîne et StringBuffer en Java?

Y at-il une taille maximale pour cordes?

Était-ce utile?

La solution

String est utilisé pour manipuler des chaînes de caractères qui ne peuvent pas être modifiés (en lecture seule et immuable).

StringBuffer est utilisé pour représenter les caractères qui peuvent être modifiés.

Performance sage, StringBuffer est plus rapide lors de l'exécution concaténations. En effet, lorsque vous concaténer une String, vous créez un nouvel objet (interne) à chaque fois depuis String est immuable.

Vous pouvez également utiliser StringBuilder qui est similaire à StringBuffer sauf qu'il est pas synchronisé. La taille maximale pour l'un de ceux-ci est Integer.MAX_VALUE (2 31 - 1 = 2147483647) ou la taille de segment maximale divisé par deux (voir combien de caractères peuvent chaîne Java ont ). Plus d'informations .

Autres conseils

A String est immuable, à savoir quand il est créé, il ne peut jamais changer.

est utilisé lorsque vous avez besoin de construire un morceau de ficelle par pièce sans les frais généraux de performance de construction beaucoup de petits StringBuffers le long du chemin A StringBuilder (ou son cousin, non synchronisé String).

La longueur maximale pour les deux est Integer.MAX_VALUE, car ils sont stockés en interne sous forme de tableaux et tableaux Java ont seulement une int pour leur pseudo-champ de longueur.

L'amélioration de la performance entre Strings et StringBuffers pour la concaténation multiple est tout à fait significatif. Si vous exécutez le code de test suivant, vous verrez la différence. Sur mon ordinateur portable ancienne avec Java 6, je reçois ces résultats: 

Concat with String took: 1781ms
Concat with StringBuffer took: 0ms

public class Concat
{
    public static String concatWithString()
    {
        String t = "Cat";
        for (int i=0; i<10000; i++)
        {
            t = t + "Dog";
        }
        return t;
    }
    public static String concatWithStringBuffer()
    {
        StringBuffer sb = new StringBuffer("Cat");
        for (int i=0; i<10000; i++)
        {
            sb.append("Dog");
        }
        return sb.toString();
    }
    public static void main(String[] args)
    {
        long start = System.currentTimeMillis();
        concatWithString();
        System.out.println("Concat with String took: " + (System.currentTimeMillis() - start) + "ms");
        start = System.currentTimeMillis();
        concatWithStringBuffer();
        System.out.println("Concat with StringBuffer took: " + (System.currentTimeMillis() - start) + "ms");
    }
}

String                                          StringBuffer

Immutable                                       Mutable
String s=new String("karthik");                StringBuffer sb=new StringBuffer("karthik")
s.concat("reddy");                             sb.append("reddy");
System.out.println(s);                         System.out.println(sb);
O/P:karthik                                    O/P:karthikreddy

--->once we created a String object            ---->once we created a StringBuffer object
we can't perform any changes in the existing  we can perform any changes in the existing
object.If we are trying to perform any        object.It is nothing but mutablity of 
changes with those changes a new object       of a StrongBuffer object
will be created.It is nothing but Immutability
of a String object

Use String--->If you require immutabilty
Use StringBuffer---->If you require mutable + threadsafety
Use StringBuilder--->If you require mutable + with out threadsafety

String s=new String("karthik");
--->here 2 objects will be created one is heap and the other is in stringconstantpool(scp) and s is always pointing to heap object

String s="karthik"; 
--->In this case only one object will be created in scp and s is always pointing to that object only

chaîne est une classe immuable. Cela signifie qu'une fois que vous instancier une instance d'une chaîne comme ceci: 

String str1 = "hello";

L'objet en mémoire ne peut pas être modifiée. Au lieu de cela, vous devrez créer une nouvelle instance, copiez l'ancienne chaîne et ajouter tout autre comme dans cet exemple: 

String str1 = "hello";
str1 = str1 + " world!";

Qu'est-ce qui se passe réellement est entendre que nous ne modifiez pas l'objet str1 existant ... nous réaffectons nouvelle mémoire tous ensemble, la copie des données « bonjour » et annexant « monde! » à la fin, les paramètres puis la référence str1 au point de cette nouvelle mémoire. Il semble donc vraiment plus comme celui-ci sous le capot: 

String str1 = "hello";
String str2 = str1 + " world!";
str1 = str2;

Il en résulte que ce processus « copier + coller et déplacer des choses autour de la mémoire » peut être très coûteux si fait repitively surtout récursive.

Lorsque vous êtes dans cette situation d'avoir à faire des choses encore et utiliser StringBuilder. Il est mutable et peut ajouter des cordes à la fin de l'actuel parce qu'il est de retour par un [nombre croissant] (pas à 100% si c'est la structure de données réelles, pourrait être une liste).

De :

  

Un fil de sécurité, la séquence de caractères mutable. Un tampon de chaîne est comme une chaîne, mais peut être modifiée. A tout moment, il contient une séquence de caractères particulier, mais la longueur et le contenu de la séquence peut être modifiée par certains appels de méthode.

Un StringBuffer est utilisé pour créer une chaîne unique de nombreuses chaînes, par exemple lorsque vous voulez ajouter des parties d'une chaîne dans une boucle.

Vous devez utiliser un StringBuilder au lieu d'un StringBuffer lorsque vous avez un seul accès au fil StringBuffer, puisque le StringBuilder n'est pas synchronisé et donc plus rapide.

AFAIK il n'y a pas de limite supérieure pour la taille en chaîne Java comme langage, mais les JVMs probablement une limite supérieure.

J'ai trouvé réponse pour une performance comparer intérêt chaîne vs StringBuffer par Reggie Hutcherso Source : http: // www.javaworld.com/javaworld/jw-03-2000/jw-0324-javaperf.html

Java fournit les classes StringBuffer et la chaîne, et la classe String est utilisée pour manipuler des chaînes de caractères qui ne peuvent pas être modifiés. Simplement dit, les objets de type String sont en lecture seule et immuable. La classe StringBuffer est utilisé pour représenter les caractères qui peuvent être modifiés.

La différence de performance significative entre ces deux classes est que StringBuffer est plus rapide que lors de l'exécution chaîne concaténations simples. Dans le code de manipulation de chaînes, des chaînes de caractères sont systématiquement concaténés. Utilisation de la classe String, concaténations sont généralement effectuées comme suit: 

 String str = new String ("Stanford  ");
 str += "Lost!!";

Si vous deviez utiliser StringBuffer pour effectuer la même concaténation, vous avez besoin du code qui ressemble à ceci: 

 StringBuffer str = new StringBuffer ("Stanford ");
 str.append("Lost!!");

Les développeurs supposent généralement que le premier exemple ci-dessus est plus efficace parce qu'ils pensent que le deuxième exemple, qui utilise la méthode append pour la concaténation, est plus coûteux que le premier exemple, qui utilise l'opérateur + pour concaténer deux objets String.

Le + opérateur semble innocent, mais le code généré produit quelques surprises. L'utilisation d'un StringBuffer pour concaténation peut produire, en fait, le code qui est nettement plus rapide que d'utiliser une chaîne. Pour découvrir pourquoi il en est le cas, nous devons examiner le bytecode généré par nos deux exemples. Le bytecode pour l'exemple avec de la ficelle ressemble à ceci: 

0 new #7 <Class java.lang.String>
3 dup 
4 ldc #2 <String "Stanford ">
6 invokespecial #12 <Method java.lang.String(java.lang.String)>
9 astore_1
10 new #8 <Class java.lang.StringBuffer>
13 dup
14 aload_1
15 invokestatic #23 <Method java.lang.String valueOf(java.lang.Object)>
18 invokespecial #13 <Method java.lang.StringBuffer(java.lang.String)>
21 ldc #1 <String "Lost!!">
23 invokevirtual #15 <Method java.lang.StringBuffer append(java.lang.String)>
26 invokevirtual #22 <Method java.lang.String toString()>
29 astore_1

Le bytecode à des emplacements de 0 à 9 est exécuté pour la première ligne de code, à savoir: 

 String str = new String("Stanford ");

Ensuite, le bytecode à l'emplacement 10 à 29 est exécuté pour la concaténation: 

 str += "Lost!!";

Les choses deviennent intéressantes ici. Le bytecode généré pour la concaténation crée un objet StringBuffer, puis invoque sa méthode append: l'objet StringBuffer temporaire est créé à l'emplacement 10, et sa méthode append est appelée à l'emplacement 23. Parce que la classe String est immuable, un StringBuffer doit être utilisé pour concaténation.

Après la concaténation est effectuée sur l'objet StringBuffer, il doit être converti en chaîne de caractères. Cela se fait avec l'appel à la méthode toString à l'emplacement 26. Cette méthode crée un nouvel objet String de l'objet StringBuffer temporaire. La création de cet objet temporaire StringBuffer et sa transformation ultérieure en objet String sont très chers.

En résumé, les deux lignes de code ci-dessus résultat dans la création de trois objets:

  1. Un objet de chaîne à l'emplacement 0
  2. Un objet StringBuffer à l'emplacement 10
  3. Un objet de chaîne à l'emplacement 26

Maintenant, regardons le bytecode généré pour l'exemple en utilisant StringBuffer: 

0 new #8 <Class java.lang.StringBuffer>
3 dup
4 ldc #2 <String "Stanford ">
6 invokespecial #13 <Method java.lang.StringBuffer(java.lang.String)>
9 astore_1
10 aload_1 
11 ldc #1 <String "Lost!!">
13 invokevirtual #15 <Method java.lang.StringBuffer append(java.lang.String)>
16 pop

Le bytecode à des emplacements 0 à 9 est exécuté pour la première ligne de code: 

 StringBuffer str = new StringBuffer("Stanford ");

Le bytecode à l'emplacement 10 à 16 est ensuite exécutée pour la concaténation: 

 str.append("Lost!!");

Notez que, comme cela est le cas dans le premier exemple, ce code appelle la méthode d'ajout d'un objet StringBuffer. Contrairement au premier exemple, cependant, il n'y a pas besoin de créer un StringBuffer temporaire, puis le convertir en un objet String. Ce code ne crée qu'un seul objet, le StringBuffer, à l'emplacement 0.

En conclusion, concaténation StringBuffer est nettement plus rapide que la concaténation String. De toute évidence, StringBuffers doivent être utilisés dans ce type d'opération lorsque cela est possible. Si la fonctionnalité de la classe String est souhaitée, envisagez d'utiliser un StringBuffer pour concaténation puis effectuer une conversion en chaîne.

En imprimant la hashcode de la chaîne / objet StringBuffer après toute opération append prouve également, objet chaîne devient recréés en interne à chaque fois avec de nouvelles valeurs plutôt que d'utiliser le même objet String. 

public class MutableImmutable {

/**
 * @param args
 */
public static void main(String[] args) {
    System.out.println("String is immutable");
    String s = "test";
    System.out.println(s+"::"+s.hashCode());
    for (int i = 0; i < 10; i++) {
        s += "tre";
        System.out.println(s+"::"+s.hashCode());
    }

    System.out.println("String Buffer is mutable");

    StringBuffer strBuf = new StringBuffer("test");
    System.out.println(strBuf+"::"+strBuf.hashCode());
    for (int i = 0; i < 10; i++) {
        strBuf.append("tre");
        System.out.println(strBuf+"::"+strBuf.hashCode());
    }

 }

}

Sortie: Il imprime la valeur de l'objet ainsi que son hashcode 

    String is immutable
    test::3556498
    testtre::-1422435371
    testtretre::-1624680014
    testtretretre::-855723339
    testtretretretre::2071992018
    testtretretretretre::-555654763
    testtretretretretretre::-706970638
    testtretretretretretretre::1157458037
    testtretretretretretretretre::1835043090
    testtretretretretretretretretre::1425065813
    testtretretretretretretretretretre::-1615970766
    String Buffer is mutable
    test::28117098
    testtre::28117098
    testtretre::28117098
    testtretretre::28117098
    testtretretretre::28117098
    testtretretretretre::28117098
    testtretretretretretre::28117098
    testtretretretretretretre::28117098
    testtretretretretretretretre::28117098
    testtretretretretretretretretre::28117098
    testtretretretretretretretretretre::28117098

A StringBuffer ou son plus jeune et plus rapide frère StringBuilder est préférable chaque fois que vous allez faire à beaucoup de concaténations de chaînes dans la saveur de 

string += newString;

ou de manière équivalente 

string = string + newString;

parce que les constructions ci-dessus crée implicitement nouvelle chaîne à chaque fois qui sera une énorme performance et baisse. A StringBuffer / StringBuilder est sous les hottes mieux pour être comparé à un List<Character> dynamiquement expansible.

A String est un tableau de caractères immuable.

A StringBuffer est un tableau de caractères mutable. Souvent reconverti en String lorsque vous avez terminé muter.

Etant donné que les deux sont un réseau, la taille maximale pour les deux est égale à la taille maximale d'un nombre entier qui est 2 ^ 31-1 (voir JavaDoc , vérifiez également la JavaDoc pour les String et StringBuffer) .C'est parce que l'argument de .length un tableau est un int primitive. (Voir tableaux ).

chaîne est immuable, ce qui signifie que lorsque vous effectuez une opération sur une chaîne que vous créez vraiment une nouvelle chaîne entière.

StringBuffer est mutable, et vous peut y ajouter du contenu ainsi que de réinitialiser sa longueur à 0.

Dans la pratique, le compilateur semble utiliser StringBuffer lors de la concaténation chaîne pour des raisons de performance . 

String is immutable.

Pourquoi? Consultez . 

StringBuffer is not. It is thread safe.

D'autres questions comme quand utiliser qui et d'autres concepts peuvent être compris à la suite cette .

Hope this helps.

Je comprends que ce n'est pas un facteur majeur de différenciation, je remarquai aujourd'hui que StringBuffer (et StringBuilder) fournit des méthodes intéressantes cette chaîne ne fonctionne pas.

  • reverse ()
  • setCharAt ()

Les différences sont

  1. Seulement Chaîne class + opérateur est surchargé. Nous pouvons concaténer deux objets String à l'aide + opérateur, mais dans le cas de StringBuffer nous ne pouvons pas.

  2. Chaîne classe est PRÉPONDÉRANTS toString (), est égal à (), hashCode () Objet classe, mais StringBuffer seulement overrides toString (). 

    String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1.equals(s2));  // output true

StringBuffer sb1 = new StringBuffer("abc");
StringBuffer sb2 = new StringBuffer("abc");
System.out.println(sb1.equals(sb2));  // output false

  3. Chaîne classe est à la fois Serializable et Comparable , mais StringBuffer est seulement Serializable . 

    Set<StringBuffer> set = new TreeSet<StringBuffer>();
set.add(sb1);
set.add(sb2);
System.out.println(set);  // gives ClassCastException because there is no Comparison mechanism

  4. Nous pouvons créer un objet String avec et sans nouveau opérateur, mais l'objet StringBuffer ne peut être créée en utilisant nouvel opérateur .

  5. chaîne est immuable, mais StringBuffer est mutable.
  6. StringBuffer est synchronisé, alors que chaîne n'est pas.
  7. StringBuffer est d'avoir une marche arrière () méthode en construction , mais Chaîne dosen't ont.

Performance StringBuffer sage est beaucoup mieux que String; parce que chaque fois que vous appliquez sur concaténation objet Chaîne puis nouvel objet String sont créés sur chaque concaténation.

Règle principale: String sont immuables (non modifiable) et StringBuffer sont mutable (Modifiable)

Voici l'expérience programmatique où vous obtenez la différence de performance 

public class Test {

  public static int LOOP_ITERATION= 100000;

  public static void stringTest(){
    long startTime = System.currentTimeMillis();
    String string = "This";
    for(int i=0;i<LOOP_ITERATION;i++){
        string = string+"Yasir";
    }

    long endTime = System.currentTimeMillis();
    System.out.println(endTime - startTime);    
  }

  public static void stringBufferTest(){
    long startTime = System.currentTimeMillis();
    StringBuffer stringBuffer = new StringBuffer("This");
    for(int i=0;i<LOOP_ITERATION;i++){
        stringBuffer.append("Yasir");
    }

    long endTime = System.currentTimeMillis();
    System.out.println(endTime - startTime);
  }

  public static void main(String []args){
    stringTest()
    stringBufferTest(); 
  }
 }

Sortie de chaîne sont dans ma machine    14800

Sortie de StringBuffer sont dans ma machine   14

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top