Java中的比较总结

一.==运算符

==比较基本类型是比较值是否相等,比较引用类型是比较==两边的地址是否相等

如下图实例

public static void main(String[] args) {
        int a=1,b=1;
        System.out.println(a==b);
        String c=new String("abc");
        String d=new String("abc");
        System.out.println(c==d);
        String e="abc";
        String f="abc";
        System.out.println(e==f);
    }

运行结果:

true
false
true

为什么中间结果的地址会不相同呢

因为new会新在堆中开辟一个地址,导致两个地址不一样;

为什么下面结果的地址一样呢

因为e在使用完后会存入常量池中,f再使用的时候会先在常量池中寻找,寻找到了就直接使用常量池中的地址

二.equals()

equals()方法只能用来比较两个对象的地址是否相同，子类中往往重写了该方法，用于判断类容是否相同，比如Integer、String等。

public static void main(String[] args) {
        Person a=new Person("张三",20);
        Person b=new Person("张三",20);
        System.out.println(a.equals(b));
        Person c=new Person("李四",21);
        Person d=new Person("张三",21);
        System.out.println(a.equals(c));
        System.out.println(a.equals(d));
    }

    static class Person{
        private String name;
        private int age;

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

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Person person = (Person) o;
            return age == person.age && Objects.equals(name, person.name);
        }

        @Override
        public int hashCode() {
            return Objects.hash(name, age);
        }
    }

运行结果:

true
false
false

注意:如果要比较我们自己定义的对象类容是否相等，必须在类中重写Object中的equals方法

三.基于Comparable接口类的比较

实现Comparable接口，重写CompareTo方法

如下例:

public static void main(String[] args) {
        Person a=new Person("张三",20);
        Person b=new Person("李四",18);
        Person c=new Person("王五",10);
        Person d=new Person("赵六",25);
        Person[] p=new Person[4];
        p[0]=a;
        p[1]=b;
        p[2]=c;
        p[3]=d;
        Arrays.sort(p);
        for (int i = 0; i < p.length; i++) {
            System.out.println(p[i].getName()+" "+p[i].getAge());
        }
    }

    static class Person implements Comparable<Person>{
        private String name;
        private int age;

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

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }


        @Override
        public int compareTo(Person o) {
            return this.age-o.age;
        }
    }

运行结果:

已经按年龄升序排好了,如果想按降序排列,把comparaTo里的this.age-o.age改为o.age-this.age即可

王五 10
李四 18
张三 20
赵六 25

当然,这种方法的缺点就是不灵活,比较的方式已经固定死了,我们通常使用下面这种定义比较器的方法

四：自己定义比较器，实现Comparator接口

方法:自己定义比较器，实现Comparator接口，重写compara方法,相比于上面的方法,这种方法灵活很多,也广泛的被使用

public static void main(String[] args) {
        Person a=new Person("张三",20);
        Person b=new Person("李四",18);
        Person c=new Person("王五",10);
        Person d=new Person("赵六",25);
        Person[] p=new Person[4];
        p[0]=a;
        p[1]=b;
        p[2]=c;
        p[3]=d;
        Arrays.sort(p,new PersonComparator());
        for (int i = 0; i < p.length; i++) {
            System.out.println(p[i].getName()+" "+p[i].getAge());
        }
    }

    static class Person{
        private String name;
        private int age;

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

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }
    static class PersonComparator implements Comparator<Person>{

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

运行结果:

王五 10
李四 18
张三 20
赵六 25

我们也可以使用匿名内部类的方式来完成比较器,如下例:

public static void main(String[] args) {
        Person a=new Person("张三",20);
        Person b=new Person("李四",18);
        Person c=new Person("王五",10);
        Person d=new Person("赵六",25);
        Person[] p=new Person[4];
        p[0]=a;
        p[1]=b;
        p[2]=c;
        p[3]=d;
        Arrays.sort(p, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.age-o2.age;
            }
        });
        for (int i = 0; i < p.length; i++) {
            System.out.println(p[i].getName()+" "+p[i].getAge());
        }
    }

    static class Person{
        private String name;
        private int age;

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

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }

运行结果:

王五 10
李四 18
张三 20
赵六 25

今天就到这里了,下期见!