Quelle est la différence entre Ssortingng et SsortingngBuffer en Java?

Quelle est la différence entre Ssortingng et SsortingngBuffer en Java?

Y a-t-il une taille maximale pour Ssortingng?

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

SsortingngBuffer est utilisé pour représenter des caractères pouvant être modifiés.

En SsortingngBuffer performances, SsortingngBuffer est plus rapide lors des concaténations. En effet, lorsque vous concaténez une Ssortingng , vous créez un nouvel object (en interne) chaque fois que Ssortingng est immuable.

Vous pouvez également utiliser SsortingngBuilder qui est similaire à SsortingngBuffer sauf qu’il n’est pas synchronisé. La taille maximale de l’un ou l’autre est Integer.MAX_VALUE (2 31 – 1 = 2 147 483 647) ou la taille maximale du Integer.MAX_VALUE divisée par 2 (voir Combien de caractères peut avoir une chaîne Java? ). Plus d’informations ici .

Une Ssortingng est immuable, c’est-à-dire que lorsqu’elle est créée, elle ne peut jamais changer.

Un SsortingngBuffer (ou son cousin non synchronisé SsortingngBuilder ) est utilisé lorsque vous avez besoin de construire une chaîne pièce par pièce sans avoir à passer par la construction de petites Ssortingng .

La longueur maximale pour les deux est Integer.MAX_VALUE, car ils sont stockés en interne en tant que tableaux, et les tableaux Java ont uniquement un int pour leur pseudo-champ de longueur.

