Java 基础系列(二) --- Java对象的比较，搞懂这些就够了

一：对象的初步认知

1.C语言与Java我们需要知道这些

1.1 面向过程

C语言是我们计算机专业的优秀学子们的基操，众所周知，C语言面向的是过程，关注的是过程，旨在分析出求解问题的步骤，然后通过函数的调用来得到问题的解决；譬如下面的两数相加的函数。

#include<stdio.h> 
int add(int x, int y) {
	return x + y;
}
int main() 
{
	int a = 10;
	int b = 20;
	int ret = add(a, b);
	printf("%d\n", ret);
	return 0;
}

面向过程注重的是过程，在整个过程中涉及到的行为，就是功能。

1.2 面向对象

Java是面向对象的，关注的是对象，旨在将一件事情拆分成不同的对象，靠的是对象之间的交互完成；
面向过程注重的是对象，也就是参与过程所涉及到的主体，是通过逻辑将一个个功能的实现连接起来；其好处就是将复杂的事情变简单了，只要面对一个对象就行。

听着有点拗口，你只需要知道以下便可！！！

1.3 重点

在我们用java开发过程中，铭记：
找对象–>建对象–>用对象–>维护对象之间的关系
面向对象的设计把握一个重要的经验：谁拥有数据，谁对外提供操作这些数据的方法,简言之：面向对象就是用类来描述客观世界中事物的一种方式，一个类主要包含一个事物的属性和行为。

2. 类与对象总结

• C 语言是面向过程的, 主要关注的是其过程, 分析出求解问题的步骤, 并通过函数调用来逐步解决问题;
• Java 是面向对象的, 关注的是对象, 将一件事情拆分成不同的对象, 依靠对象之间的交互来解决问题;
• 通过一个类就可以产生多个对象, 类就是一类对象的统称, 对象就是这一类的具体化的一个实例; 总之类就相当于一个模板, 而对象是由模板来产生样本;
• 面向对象就是用代码(类)来描述客观世界的事物的一种方式, 一个类主要包含一个事物的属性和行为.

二：元素的比较

1.基本类型的比较

我们知道基本类型的对象可以直接比较大小，例如下面的代码：

public class Test {
    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);
        System.out.println("======");
        char c1 = 'a';
        char c2 = 'b';
        System.out.println(c1 > c2);
        System.out.println(c1 < c2);
        System.out.println(c1 == c2);
    }
}

运行结果如下，从结果中可以看出这些数据可以直接比较。

那么在这里我要问一下，对象可以直接进行比较么？为什么呢？

2.对象的比较

结合上面可以看出，基本类型是可以直接进行比较的，下面我将写一个对象进行比较的示例，我们来看一下能否运行成功。

class People {
    public int age;
    public String name;

    public People(int age, String name) {
        this.age = age;
        this.name = name;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        People p1 = new People(18,"zhangsan");
        People p2 = new People(20,"lisi");
        System.out.println(p1 > p2);//编译错误
        //在IDEA上这里其实已经标红报错啦
        System.out.println(p1 < p2);//编译错误
        System.out.println(p1 == p2);//编译成功
    }
}

解读代码
p1 == p2 编译成功，因为其指向的是两个不同的对象，对于用户实现自定义类型，都默认继承自Object类，而Object类中提供了equal方法，该方法的比较规则是：没有比较引用变量及引用对象的内容，而是直接比较引用变量的地址，所以可以编译成功；下图可以看出其直接比较的是两个引用变量的地址。

p1 > p2 及 p1 < p2 不能编译成功，是因为Java中引用类型的变量不能直接按照 > 或者 < 方式进行比较，也可以这样想，编译器无法知道你是按照年龄来进行比较还是按照姓名来进行比较。

那么有些时候我们就是要比较对象中的内容，例如向优先级队列中插入某个对象时，需要按照对象中的内容来调整堆，这时候我们就需要来比较对象中的内容，该如何实现呢？下面的内容便是解决这个问题的三种方式，极其重要！！！

三：对象的比较

1.覆写基类equal

注意

