Les chaînes sont des objets en Java, alors pourquoi n'utilisons-nous pas «nouveau» pour les créer?

Nous créons normalement des objets en utilisant le newmot - clé, comme:

Object obj = new Object();

Les chaînes sont des objets, mais nous ne les utilisons pas newpour les créer:

String str = "Hello World";

Pourquoi est-ce? Puis-je créer une chaîne avec new?

En plus de ce qui a déjà été dit, les chaînes littérales [c'est-à-dire, les chaînes comme "abcd"mais pas comme new String("abcd")] en Java sont internées - cela signifie que chaque fois que vous faites référence à "abcd", vous obtenez une référence à une seule Stringinstance, plutôt qu'à une nouvelle chaque fois. Vous aurez donc:

String a = "abcd";
String b = "abcd";

a == b; //True

mais si tu avais

String a = new String("abcd");
String b = new String("abcd");

alors il est possible d'avoir

a == b; // False

(et au cas où quelqu'un aurait besoin d'un rappel, utilisez toujours .equals()pour comparer les chaînes; ==teste l'égalité physique).

L'intégration de littéraux String est une bonne chose car ils sont souvent utilisés plus d'une fois. Par exemple, considérez le code (artificiel):

for (int i = 0; i < 10; i++) {
  System.out.println("Next iteration");
}

Si nous n'avions pas d'internement des chaînes, la "prochaine itération" devrait être instanciée 10 fois, alors que maintenant elle ne sera instanciée qu'une seule fois.

Les chaînes sont des objets "spéciaux" en Java. Les concepteurs Java ont judicieusement décidé que les chaînes sont utilisées si souvent qu'ils avaient besoin de leur propre syntaxe ainsi que d'une stratégie de mise en cache. Lorsque vous déclarez une chaîne en disant:

String myString = "something";

myString est une référence à un objet String avec une valeur de "quelque chose". Si vous déclarez plus tard:

String myOtherString = "something";

Java est suffisamment intelligent pour déterminer que myString et myOtherString sont identiques et les stockera dans une table de chaînes globale en tant que même objet. Cela repose sur le fait que vous ne pouvez pas modifier les chaînes pour ce faire. Cela réduit la quantité de mémoire requise et peut accélérer les comparaisons.

Si, à la place, vous écrivez

String myOtherString = new String("something");

Java créera pour vous un tout nouvel objet, distinct de l'objet myString.

String a = "abc"; // 1 Object: "abc" added to pool

String b = "abc"; // 0 Object: because it is already in the pool

String c = new String("abc"); // 1 Object

String d = new String("def"); // 1 Object + "def" is added to the Pool

String e = d.intern(); // (e==d) is "false" because e refers to the String in pool

String f = e.intern(); // (f==e) is "true" 

//Total Objects: 4 ("abc", c, d, "def").

J'espère que cela dissipe quelques doutes. :)

C'est un raccourci. Ce n'était pas comme ça à l'origine, mais Java l'a changé.

Cette FAQ en parle brièvement. Le guide de spécification Java en parle également. Mais je ne peux pas le trouver en ligne.

La chaîne est soumise à quelques optimisations (faute d'une meilleure phrase). Notez que String a également une surcharge d'opérateur (pour l'opérateur +) - contrairement à d'autres objets. C'est donc un cas très spécial.

Nous utilisons généralement des littéraux String pour éviter de créer des objets inutiles. Si nous utilisons un nouvel opérateur pour créer un objet String, il créera un nouvel objet à chaque fois.

Exemple:

String s1=“Hello“;
String s2=“Hello“;
String s3= new String(“Hello“);
String s4= new String(“Hello“);

Pour le code ci-dessus en mémoire:

En Java, les chaînes sont un cas particulier, avec de nombreuses règles qui ne s'appliquent qu'aux chaînes. Les guillemets doubles obligent le compilateur à créer un objet String. Étant donné que les objets String sont immuables, cela permet au compilateur d'interner plusieurs chaînes et de créer un pool de chaînes plus grand. Deux constantes String identiques auront toujours la même référence d'objet. Si vous ne voulez pas que ce soit le cas, vous pouvez utiliser le nouveau String (""), et cela créera un objet String au moment de l'exécution. La méthode intern () était autrefois courante, pour que les chaînes créées dynamiquement soient vérifiées par rapport à la table de recherche de chaînes. Une fois qu'une chaîne est internée, la référence d'objet pointe vers l'instance de chaîne canonique.

    String a = "foo";
    String b = "foo";
    System.out.println(a == b); // true
    String c = new String(a);
    System.out.println(a == c); // false
    c = c.intern();
    System.out.println(a == c); // true

Lorsque le chargeur de classe charge une classe, toutes les constantes String sont ajoutées au pool String.

Sucre syntaxique. le

String s = new String("ABC");

la syntaxe est toujours disponible.

Vous pouvez toujours utiliser new String("string"), mais il serait plus difficile de créer de nouvelles chaînes sans littéraux de chaîne ... vous devrez utiliser des tableaux de caractères ou des octets :-) Les littéraux de chaîne ont une propriété supplémentaire: tous les mêmes littéraux de chaîne de n'importe quelle classe pointent vers la même chaîne instance (ils sont internés).

Il n'est presque pas nécessaire de créer une nouvelle chaîne car le littéral (les caractères entre guillemets) est déjà un objet String créé lorsque la classe hôte est chargée. Il est parfaitement légal d'invoquer des méthodes sur un littéral et don, la principale distinction est la commodité fournie par les littéraux. Ce serait une douleur et un gaspillage majeurs si nous devions créer un tableau de caractères et le remplir char par char et faire un nouveau String (char array).

N'hésitez pas à créer une nouvelle chaîne avec

String s = new String("I'm a new String");

La notation habituelle s = "new String";est plus ou moins un raccourci pratique - qui devrait être utilisé pour des raisons de performances, sauf dans les cas assez rares, où vous avez vraiment besoin de chaînes qui se qualifient pour l'équation

(string1.equals(string2)) && !(string1 == string2)

ÉDITER

En réponse au commentaire: il ne s'agissait pas d'un conseil, mais simplement d'une réponse directe à la thèse des questionneurs, à savoir que nous n'utilisons pas le mot-clé «nouveau» pour les chaînes, ce qui n'est tout simplement pas vrai. J'espère que cette modification (y compris celle ci-dessus) clarifie un peu cela. BTW - il y a quelques bonnes et bien meilleures réponses à la question ci-dessus sur SO.

Le pool littéral contient toutes les chaînes créées sans utiliser le mot clé new.

Il y a une différence: la chaîne sans nouvelle référence est stockée dans le pool littéral de chaîne et la chaîne avec new indique qu'elles sont dans la mémoire du tas.

Les chaînes avec new sont ailleurs en mémoire, comme n'importe quel autre objet.

Parce que String est une classe immuable dans java.

Maintenant, pourquoi est-il immuable? Comme String est immuable, il peut être partagé entre plusieurs threads et nous n'avons pas besoin de synchroniser l'opération String en externe. As String est également utilisé dans le mécanisme de chargement de classe. Donc, si String était mutable, java.io.writer aurait pu être changé en abc.xyz.mywriter

TString obj1 = new TString("Jan Peter");                
TString obj2 = new TString("Jan Peter");                    

if (obj1.Name == obj2.Name)                 
    System.out.println("True");
else                
    System.out.println("False");

Production:

Vrai

J'ai créé deux objets séparés, tous deux ont un champ (ref) 'Nom'. Donc même dans ce cas "Jan Peter" est partagé, si je comprends bien la façon dont java traite ..

Eh bien, le StringPool est implémenté en utilisant The Hashmap en java. Si nous créons toujours avec un nouveau mot-clé, il ne recherche pas dans le pool de chaînes et ne crée pas une nouvelle mémoire pour celui-ci, ce qui pourrait être nécessaire plus tard si une opération gourmande en mémoire est en cours d'exécution et si nous créons toutes les chaînes avec un nouveau mot-clé qui affecterait les performances de notre application. Il est donc conseillé de ne pas utiliser de nouveaux mots-clés pour créer une chaîne, car alors seulement il ira au pool de chaînes qui à son tour est un Hashmap, (mémoire enregistrée, imaginez si nous avons beaucoup de chaînes créées avec un nouveau mot-clé) ici, il sera stocké et si la chaîne existe déjà, sa référence (qui résiderait généralement dans la mémoire de la pile) serait renvoyée à la chaîne nouvellement créée. C'est donc fait pour améliorer les performances.