L’amélioration des performances entre Ssortingng s et SsortingngBuffer pour la concaténation multiple est assez significative. Si vous exécutez le code de test suivant, vous verrez la différence. Sur mon ancien ordinateur portable avec Java 6, je reçois ces résultats:

 Concat avec Ssortingng a pris: 1781ms
 Concat avec SsortingngBuffer a pris: 0ms
 public class Concat { public static Ssortingng concatWithSsortingng() { Ssortingng 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"); } } 
 Ssortingng SsortingngBuffer Immutable Mutable Ssortingng s=new Ssortingng("karthik"); SsortingngBuffer sb=new SsortingngBuffer("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 Ssortingng object ---->once we created a SsortingngBuffer 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 Ssortingng object Use Ssortingng--->If you require immutabilty Use SsortingngBuffer---->If you require mutable + threadsafety Use SsortingngBuilder--->If you require mutable + with out threadsafety Ssortingng s=new Ssortingng("karthik"); --->here 2 objects will be created one is heap and the other is in ssortingngconstantpool(scp) and s is always pointing to heap object Ssortingng s="karthik"; --->In this case only one object will be created in scp and s is always pointing to that object only 

Ssortingng est une classe immuable. Cela signifie qu’une fois que vous instanciez une instance d’une chaîne comme ceci:

 Ssortingng str1 = "hello"; 

L’object en mémoire ne peut pas être modifié. Au lieu de cela, vous devrez créer une nouvelle instance, copier l’ancienne chaîne et append tout ce que vous voulez dans cet exemple:

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

Ce qui se passe réellement, c’est que nous ne mettons PAS à jour l’object str1 existant … nous réaffectons de la mémoire tous ensemble, en copiant les données “hello” et en ajoutant “world!” jusqu’à la fin, puis configure la référence str1 pour qu’elle pointe vers cette nouvelle mémoire. Donc ça ressemble vraiment plus à ça sous le capot:

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

Il s’ensuit que ce processus “copier + coller et déplacer des trucs en mémoire” peut être très coûteux s’il est fait de manière répétitive, en particulier de manière récursive.

Lorsque vous êtes dans cette situation de devoir faire des choses encore et encore, utilisez SsortingngBuilder. Il est modifiable et peut append des chaînes à la fin de la liste courante car il est renvoyé par un [tableau croissant] (et non pas à 100% s’il s’agit de la structure de données réelle, pourrait être une liste).

De l’ API:

Une séquence de caractères modifiable en toute sécurité. Un tampon de chaîne est comme une chaîne, mais peut être modifié. À tout moment, il contient une séquence de caractères particulière, mais la longueur et le contenu de la séquence peuvent être modifiés via certains appels de méthode.

Un SsortingngBuffer est utilisé pour créer une chaîne unique à partir de nombreuses chaînes, par exemple lorsque vous souhaitez append des parties d’une chaîne dans une boucle.

Vous devez utiliser un SsortingngBuilder au lieu d’un SsortingngBuffer lorsque vous n’avez qu’un seul Thread accédant à SsortingngBuffer, puisque SsortingngBuilder n’est pas synchronisé et donc plus rapide.

AFAIK il n’y a pas de limite supérieure pour la taille de la chaîne en Java en tant que langage, mais les JVM ont probablement une limite supérieure.

J’ai trouvé une réponse intéressante pour comparer les performances Ssortingng vs SsortingngBuffer par Reggie Hutcherso Source : http://www.javaworld.com/javaworld/jw-03-2000/jw-0324-javaperf.html

Java fournit les classes SsortingngBuffer et Ssortingng, et la classe Ssortingng est utilisée pour manipuler des chaînes de caractères qui ne peuvent pas être modifiées. En termes simples, les objects de type Ssortingng sont en lecture seule et immuables. La classe SsortingngBuffer est utilisée pour représenter des caractères pouvant être modifiés.

La différence de performance significative entre ces deux classes est que SsortingngBuffer est plus rapide que Ssortingng lors de la réalisation de concaténations simples. Dans le code de manipulation de chaînes, les chaînes de caractères sont systématiquement concaténées. En utilisant la classe Ssortingng, les concaténations sont généralement effectuées comme suit:

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

Si vous deviez utiliser SsortingngBuffer pour effectuer la même concaténation, vous auriez besoin du code suivant:

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

Les développeurs supposent généralement que le premier exemple ci-dessus est plus efficace car 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 objects Ssortingng.

L’opérateur + semble innocent, mais le code généré génère des sursockets. L’utilisation d’un SsortingngBuffer pour la concaténation peut en fait produire un code beaucoup plus rapide que l’utilisation d’une chaîne. Pour découvrir pourquoi c’est le cas, nous devons examiner le bytecode généré à partir de nos deux exemples. Le bytecode de l’exemple utilisant Ssortingng ressemble à ceci:

 0 new #7  3 dup 4 ldc #2  6 invokespecial #12  9 astore_1 10 new #8  13 dup 14 aload_1 15 invokestatic #23  18 invokespecial #13  21 ldc #1  23 invokevirtual #15  26 invokevirtual #22  29 astore_1 

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

  Ssortingng str = new Ssortingng("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 object SsortingngBuffer, puis appelle sa méthode append: l’object SsortingngBuffer temporaire est créé à l’emplacement 10 et sa méthode append est appelée à l’emplacement 23. La classe Ssortingng étant immuable, un object SsortingngBuffer doit être utilisé pour enchaînement.

Une fois la concaténation effectuée sur l’object SsortingngBuffer, il doit être reconverti en chaîne. Cela se fait avec l’appel à la méthode toSsortingng à l’emplacement 26. Cette méthode crée un nouvel object Ssortingng à partir de l’object SsortingngBuffer temporaire. La création de cet object SsortingngBuffer temporaire et sa conversion ultérieure en object Ssortingng sont très coûteuses.

En résumé, les deux lignes de code ci-dessus entraînent la création de trois objects:

  1. Un object Ssortingng à l’emplacement 0
  2. Un object SsortingngBuffer à l’emplacement 10
  3. Un object Ssortingng à l’emplacement 26

Maintenant, regardons le bytecode généré pour l’exemple utilisant SsortingngBuffer:

 0 new #8  3 dup 4 ldc #2  6 invokespecial #13  9 astore_1 10 aload_1 11 ldc #1  13 invokevirtual #15  16 pop 

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

  SsortingngBuffer str = new SsortingngBuffer("Stanford "); 

Le bytecode à l’emplacement 10 à 16 est alors exécuté pour la concaténation:

  str.append("Lost!!"); 

Notez que, comme c’est le cas dans le premier exemple, ce code appelle la méthode append d’un object SsortingngBuffer. Contrairement au premier exemple, il n’est pas nécessaire de créer un SsortingngBuffer temporaire, puis de le convertir en object Ssortingng. Ce code crée un seul object, le SsortingngBuffer, à l’emplacement 0.

En conclusion, la concaténation SsortingngBuffer est nettement plus rapide que la concaténation Ssortingng. De toute évidence, SsortingngBuffers doit être utilisé dans ce type d’opération lorsque cela est possible. Si la fonctionnalité de la classe Ssortingng est souhaitée, envisagez d’utiliser un SsortingngBuffer pour la concaténation, puis d’effectuer une conversion en Ssortingng.

Un SsortingngBuffer ou son frère plus jeune et plus rapide, SsortingngBuilder est préférable lorsque vous faites beaucoup de concaténations de chaînes en fonction de la

 ssortingng += newSsortingng; 

ou équivalent

 ssortingng = ssortingng + newSsortingng; 

car les constructions ci-dessus créent implicitement une nouvelle chaîne à chaque fois, ce qui sera une énorme perte de performance. Un SsortingngBuffer / SsortingngBuilder doit être comparé à une List expansible de manière dynamic.

Une Ssortingng est un tableau de caractères immuable.

Un SsortingngBuffer est un tableau de caractères mutable. Souvent reconverti en Ssortingng fin de mutation.

Comme les deux sont un tableau, la taille maximale pour les deux est égale à la taille maximale d’un entier, qui est 2 ^ 31-1 (voir JavaDoc , consultez également le JavaDoc à la fois pour Ssortingng et SsortingngBuffer ). l’argument d’un tableau est une primitive int . (Voir tableaux ).

Ssortingng est immuable, ce qui signifie que lorsque vous effectuez une opération sur une chaîne, vous créez réellement une nouvelle chaîne.

SsortingngBuffer est mutable et vous pouvez y append une valeur ainsi que sa longueur à 0.

En pratique, le compilateur semble utiliser SsortingngBuffer lors de la concaténation de chaînes pour des raisons de performances .

 Ssortingng is immutable. 

Pourquoi? Vérifiez ici .

 SsortingngBuffer is not. It is thread safe. 

Suite à cela, d’autres questions, comme quand utiliser quel ou d’autres concepts, peuvent être trouvées.

J’espère que cela t’aides.

Bien que je comprenne que ce n’est pas un facteur de différenciation majeur, j’ai remarqué aujourd’hui que SsortingngBuffer (et SsortingngBuilder) fournit des méthodes intéressantes que Ssortingng ne permet pas.

  • sens inverse()
  • setCharAt ()

En imprimant le code de hachage de l’object Ssortingng / SsortingngBuffer après toute opération d’ajout, l’object object Ssortingng est recréé en interne à chaque fois avec de nouvelles valeurs plutôt que d’utiliser le même object Ssortingng.

 public class MutableImmutable { /** * @param args */ public static void main(Ssortingng[] args) { System.out.println("Ssortingng is immutable"); Ssortingng 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()); } } } 

Output: Affiche la valeur de l'object avec son hashcode

  Ssortingng is immutable test::3556498 testtre::-1422435371 testtretre::-1624680014 testtretretre::-855723339 testtretretretre::2071992018 testtretretretretre::-555654763 testtretretretretretre::-706970638 testtretretretretretretre::1157458037 testtretretretretretretretre::1835043090 testtretretretretretretretretre::1425065813 testtretretretretretretretretretre::-1615970766 Ssortingng 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 

Les différences sont

  1. Seulement dans Ssortingng class +, l’ opérateur est surchargé. Nous pouvons concaténer deux objects Ssortingng en utilisant l’opérateur + , mais dans le cas de SsortingngBuffer, nous ne pouvons pas.
  2. La classe Ssortingng remplace toSsortingng (), equals (), hashCode () de la classe Object , mais SsortingngBuffer ne remplace que toSsortingng ().

     Ssortingng s1 = new Ssortingng("abc"); Ssortingng s2 = new Ssortingng("abc"); System.out.println(s1.equals(s2)); // output true SsortingngBuffer sb1 = new SsortingngBuffer("abc"); SsortingngBuffer sb2 = new SsortingngBuffer("abc"); System.out.println(sb1.equals(sb2)); // output false 
  3. La classe Ssortingng est à la fois Serializable et Comparable , mais SsortingngBuffer est uniquement Serializable .

     Set set = new TreeSet(); set.add(sb1); set.add(sb2); System.out.println(set); // gives ClassCastException because there is no Comparison mechanism 
  4. Nous pouvons créer un object Ssortingng avec et sans nouvel opérateur, mais l’object SsortingngBuffer ne peut être créé qu’à l’aide d’un nouvel opérateur.

  5. La chaîne est immuable, mais SsortingngBuffer est mutable.
  6. SsortingngBuffer est synchronisé, alors que Ssortingng n’est pas.
  7. SsortingngBuffer utilise une méthode reverse () intégrée, mais Ssortingng ne l’a pas.

Sage de performance SsortingngBuffer est bien meilleur que Ssortingng; car chaque fois que vous appliquez une concaténation sur un object Ssortingng, un nouvel object Ssortingng est créé à chaque concaténation.

Règle principale: la chaîne est immuable (non modifiable) et SsortingngBuffer est 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 ssortingngTest(){ long startTime = System.currentTimeMillis(); Ssortingng ssortingng = "This"; for(int i=0;i 

La sortie de la chaîne est dans ma machine 14800

La sortie de SsortingngBuffer est dans ma machine 14