Combien d'objets string en Java?

Question

Mon ami m'a envoyé une question qu'il a vu dans un simulacre d'examen pour la certification Java sur des objets de chaîne:

String makeStrings(){
    String s = "HI";
    s = s + "5";
    s = s.substring(0,1);
    s = s.toLowerCase();
    return s.toString();
}

Combien d'objets string sera créé lorsque cette méthode est invoquée? Le bon de répondre à l'examen a donné était de 3. Mais je pense que c'est cinq.

1. "SALUT"
2. "5"
3. "HI5"
4. "H"
5. "h"

Suis-je tort?

Answer 1

String makeStrings() {
    String s = "HI";           //String literal
    s = s + "5";               //concatenation creates new String object (1)
    s = s.substring(0,1);      //creates new String object (2)
    s = s.toLowerCase();       //creates new String object (3)
    return s.toString();       //returns already defined String
}

À l'égard de la concaténation, lors de la création d'une nouvelle Chaîne,JVM utilise StringBuilder, c'est à dire:

s = new StringBuilder(s).append("5").toString(); 

toString() d'un StringBuilder est:

public String toString() {
    return new String(value, 0, count); //so a new String is created
}

substring crée un nouvel objet String à moins que l'ensemble de l' String est indexé:

public String substring(int beginIndex, int endIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    if (endIndex > count) {
        throw new StringIndexOutOfBoundsException(endIndex);
    }
    if (beginIndex > endIndex) {
        throw new StringIndexOutOfBoundsException(endIndex - beginIndex)
    }

    return ((beginIndex == 0) && (endIndex == count)) ? this :
           new String(offset + beginIndex, endIndex - beginIndex, value);
}

toString() ne PAS créer une nouvelle Chaîne:

public String toString()
{
   return this;
}

toLowerCase() est une bonne méthode, mais il suffit de dire que si l' String est pas déjà en minuscules, il sera de retour un new String.

Étant donné que la condition de réponse est - 3, comme Jon Skeet suggéré, on peut supposer que les deux littéraux de Chaîne sont déjà dans la Chaîne de la piscine. Pour plus d'informations sur les Chaînes de caractères sont ajoutés à la piscine, voir des Questions à propos de Java dans la Chaîne de la piscine.

Answer 2

s = s + "5";

Traduit de:

String s = new StringBuilder(s).append("5").toString();

Pour l'instant, un Objet est créé.

---

s = s.substring(0,1); 

Crée une nouvelle Chaîne.

---

s = s.toLowerCase();

Crée un nouvel Objet.

---

return s.toString(); 

Ne pas créer une Chaîne, il renvoie un déjà créé une.

Answer 3

Certains des autres réponses ne font sens, mais que dire de la chaîne de caractères littérale?

String s = "HI";

Pour les littéraux de chaîne, quand un .fichier java est compilé en un .fichier de classe, tous les littéraux de chaîne sont notés d'une manière spéciale, comme toutes les constantes sont. Quand une classe est chargée (notez que le chargement se produit avant l'initialisation), la JVM va par le code de la classe et de la recherche des chaînes.

Quand il en trouve un, il vérifie si une Chaîne équivalente est déjà référencé dans le tas. Si pas, il crée une instance de Chaîne sur le tas et stocke une référence à l'objet dans la table de constantes

Une fois qu'une référence est faite à la chaîne de l'objet, toutes les références à cette chaîne littérale tout au long de votre programme sont tout simplement remplacée par la référence à l'objet référencé à partir de la chaîne de caractères littérale de la piscine.

Donc il devrait y avoir quatre objets Java, bien que lorsque la même méthode est appelée, encore et encore, alors il n'y aurait que trois objets que dans l'application de la chaîne de caractères littérale de la piscine contient le littéral "HI".

Aussi, pour plus d'informations sur le pourquoi de nouveaux objets sont créés lorsque la méthode ci-dessus, les blocs sont exécutée, nous pouvons également vérifier le hash codes qui sont différentes pour différentes chaînes (String d'être immuable.)

  public static void main(String[] args)
  {
      NumberOfString str = new NumberOfString();
      String s = str.makeStrings();
      System.out.println(s.hashCode());
  }

  public String makeStrings()
  {
      String s = "HI";
      System.out.println(s.hashCode());
      s = s + "5";
      System.out.println(s.hashCode());
      s = s.substring(0, 1);
      System.out.println(s.hashCode());
      s = s.toLowerCase();
      System.out.println(s.hashCode());
      return s.toString();
  }

Vous obtenez le résultat suivant:

2305
71508
72
104
104

Ne devrions-nous pas compter dans la Chaîne de caractères littérale de l'objet dans l'exemple ci-dessus?