下面的代码便是一般覆写equals的套路，这里需要注意一下几点，代码中也进行了注释。
1.如果指向同一个对象，返回true；
2.如果是null，返回false；
3.如果传入的对象类型不是People，返回false；
4.按照类的实现目标来进行比较，例如下面的代码只要是年龄和姓名一样，就认为相同。
缺点
覆写基类equal方式虽然可以比较，但只能按照相等进行比较，不能按照大于、小于的方式来进行比较。

class People {
    public int age;
    public String name;

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

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

2.基于Comparble接口类的比较

Comparble是JDK提供的泛型的比较接口类，源码如下：

public interface Comparable<E> {
        int compareTo(E o);
    }

说明：
" < 0" ：表示this指向的对象小于o指向的对象；
" == 0"：表示this指向的对象等于o指向的对象；
" > 0"：表示this指向的对象等于o指向的对象。
示例：
对于用户自定义类型，如果要按照大小与方式进行比较时，在定义类时，实现Comparable接口即可，然后再类中重写compareTo方法。

class People implements Comparable<People> {
    public int age;
    public String name;

    public People(int age, String name) {
        this.age = age;
        this.name = name;
    }
    //这里我们根据数值进行比较，不管姓名
    //这里认为null是最小的
    @Override
    public int compareTo(People o) {
        if (o == null) {
            return 1;
        }
        return age - o.age;
    }
}
public class TestDemo1 {
    public static void main(String[] args) {
        People p1 = new People(18,"zhangsan");
        People p2 = new People(20,"lisi");
        People o = new People(18,"lisi");
        System.out.println(p1.compareTo(o));
        System.out.println(p1.compareTo(p2));
        System.out.println(p2.compareTo(p1));
    }
}

运行结果：
" == 0 ",表示相等；
" < 0 ",表示p1比较小；
" > 0 ",表示p2比较大；

3.基于比较器的比较

3.1 Comparable和Comparator

在学习比较器方式之前，需要区分一下Comparable和Comparator,不要混淆。

1. Comparable是一个排序接口，也可以认为是一个内比较器，如果一个类实现了Comparable接口，就意味着这个类可以进行排序比较，例如上面写的代码中进行年龄的比较；
2. Comparator也是一个比较器，也可以认为是一个外比较器，例如我们需要对People类的年龄进行比较，People类中有两个属性：年龄（age）和姓名（name），但是People这个类是别人写好的，但是里面并没有Comparable接口，在不允许改变源代码的情况写，便可以使用Comparator接口，覆写方式如下。

按照比较器方式进行比较，实现Comparator接口：

public interface Comparator<T> {
        int compare(T o1,T o2);
    }

说明
" < 0 "：表示o1指向的对象小于o2指向的对象；
" == 0 "：表示o1指向的对象等于o2指向的对象；
" > 0 "：表示o1指向的对象大于o2指向的对象。

3.2 覆写Comparator中的compare方法

示例如下：

class People {
    public int age;
    public String name;

    public People(int age, String name) {
        this.age = age;
        this.name = name;
    }
}
class PeopleComparator implements Comparator<People> {
    @Override
    public int compare(People o1,People o2) {
        if(o1 == o2) {
            return 0;
        }
        if(o1 == null) {
            return -1;
        }
        if(o2 == null) {
            return 1;
        }
        return o1.age - o2.age;
    }
}
public class TestDemo2 {
    public interface Comparator<T> {
        int compare(T o1,T o2);
    }
    public static void main(String[] args) {
        People p1 = new People(18,"zhangsan");
        People p2 = new People(20,"lisi");
        People o = new People(18,"lisi");
        //定义比较器对象
        PeopleComparator cmptor = new PeopleComparator();
        //使用比较器对象进行比较
        System.out.println(cmptor.compare(p1,o));
        System.out.println(cmptor.compare(p1,p2));
        System.out.println(cmptor.compare(p2,p1));
    }
}

运行结果：

" == 0 ",表示相等；
" < 0 ",表示p1比较小；
" > 0 ",表示p2比较大；

4.三种方式的对比