Comment une chaîne peut-elle être initialisée avec «»?

Si String est une classe comme une autre, comment peut-elle être initialisée à l'aide de guillemets doubles?

La chaîne Java est spéciale

Les concepteurs de Java ont décidé de conserver les types primitifs dans un langage orienté objet, au lieu de faire de tout un objet, afin d'améliorer les performances du langage. Les primitives sont stockées dans la pile d'appels, qui nécessitent moins d'espaces de stockage et sont moins coûteuses à manipuler. D'autre part, les objets sont stockés dans le tas de programme, ce qui nécessite une gestion de la mémoire complexe et plus d'espaces de stockage.

Pour des raisons de performances, la chaîne Java est conçue pour se situer entre une primitive et une classe.

Par exemple

String s1 = "Hello";              // String literal
String s2 = "Hello";              // String literal
String s3 = s1;                   // same reference
String s4 = new String("Hello");  // String object
String s5 = new String("Hello");  // String object

Remarque: les littéraux de chaîne sont stockés dans un pool commun. Cela facilite le partage du stockage pour les chaînes avec le même contenu pour économiser le stockage. Stringles objets alloués via un nouvel opérateur sont stockés dans le heap, et il n'y a pas de partage de stockage pour le même contenu.

Java traite String comme une classe spéciale, vous pouvez l'initialiser des deux manières

1. Attribuer directement un littéral

   String a = "adsasdf";

2. Comme d'autres objets utilisant un nouveau mot-clé

   String a = new String("adsasdf");

Vous devez faire particulièrement attention lorsque vous souhaitez comparer avec le ==signe:

String a = "asdf";
String b = "asdf";
System.out.println(a == b);  // True
System.out.println(a.equals(b)); // True

String a = new String("asdf");
String b = new String("asdf");
System.out.println(a == b);  // False
System.out.println(a.equals(b)); // True

C'est parce que dans le premier cas, les objets a et b sont conservés dans quelque chose appelé literal poolet ils font tous les deux référence au même objet, ils sont donc égaux dans les deux sens.

Mais dans le second cas, a et b font référence à différents objets, comme lorsque nous initialisons d'autres objets. ils sont donc inégaux par rapport à l' ==opérateur alors qu'ils sont égaux en valeurs.

La chaîne reçoit un traitement spécial dans le JLS: c'est l'un des deux types non primitifs pour lesquels des littéraux existent (l'autre est Class) ^* .

Depuis le JLS :

Un littéral de chaîne est une référence à une instance de la classe `String [...].

^{* Eh bien, il y a aussi le "type nul" avec son "littéral nul" null, mais la plupart des gens ne considèrent pas le "type nul" comme un type approprié.}

C'est une fonctionnalité du langage Java. Les chaînes littérales du code source reçoivent un traitement spécial.

La spécification du langage, ici , indique simplement qu'une chaîne littérale est de Stringtype

Le texte entre guillemets doubles crée un Stringobjet littéral .

String myString = "Some text";

Le code ci-dessus crée un Stringobjet, en utilisant des guillemets doubles.

Les chaînes sont très souvent utilisées dans un langage de programmation. Puisque java est orienté objet, une chaîne est un objet. Pour éviter la nouvelle chaîne lourde ("someString"); chaque fois que vous avez besoin d'un objet string java vous permet de créer simplement un objet string en utilisant le littéral string.

Mais vous devez garder à l'esprit l'égalité des chaînes. Voici un court test JUnit pour démontrer ce que je veux dire.

    @Test
    public void stringTest() {
       // a string literal and a string object created 
       // with the same literal are equal
       assertEquals("string", new String("string"));

       // two string literals are the same string object
       assertSame("string", "string"); 

       // a string literal is not the same object instance 
       // as a string object created with the same string literal
       assertFalse("string" == new String("string"));

       // java's String.intern() method gives you the same
       // string object reference for all strings that are equal.
       assertSame("string", new String("string").intern());
    }

Juste pour mentionner. Un littéral de chaîne est une référence à une instance de la classe String, vous pouvez écrire du code comme ceci:

 "abc" .getBytes ();

 "a: b: c" .split (":");

 "愛" .codePointAt (0);

- String est une classe en Java . Vous avez raison, nous pouvons donc toujours initialiser avec le newmot - clé.

- Mais quand on fait quelque chose comme:

String s = "";

L'instruction ci-dessus est marquée par le compilateur comme étant un objet String spécial , puis JVM pendant le chargement de la classe (le chargement est effectué avant l'initialisation), voit cela ce que l'on appelle un littéral de chaîne , qui est stocké dans un pool de littéraux de chaîne .

- Ainsi, une chaîne peut être créée en utilisant new()et par la ""méthode, mais cette dernière fournit un littéral de chaîne qui reste dans le tas même s'il n'y a pas de référence à cet objet de chaîne, car il a une référence du pool de littéraux de chaîne.

Java effectue un processus en deux étapes pour nous.

String str = "hello";

est équivalent à

char data[] = {'h', 'e', 'l' , 'l', 'o'};
String str = new String(data);

Comme [.NET] [1] a une chose similaire.

String(Char[]) constructor

Est-ce que

String(char[] value)

Ajout de références: -

• http://docs.oracle.com/javase/6/docs/api/java/lang/String.html
• http://msdn.microsoft.com/en-us/library/system.string.aspx

Java.lang.Stringn'est pas qu'une classe. Cela fait partie intégrante du langage de base. Le compilateur a du sucre syntaxique pour cela. Par exemple, ""est comme une abréviation pour new String(""). Lorsqu'il est écrit, ""le compilateur optimise des chaînes identiques sur la même instance pour économiser de l'espace."a" + 5 == "a5" ==> true

Le compilateur a du sucre syntaxique pour beaucoup de choses, y compris ne pas avoir à boxer / déballer entre les versions d'objet et leurs types natifs, pas de parent signifie Object, constructeur par défaut, ...