JAVA对象的比较

1.元素的比较

1.==是比较两者的值是否相等

若比较的是基本类型，比较的就是他们保存的内容
若比较的市引用类型，比较的引用的地址
2.equals比较的是两者的内容，如果不覆写equals方法就jdk内部默认的比较方式

2.对象的比较

复写equals方法

public class Card { 
public int rank; // 数值 
public String suit; // 花色 
public Card(int rank, String suit) { 
this.rank = rank;
 this.suit = suit; 
 }

  public boolean equals(Object o) {
   // 自己和自己比较 
   if (this == o) { 
   return true; 
   }
   // o如果是null对象，或者o不是Card的子类 
   if (o == null || !(o instanceof Card)) { 
   return false; 
   }// 注意基本类型可以直接比较，但引用类型最好调用其equal方法 
   Card c = (Card)o; 
   return rank == c.rank && suit.equals(c.suit);
    } 
    }

Comparble和Comparator

Comparble

Comparable可以认为是一个内比较器，实现了Comparable接口的类有一个特点，就是这些类是可以和自己比较的，至于具体和另一个实现了Comparable接口的类如何比较，则依赖compareTo方法的实现。

创建一个实现comparable接口的类

public class Domain implements Comparable<Domain>
{
    private String str;

    public Domain(String str)
    {
        this.str = str;
    }

    public int compareTo(Domain domain)
    {
        if (this.str.compareTo(domain.str) > 0)
            return 1;
        else if (this.str.compareTo(domain.str) == 0)
            return 0;
        else 
            return -1;
    }
    
    public String getStr()
    {
        return str;
    }
}

测试一下

public static void main(String[] args)
    {
        Domain d1 = new Domain("c");
        Domain d2 = new Domain("c");
        Domain d3 = new Domain("b");
        Domain d4 = new Domain("d");
        System.out.println(d1.compareTo(d2)); //0
        System.out.println(d1.compareTo(d3)); //1
        System.out.println(d1.compareTo(d4)); //-1
    }
    

Comparator

Comparator可以认为是是一个外比较器，一个对象不支持自己和自己比较（没有实现Comparable接口），但是又想对两个对象进行比较

原本的类不改变

public class DomainComparator implements Comparator<Domain>
{
    public int compare(Domain domain1, Domain domain2)
    {
        if (domain1.getStr().compareTo(domain2.getStr()) > 0)
            return 1;
        else if (domain1.getStr().compareTo(domain2.getStr()) == 0)
            return 0;
        else 
            return -1;
    }
}

测试一下

public static void main(String[] args)
{
    Domain d1 = new Domain("c");
    Domain d2 = new Domain("c");
    Domain d3 = new Domain("b");
    Domain d4 = new Domain("d");
    DomainComparator dc = new DomainComparator();
    System.out.println(dc.compare(d1, d2)); //0
    System.out.println(dc.compare(d1, d3)); //1
    System.out.println(dc.compare(d1, d4)); //-1
}

总结

3.集合框架中的PriorityQueue

集合框架中的PriorityQueue底层使用堆结构，因此其内部的元素必须要能够比大小，PriorityQueue采用了：
Comparble和Comparator两种方式。

1. Comparble是默认的内部比较方式，如果用户插入自定义类型对象时，该类对象必须要实现Comparble接
   口，并覆写compareTo方法。
2. 用户也可以选择使用比较器对象，如果用户插入自定义类型对象时，必须要提供一个比较器类，让该类实现
   Comparator接口并覆写compare方法。

内置PriorityQueue

import java.util.PriorityQueue;
import java.util.Random;

public class PriorityQueueExample {
    public static void main(String[] args) {
        PriorityQueue<Integer>queue = new PriorityQueue<>();
        Random random = new Random();
        for (int i = 0; i < 7; i++) {
            queue.offer(new Integer(random.nextInt(100)));
        }
        for (int i = 0; i < 7; i++) {
            System.out.print(queue.poll()+" ");
        }
    }

}
//运行结果
//21 26 44 49 50 53 58 

自定义PriorityQueue

import java.util.Comparator;
import java.util.Queue;
import java.util.PriorityQueue;

public class PriorityQueueTest {
    public static void main(String[] args) {
//        int []data={1,4,3,2,7,6,5,8,10,9};
        Queue<Student> queue = new PriorityQueue<>(new StudentCom());
        Student stu1 = new Student("宋江", 20);
        Student stu2 = new Student("张飞", 19);
        Student stu3 = new Student("关羽", 18);

        queue.offer(stu1);
        queue.offer(stu2);
        queue.offer(stu3);
        while (!queue.isEmpty()) {
            System.out.println(queue.poll());
        }
        

    }
}
class StudentCom implements Comparator<Student>{

    @Override
    public int compare(Student o1, Student o2) {
        return o1.getAge()-o2.getAge();
    }

}
class StudentComDesc implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o2.getAge() - o1.getAge();
    }
}

    class Student {
        String name;
        int age;

        public int getAge() {
            return age;
        }

        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }

        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }


    }