Résumé et partage de trois façons de comparer les tailles de deux objets en Java

Cet article vous apporte des connaissances pertinentes sur java Les éléments insérés dans la file d'attente prioritaire doivent être de taille comparable. Si la taille ne peut pas être comparée, comme l'insertion de deux éléments de type étudiant, une ClassCastException sera signalée. Ce qui suit présente trois méthodes pour comparer les tailles de deux objets en Java. J'espère que cela sera utile à tout le monde.

Étude recommandée : "Tutoriel vidéo Java"

1. Pourquoi avez-vous besoin de comparer des objets

La section précédente a présenté la file d'attente prioritaire Les éléments insérés dans la file d'attente prioritaire doivent être de taille comparable. ils ne peuvent pas être comparés, Taille, si deux éléments de type étudiant sont insérés, une ClassCastException sera signalée

Exemple :

class Student{
    String name;
    int age;
 
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("张三",25);
        Student s2 = new Student("李四",31);
        PriorityQueue<Student> p = new PriorityQueue<>();
        p.offer(s1);
        p.offer(s2);
    }
}

Résultat :

Cause : Parce que la couche inférieure de la file d'attente prioritaire utilise une structure de données en tas , lors de l'insertion d'éléments dans le tas, vous avez besoin de comparer les éléments, et l'étudiant ne peut pas comparer directement, donc une exception est levée

2. Comparaison des éléments

1. Comparaison des types de base

En Java, les éléments des types de base peuvent être. comparé directement

public class TestCompare {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a>b);
        System.out.println(a==b);
        System.out.println(a<b);
 
        char c1 = &#39;a&#39;;
        char c2 = &#39;b&#39;;
        System.out.println(c1==c2);
        System.out.println(c1>c2);
        System.out.println(c1<c2);
 
        boolean b1 = true;
        boolean b2 = false;
        System.out.println(b1==b2);
        System.out.println(b1!=b2);
    }
}

2 . Comparaison des types de référence

class Student{
    String name;
    int age;
 
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("张三",25);
        Student s2 = new Student("李四",31);
        Student s3 = s1;
        System.out.println(s1==s2);  //false
        System.out.println(s1==s3);  //true
        //System.out.println(s1<s2); 编译报错
        //System.out.println(s1>s3); 编译报错
    }
}

À en juger par les résultats ci-dessus, les types personnalisés ne peuvent pas être comparés en utilisant >, <.

==Lors de la comparaison de types personnalisés, ce qui est comparé est de savoir si les adresses des objets sont les mêmes

Mais nous avons souvent besoin de comparer le contenu des objets. Par exemple, si nous insérons un objet dans la file d'attente prioritaire, nous le faisons. besoin d'ajuster le tas en fonction du contenu de l'objet. Alors Comment comparer ?

3. Méthodes de comparaison d'objets

1. Comparaison de méthodes égales

La classe Object est la classe de base de chaque classe, qui fournit la méthode equals() pour comparer si le contenu est le même

Mais les égaux dans Object Par défaut, la méthode utilise == pour comparer, c'est-à-dire pour comparer les adresses de deux objets, donc si vous souhaitez que vos types personnalisés soient comparés, vous pouvez remplacer la méthode equals() de la classe de base

Exemple :

class Student{
    String name;
    int age;
 
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    @Override
    public boolean equals(Object obj) {
        if(this == obj){
            return true;
        }
        if(obj==null || !(obj instanceof Student)){
            return false;
        }
        Student s = (Student) obj;
        return this.age==s.age && this.name.equals(s.name);
    }
}
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("张三",25);
        Student s2 = new Student("李四",31);
        Student s3 = new Student("李四",31);
        System.out.println(s1.equals(s2));
        System.out.println(s2.equals(s3));
    }
}

Résultat : Le contenu peut être comparé Sont-ils identiques

Étapes pour remplacer la méthode égale

• Si les adresses des deux objets sont les mêmes, retournez vrai
• Si l'objet a réussi in est nul, renvoie false
• Si l'objet transmis est le même que l'objet appelé Les objets ne sont pas du même type, renvoie false
• Si le contenu est le même, renvoie true, sinon renvoie false

