Les problèmes comparatifs en Java sont très basiques et faciles à confondre. Aujourd'hui, je vais résumer et organiser un résumé et un arrangement plus détaillés de quelques points sujets aux erreurs, en espérant que cela sera utile pour l'étude et l'entretien de chacun.
1. La différence entre == et égal ()
Tout d'abord, nous devons connaître la différence entre == et equals (). Le signe == est toujours comparé à la valeur d'adresse. Pour les types de données de base, la comparaison == est en fait de savoir si les valeurs variables sont égales, tandis que pour les types de données de référence, la valeur d'adresse est comparée. Ce dont vous avez besoin pour prêter une attention particulière ici, c'est le type de chaîne, qui est facile à prendre pour acquis == et est facile à faire des erreurs. La méthode equals () est une méthode dans la classe d'objets. Nous savons que toutes les classes de Java hériteront de la classe d'objets par défaut, donc les objets de classe auront la méthode equals (). La méthode equals () dans la classe d'objets est indiquée dans la figure ci-dessous:
Comme le montre le code source, la couche sous-jacente de la méthode equals () dans la classe d'objets utilise également ==, donc c'est en fait la valeur d'adresse. Donc, si nous voulons utiliser la méthode equals () pour d'autres comparaisons, nous devons remplacer la méthode equals ().
2. Types de données de base et types d'emballage
Nous savons tous que l'octet, court, int, long, booléen, char, double et float sont des types de données de base, et les variables qu'ils déclarent sont stockées dans la mémoire de la pile. Les variables définies par leurs types d'emballage correspondants (octet, court, entier, long, booléen, caractère, double) existent dans la mémoire du tas. Pour les types de données de base, leur comparaison est relativement simple, c'est-à-dire utiliser == pour déterminer s'ils sont égaux et utiliser <,>, <=,> = pour comparer les tailles. Mais pour les types d'emballage, c'est un peu différent.
Premièrement, pour déterminer s'il est égal, voir le résultat d'exécution du code suivant:
Package DailyTest; import org.junit.test; / ** * Résumé comparatif en java * @author yrr * / public class javacomparetest {/ ** * Le jugement de type entier est égal * / @test public void test01 () {int n3 = 48; System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- n8); System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.Println (n1.intvalue () == N2.IntValue (); N6); NullPointException} / ** * Le jugement de type long est égal * / @Test public void test02 () {// notez ici que lorsque vous utilisez une définition longue, L ou L n'est pas requise, mais lors de l'utilisation longue, sinon une erreur sera signalée // l'ajouter dans la construction pour indiquer la différence Long N3 = 48L; System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- N1); System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System. // Lorsque vous utilisez la méthode long.intvalue (), vous devez faire attention pour vérifier s'il est nul pour empêcher NullPointException}}Pour les résultats d'exécution ci-dessus, l'explication suivante est faite:
Tout d'abord, pour la nouvelle méthode, nous déclarons un entier ou un objet long. Étant donné que le nouvel objet ouvre un morceau d'espace dans le tas, même si les valeurs des deux sont les mêmes, pour ==, la valeur d'adresse est comparée, donc FALSE sera renvoyé. Pour les classes en wrapper de types de données de base, la méthode equals () a été réécrite et la taille numérique sera comparée, de sorte que la méthode equals () peut être utilisée pour juger en fonction de la taille numérique. En ce qui concerne le problème de la comparaison des variables entières avec les variables int, nous constaterons que la valeur de comparaison est également basée sur la taille numérique. En effet, lors de la comparaison, le type entier est automatiquement déballé et converti en type int. L'explication des trois premiers points s'applique à tous les types d'emballages. Pour la méthode d'attribution directe, les deux variables entières avec une valeur de 48 sont jugées vraies par le signe ==, mais lorsque la valeur est 128, elle est fausse. En effet, en bas, pour entier n1 = 48;, la méthode d'attribution directe appelle réellement la méthode Integer.Value (). Nous pouvons jeter un bref aperçu du code source de la méthode Integer.Value (), comme indiqué dans la figure ci-dessous:
Nous pouvons voir qu'il y a un s'il y a un jugement ici. Lorsque l'entrée I est dans la plage de [-128, 127], elle est renvoyée directement à partir du tableau IntegerCache. Par conséquent, pour les valeurs de cette plage, les valeurs d'adresse correspondant à ce tableau sont renvoyées, donc en utilisant le signe == pour juger True sera retourné. Ce qui n'est pas dans cette plage, c'est l'objet nouveau, donc faux sera renvoyé. Cette conclusion est vraie pour les types d'octets, courts, entiers et longs (si vous êtes intéressé, vous pouvez vérifier le code source de leur méthode de valeur () correspondante), car la portée du type d'octet est [-128, 127], donc pour le type d'octet, l'utilisation == n'est pas différente d'Equals ().
Pour la comparaison des tailles, il n'y a pas de problème à utiliser>, <, <=,> =, et ils seront automatiquement débilés. Mais nous recommandons généralement d'utiliser les deux façons suivantes de comparer les tailles:
Appelez la méthode xxxValue () pour la convertir en type de données de base pour la comparaison. Dans la classe de wrapper, la méthode compareto () est réécrite. En regardant le code source compareto (), vous pouvez voir qu'en fait, l'utilisation sous-jacente est également convertie en type de données de base correspondant en déballant automatiquement puis en le comparant.
2. Comparaison des objets Java
Avec l'introduction ci-dessus, il est plus facile de comparer les objets. Les principes sont les mêmes.
1. Comparaison des types de chaînes
Il convient de noter que le type de chaîne ne peut pas être utilisé directement>, <=,> =, et <, et rapportera une exception de compilation.
Package DailyTest; import org.junit.test; / ** * Résumé comparatif dans java * @author yrr * / public class javacompareTest {@test public void test03 () {String s1 = new String ("123"); String s2 = new String ("123"); System.out.println (S1 == S2); // false System.out.println (s1.equals (s2)); String S3 = "234"; String S4 = "234"; System.out.println (S3 == S4); // true System.out.println (S3.Equals (S4)); // true //system.out.println(s1 <= s3); // L'opérateur <n'est pas défini pour le type d'argument Java.lang.string, java.lang.string System.out.println (s1.compareto (S3) <0); //vrai }}2. Comparaison des objets de classe
La conclusion des objets de classe est la même, mais par rapport aux types de données de base et aux types de chaînes, il est un peu plus compliqué.
Selon une certaine règle, pour déterminer si les deux objets sont égaux, la méthode equals () doit être réécrite dans la classe jugée. L'exemple de code est le suivant:
Package DailyTest; import org.junit.test; / ** * Résumé comparatif dans java * @author yrr * / public class javacomparetest {@test public void test04 () {personne p1 = new personne ("yrr", 18); Personne P2 = nouvelle personne ("YRR", 18); System.out.println (P1 == P2); // false System.out.println (p2.Equals (p1)); // true}} classe de classe {nom de chaîne privée; Âge entier privé; Public Person () {} Person public (nom de chaîne, âge entier) {this.name = name; this.age = âge; } public String getName () {Nom de retour; } public Integer Getage () {Return Age; } @Override public booléen égaux (objet obj) {personne personne = (personne) obj; retour name.equals (personne.getName ()) && age.equals (personne.getage ()); }}Et si vous souhaitez comparer les tailles de deux objets (c'est aussi une question d'entrevue courante), il y a deux façons:
La classe comparable implémente l'interface comparable et remplace la méthode compareto () pour définir la classe qui implémente une interface de comparaison ou utiliser la classe interne pour remplacer la méthode compare (): le premier est défini sur la classe comparable, tandis que le second est défini en dehors de la classe comparable. Grâce à cette différence, les avantages et les inconvénients des deux sont également évidents. Le premier est simple, mais nécessite une modification de la classe comparée, tandis que le second n'a pas besoin de modifier le code d'origine, ce qui est plus flexible.
La première méthode, l'exemple de code est le suivant:
Package DailyTest; import org.junit.test; / ** * Résumé comparatif dans java * @author yrr * / public class JavacompareTest {@test public void test5 () {personne p1 = new personne ("yrr", 18); Personne P2 = nouvelle personne ("WX", 19); System.out.println (p1.compareto (p2) <0); }} La personne de classe implémente le nom de la chaîne PRIMATIVE <Person> {le nom de chaîne privée; Âge entier privé; Public Person () {} Person public (nom de chaîne, âge entier) {this.name = name; this.age = âge; } public Integer Getage () {Return Age; } @Override public int compareto (personne o) {return this.getage () - o.getage (); }}La deuxième méthode, l'exemple de code est le suivant:
Package Comparator; Importer java.util.arrays; import java.util.comparator; public class myComparator {public static void main (String [] args) {user [] users = nouvel utilisateur [] {nouvel utilisateur ("U1001", 25), nouvel utilisateur ("U1002", 20), nouvel utilisateur ("U1003", 21)}; Arrays.sort (utilisateurs, nouveau comparateur <server> () {@Override public int compare (utilisateur o1, utilisateur o2) {return o1.getage () - o2.getage ();}}); for (int i = 0; i <users.length; i ++) {utilisateur utilisateur = utilisateurs [i]; System.out.println (user.getId () + "" + user.getage ()); }}} classe utilisateur {ID de chaîne privée; Âge privé; Utilisateur public (String id, int Age) {this.id = id; this.age = âge; } public int getage () {return âge; } public void Setage (int Age) {this.age = age; } public String getID () {return id; } public void setid (String id) {this.id = id; }}Ce qui précède est le contenu pertinent des questions de comparaison Java que je vous ai dit cette fois. Si vous avez d'autres questions, vous pouvez en discuter dans la zone de commentaires ci-dessous. Merci pour votre soutien.