Ingénieur Java Akuma-chan @akumachanit Démo! Aujourd'hui, c'est une démo qui parle de comparaison de chaînes!
** Quand parlez-vous ** démo? Akuma-chan était ** en train de développer une application avec JDK 1.6 au travail ** (une démo à laquelle on peut croire à l'époque de Reiwa? Mais c'est une démo à mettre à niveau!), Mais récemment, elle a été mise à jour. Une démo qui vous permet d'utiliser les fonctionnalités de 1.7!
Objects Démo avec Objects dans la classe ajoutée à partir de 1.7. Il semble que 1.7 soit sorti en 2011, donc je pense qu'il y a beaucoup de gens qui lisent ceci et ne sont pas devenus ingénieurs à ce moment-là. Je suis désolé d'en parler maintenant. (Une démo tellement égoïste qui n'était pas ingénieur à l'époque).
Donc, en utilisant la méthode ʻObjects.equals () de ces ʻObjects, j'ai vérifié les spécifications pour le moment, donc la démo que je vais écrire ici.
Une démo écrite dans la spécification «Objets» comme suit.
Cette classe (...) contient des méthodes nulles ou tolérantes à zéro pour comparer deux objets.
En d'autres termes, qu'est-ce que cela signifie?
if(a.equals("test")) { //NullPointerException si a est nul
}
Si vous écrivez un code comme celui-ci, si ʻavautnull, NullPointerExceptioin se produira. Il n'y a pas de méthode ʻequals (ou quoi que ce soit) dans null, donc c'est une démo naturelle.
Dans un tel cas, il était nécessaire de placer la chaîne de caractères en premier ou d'effectuer d'abord la vérification «null».
if("test".equals(a)) { //Absolument NullPointerException ne se produit jamais
}
if(a != null && a.equals("test")) { //Si nul, ignorez le jugement
}
L'exemple ci-dessus ne peut pas être utilisé comme des variables où les deux peuvent être null, et ce n'est pas super beau d'écrire la même chose à chaque fois comme l'exemple ci-dessous!
Objects.equals()
ʻObjects.equals () `!! qui est apparu ici
Objects.equals(a, "test"); //Comme ça
public static boolean equals(Object a, Object b) Renvoie true si les arguments sont égaux les uns aux autres, false dans le cas contraire. Par conséquent, true est renvoyé si les deux arguments sont nuls et false si un seul argument est nul. Sinon, la méthode equals du premier argument est utilisée pour déterminer s'ils sont égaux.
ʻObjects.equals () est une démo qui renvoie truemême si les deux sont nuls! Ceci est une démo qui ne peut pas être faite avec la méthode conventionnelle mentionnée ci-dessus! Eh bien, un ʻObjects.equals ()si pratique, mais que se passe-t-il lorsque vous essayez de comparer des chaînes?
Je pense que tous ceux qui utilisent Java savent que ** les chaînes ne doivent pas être utilisées à des fins de comparaison **! Une démo dont les gens qui ne savaient pas se souviendront certainement et reviendront ici. C'est une démo que vous aurez du mal à utiliser sans le savoir.
Tout d'abord, une démonstration qui examine les spécifications Java pour les opérateurs d'égalité.
15.21. Equality Operators The equality operators may be used to compare two operands that are convertible (§5.1.8) to numeric type, or two operands of type boolean or Boolean, or two operands that are each of either reference type or the null type. All other cases result in a compile-time error.
(Traduction appropriée) Les opérateurs d'équivalence peuvent être utilisés entre «deux opérandes convertibles en type numérique», «entre deux opérandes booléens ou booléens» et «entre des opérandes de type référence ou de type nul». D'autres modèles entraîneront une erreur de compilation.
Puisque String est un type de référence, une démonstration à lire sur la comparaison entre le type de référence et le type null.
15.21.3. Reference Equality Operators == and != At run time, the result of == is true if the operand values are both null or both refer to the same object or array; otherwise, the result is false.
(Traduction appropriée) Au moment de l'exécution, le résultat de == est vrai si les valeurs des deux opérandes sont "toutes deux nulles" ou "toutes deux désignent le même objet ou tableau", sinon faux. ..
En d'autres termes, «==» est une démonstration qui vérifie si les objets référencés sont les mêmes.
Ensuite, une démo pour voir le code qui compare réellement le == de String.
String a = "test";
String b = "test";
System.out.println(a == b); // true
cette? Pas de problème de démo, non? ?? ?? Alors que diriez-vous de cette démo?
String a = "test";
String b = new String("test");
System.out.println(a == b); // false
cette? N'est-ce pas une démonstration que le résultat est «false» après avoir remplacé «new» par «String» par «b»? Alors que diriez-vous de cette démo?
String a = "test";
String b = "te".concat("st");
System.out.println(a == b); // false
C'est aussi une démo qui est devenue "fausse"!
La raison en est qu'en Java ** chaîne littérale ** (une chaîne entre guillemets doubles comme `` test '') ** fait référence à la même instance de type String. ** démo. En d'autres termes, quel que soit le nombre de fois que vous attribuez «test», une référence à la même instance de type «String» sera incluse dans la démo.
Donc, le premier exemple est une démo où quelque chose comme ça se passe en interne.
String x = new String("test");
String a = x;
String b = x;
System.out.println(a == b); // true
Ceci est une démo facile à comprendre! Puisque ʻa et bfont référence àx, c'est une démonstration convaincante que ʻa == b est vrai.
Alors pourquoi n'était-il pas égal dans les deuxième et troisième exemples? Si vous utilisez new String () pour générer une chaîne, cela créera une nouvelle instance même si les valeurs sont les mêmes ** Démo ..
Une démo de concat () aussi en interne en utilisant new String () pour renvoyer une nouvelle chaîne. (Cependant, notez que concat () retourne l'instance d'origine telle qu'elle est si la longueur de la chaîne d'argument est 0.)
Maintenant, c'est une démo où vous ne pouvez pas utiliser == pour comparer des chaînes. La raison est que même si les valeurs de ** String ** à comparer sont les mêmes, il n'y a aucune garantie qu'elles se réfèrent à la même instance ** Demo.
Alors, comment pouvez-vous vérifier des chaînes avec différentes instances et la même valeur? !!
C'est là qu'intervient la démo de la méthode String # equals ()! !! !!
String#equals()
La méthode String # equals () est une démo qui vérifie la valeur de String!
String a = "test";
String b = new String("test");
System.out.println(a.equals(b)); // true
Bien! Ceci est une démo de solution! C'est une démo qui ne nécessite pas d'explication à ce stade.
Pour la comparaison de String ** String # equals ()! !! Ceci est une démo parfaite! !! ** **
La démo qui semble être ... atteint enfin le problème au début ici.
// String#equals()Démos de code disgracieuses avec lesquelles vous devez écrire
if("test".equals(a)) { //Absolument NullPointerException ne se produit jamais
}
if(a != null && a.equals("test")) { //Si nul, ignorez le jugement
}
Hmmmm! La démo à laquelle je suis enfin arrivé! Voici la démo de production!
La démo que j'ai mentionnée au début est que # Objects.equals () checks null, et quand vous comparez nulls, il renvoie true!
String a = null;
String b = null;
Objects.equals(a, b); // true -N'entraîne pas NullPointerException
String a = null;
String b = "test";
Objects.equals(a, b); // false -N'entraîne pas NullPointerException
Donc, une démo qui m'a fait me demander. ** Qu'arrive-t-il aux comparaisons de chaînes? ** **
La raison pour laquelle j'ai pensé à cela est que String # equals () est en fait une démo qui compare des valeurs, mais sa classe parent ʻObjecta ʻObject # equals ()est **. Démonstration comparant ** des instances référencées plutôt que des valeurs. Plus précisément, une démo qui utilise == en interne.
// Object#equals()
public boolean equals(Object obj) {
return (this == obj);
}
String # equals () est une démo qui ** remplace ʻObject # equals () `et réécrit le processus **.
Donc, quand vous connaissez ʻObjects # equals () , il s'appelle ʻObject, donc il se comporte de la même manière que ʻObject # equals`? Je pensais que c'était une démo.
La réponse est la démonstration décrite dans les spécifications de méthode écrites au début.
~ (Omis) Sinon, la méthode equals du premier argument est utilisée pour déterminer s'ils sont égaux.
Une démonstration dans laquelle la ** méthode du premier argument ʻequals ** est spécifiée si les deux arguments ne sont pas null`.
En d'autres termes, si vous passez une valeur de type «String» au premier argument, il comparera les valeurs. Si le premier argument est différent de «String» et le second argument est «String», il est de toute façon faux, donc le contenu de l'argument de la méthode «equals» n'est pas pertinent pour la démonstration.
** Démo utilisant Objects.equals ()! !! !! ** **
Trucs officiels d'oracle et ceci et démos.
Recommended Posts