On m'a demandé de prédire la sortie de ce code:
String party1 = "party";
String party2= "PARTY".toLowerCase();
if(party1==party2){
System.out.println("EQUAL");
}else{
System.out.println("NOT EQUAL");
}
Je pensais que le résultat de toLowerCase () serait interné automatiquement et donc la même référence à party1 serait renvoyé, mais je me suis trompé car le code sort "NOT EQUAL" .
toLowerCase () ( toUpperCase () également) renvoie-t-il une nouvelle String ?
Modifier : je n'utilise pas == pour comparer des chaînes, je veux juste connaître le comportement de la méthode toLowerCase ()
4 Réponses :
À ma connaissance sur toutes les opérations sur la chaîne, il dupliquera la chaîne donc n'utilisez jamais '==' à la place utilisez .equals ()
String party1 = "party";
String party2= "PARTY".toLowerCase();
System.out.println(party1);
System.out.println(party2);
if(party1.equals(party2)){
System.out.println("EQUAL");
}else{
System.out.println("NOT EQUAL");
}
Cela a donné le résultat égal
La réponse est dans la méthode String.toLowerCase () elle-même .. comme vous pouvez le vérifier par votre propre méthode toLowerCase () renvoie une nouvelle chaîne en minuscules (un nouvel objet String ) et == vérifie la référence de l'objet et renvoie true si ce sont les mêmes qui sont différents dans votre cas .. c'est pourquoi il renvoie false .. j'espère que vous l'obtiendrez.
public String toLowerCase(Locale locale) {
if (locale == null) {
throw new NullPointerException();
}
........
............
return new String(result, 0, len + resultOffset);
}
Si le résultat d'une opération String était internalisé, le pool croîtrait extrêmement et inutilement rapidement. Toute action intermédiaire sur un Spring entraînerait un nouvel élément dans le pool. Ce serait bénéfique pour un TRÈS petit nombre de cas dans un domaine TRÈS spécifique. Par conséquent, ce n'est pas la politique par défaut et c'est pourquoi intern () existe.
String party1 = "party"; String party2 = "PARTY".toLowerCase().intern(); System.out.println(party1 == party2 ? "EQUAL" : "NOT EQUAL");
Il n'y a rien de spécial à propos de toLowerCase () : tout La méthode String renverrait une nouvelle String car les String sont immuables.
Les chaînes sont immuables. En général, chaque fois que nous essayons de modifier une chaîne, un nouveau littéral de chaîne est créé dans le pool de littéraux constants et une nouvelle référence à celui-ci est retournée. c'est-à-dire parti mais en pool constant, ils se réfèrent à deux littéraux différents et ont deux références différentes. En utilisant l'opérateur == , vous comparez les références et non les valeurs. Comme elles ont des références différentes, il imprime NOT Equal . Essayez avec party1.equals (party2) < / code> et il affichera EQUAL car il compare le contenu et non la référence.
Pourquoi vous attendiez-vous à ce qu'il ne renvoie pas une nouvelle chaîne?
Ne vous fiez jamais, jamais à
==pour la comparaison de chaînes.Copie possible de Comment comparer des chaînes en Java?
"Je pensais que le résultat de toLowerCase () serait automatiquement interné" - Qu'est-ce qui vous a fait penser cela?
@a_horse_with_no_name J'utilise equals () à cette fin, ma question portait sur l'implémentation spécifique de toLowerCase ()
«Je pensais que le résultat de toLowerCase () serait automatiquement interné» Voulez-vous dire que vous pensiez qu'une instance de la chaîne serait renvoyée à partir du pool de chaînes s'il en existe une? Si c'est le cas, non: il n'y a pas de mécanisme (public) pour demander si une chaîne existe dans le pool de chaînes, autrement qu'en appelant
intern ()et en voyant si la même chaîne revient.