Notes

La méthode equals() ne peut comparer que si deux objets sont identiques et ne peut pas suivre les règles de >, < Comparaison basée sur une interface comparable

2. Comparaison basée sur une interface comparable

Pour les types de référence, si. vous souhaitez comparer en fonction de la taille, implémentez l'interface Comparable lors de la définition de la classe, puis remplacez la méthode compareTo dans la classe

Exemple : comparaison La taille de deux personnes est généralement comparée en fonction de l'âge

class Person implements Comparable<Person>{
    String name;
    int age;
 
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    @Override
    public int compareTo(Person o) {
        if(o == null){
            return 1;
        }
        return this.age-o.age;
    }
}
public class Test1 {
    public static void main(String[] args) {
        Person p1 = new Person("小王",22);
        Person p2 = new Person("小张",21);
        Person p3 = new Person("小方",22);
        System.out.println(p1.compareTo(p2)); //>0表示大于
        System.out.println(p2.compareTo(p3)); //<0表示小于
        System.out.println(p1.compareTo(p3)); //==0表示相等
    }
}

La méthode compareTo est une interface classe en java.lang, qui peut être utilisée directement

L'utilisation de l'interface Comparable permet d'insérer des objets de type Student dans la file d'attente prioritaire

import java.util.PriorityQueue;
 
class Student implements Comparable<Student> {
    String name;
    int age;
 
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    @Override
    public int compareTo(Student o) {
        if(o == null){
            return -1;
        }
        return this.age-o.age;
    }
}
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("张三",25);
        Student s2 = new Student("李四",31);
        Student s3 = new Student("李四",35);
        PriorityQueue<Student> p = new PriorityQueue<>();
        p.offer(s1);
        p.offer(s2);
        p.offer(s3);
    }
}

Résultat : les objets de type Student peuvent également être insérés dans la file d'attente prioritaire

3 . Comparaison basée sur l'interface Comparator

Les étapes spécifiques de la comparaison selon le comparateur sont les suivantes :

• Créer une classe de comparateur et implémenter l'interface Comparator
• Réécrire la méthode de comparaison

Utiliser un comparateur pour qu'un objet de. type Student peut être inséré dans la file d'attente prioritaire

import java.util.Comparator;
import java.util.PriorityQueue;
 
class Student {
    String name;
    int age;
 
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
class StudentComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        if(o1 == o2){
            return 0;
        }
        if(o1 == null){
            return -1;
        }
        if(o2 == null){
            return 1;
        }
        return o1.age-o2.age;
    }
}
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("张三",25);
        Student s2 = new Student("李四",31);
        Student s3 = new Student("李四",35);
        PriorityQueue<Student> p = new PriorityQueue<>(new StudentComparator());
        p.offer(s1);
        p.offer(s2);
        p.offer(s3);
    }
}

Résultat : Un objet de type Student peut être inséré dans la file d'attente prioritaire

Comparator est une fonction générale du package java.util Type d'interface classe, le package correspondant doit être importé lors de l'utilisation de

4. Comparaison de trois méthodes de comparaison

.

Méthode remplacée	Description
Object.equals	ne peut comparer que si le contenu de deux objets est égal, ne peut pas comparer les tailles
Comparable.compareTo	La classe doit implémenter l'interface, qui est très intrusive pour la classe et détruit la structure de la classe d'origine
Comparator.compare	doit implémenter une classe de comparaison, qui est très intrusive à la classe C'est moins intrusif et ne détruit pas la classe d'origine

Comparable, quelle méthode de comparaison Comparator utilise-t-il ?

Si nous obtenons une classe définie par d'autres et que nous ne pouvons pas opérer sur la classe, nous utiliserons la méthode de création d'une classe pour implémenter l'interface Comparator

Si la classe est une classe définie par l'utilisateur et que nous pouvons opérer sur le classe, nous utiliserons la méthode d'implémentation de la méthode d'interface comparable

Apprentissage recommandé : "Tutoriel vidéo Java"

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!