Java比较问题详细分析

java中的比较问题是一个很基础又很容易混淆的问题。今天就几个容易出错的点作一个比较详细的归纳与整理，希望对大家的学习与面试有帮助。

一、==与equals()的区别

首先，我们需要知道==与equals()的区别，==号比较的一直是地址值，对于基本数据类型来说，==比较实际上就是变量数值是否相等，而对于引用数据类型，比较的则是地址值。这里特别需要注意的是string类型，很容易想当然的使用==，很容易出错。equals()方法是object类里的方法，我们知道java中一切类都会默认继承object类，所以类对象都会有equals()方法。object类中equals()方法如下图所示：

由源码可以看出，object类里的equals()方法底层也是用的==，所以它比较的其实也是地址值。所以如果想用equals()方法去作其他比较，我们需要重写equals()方法。

二、基本数据类型及其包装类

我们都知道，byte、short、int、long、boolean、char、double、float这八个是基本数据类型，它们声明的变量存放在栈内存中。而它们对应的包装类型(byte、short、integer、long、boolean、character、double)定义的变量则存在于堆内存中。对于基本数据类型，它们的比较相对而言较为简单，即判断是否相等用==，比较大小用<、>、<=、>=即可。而对于包装类型，却有些不同。

首先对于判断是否相等，看如下代码的执行结果：

package dailytest;
import org.junit.test;
/**
 * java中的比较总结
 * @author yrr
 */
public class javacomparetest {
  /**
   * integer类型判断是否相等
   */
  @test
  public void test01() {
    int n3 = 48;
    system.out.println("--------使用new对象时，当值在[-127,128]之间时---------");
    integer n7 = new integer(48);
    integer n8 = new integer(48);
    system.out.println(n7 == n8);  //false
    system.out.println(n7 == n3);  //true
    system.out.println("--------直接赋值方式，当值在[-128,127]之间时---------");
    integer n1 = 48;
    integer n2 = 48;
    system.out.println(n3 == n1); //true
    system.out.println(n1 == n2); //true
    system.out.println(n1.equals(n2)); //true
    system.out.println(n1.equals(n3)); //true
    system.out.println(n1.intvalue() == n2.intvalue()); //true
    system.out.println("--------直接赋值方式，当值不在[-127,128]之间时---------");
    integer n4 = 128;
    integer n5 = 128;
    int n6 = 128;
    system.out.println(n4 == n5);  //false
    system.out.println(n4 == n6);  //true
    system.out.println(n4.equals(n5)); //true
    system.out.println(n4.equals(n6)); //true
    system.out.println(n4.intvalue() == n5.intvalue()); //true
    //使用integer.intvalue()方法时需要注意验证是否为null，防止出现nullpointexception
  }
  /**
   * long类型判断是否相等
   */
  @test
  public void test02() {
    //这里需要注意，使用long定义时，不需要加l或者l，而使用long时必须加，否则会报错
    //建设都加上，以示区别
    long n3 = 48l;
    system.out.println("--------使用new对象时，当值在[-127,128]之间时---------");
    long n7 = new long(48);
    long n8 = new long(48);
    system.out.println(n7 == n8);  //false
    system.out.println(n7 == n3);  //true
    system.out.println("--------直接赋值方式，当值在[-127,128]之间时---------");
    long n1 = 48l;
    long n2 = 48l;
    system.out.println(n3 == n1); //true
    system.out.println(n1 == n2); //true
    system.out.println(n1.equals(n2)); //true
    system.out.println(n1.equals(n3)); //true
    system.out.println(n1.intvalue() == n2.intvalue()); //true
    system.out.println("--------直接赋值方式，当值不在[-127,128]之间时---------");
    long n4 = 128l;
    long n5 = 128l;
    long n6 = 128;
    system.out.println(n4 == n5);  //false
    system.out.println(n4 == n6);  //true
    system.out.println(n4.equals(n5)); //true
    system.out.println(n4.equals(n6)); //true
    system.out.println(n4.intvalue() == n5.intvalue()); //true
    //使用long.intvalue()方法时需要注意验证是否为null，防止出现nullpointexception
  }
}

针对上面的执行结果，作如下说明：

首先，对于new方法来声明一个integer或者long对象，因为new对象都是在堆里开辟一块空间，所以即便两者的数值相同，但对于==来说，比较的是地址值，所以会返回false。 对于基本数据类型的包装类，都重写了equals()方法，会比较数值大小，所以用equals()方法是可以根据数值大小进行判断的。 对于integer变量与int变量比较的问题，会发现也是基于数值大小得出来的比较值，这是因为在比较时，integer类型做了自动拆箱，转成了int类型。 前三点的解释，对所有包装类型都是适用的 对于直接赋值方式，值为48的两个integer变量，用==号判断是true，而当值为128后，却为false。这是因为在底层，对于integer n1 = 48;这种直接赋值的方式，其实调用了integer.value()方法。我们可以简单看一下integer.value()方法的源码，如下图所示：

我们可以看到，这里有个if判断，当输入的i在[-128,127]的范围内时，直接从integercache数组中返回了。所以，对于在这个范围内的数值，返回的都是这个数组对应的地址值，因此用==号判断会返回true。而不在这个范围内的，是new出的对象，因此会返回false。这个结论对于byte、short、integer、long类型都成立（感兴趣的可以去看下它们对应的value()方法的源码），因为byte类型的范围就是[-128,127]，所以对于byte类型来说，使用==与equals()没有区别。 

而对于大小比较，使用>、<、<=、>=是没有问题的，它们会进行自动拆箱。但是我们通常建议使用以下两种方式来进行大小比较：

调用xxxvalue()方法转成基本数据类型进行比较 使用compareto()方法进行比较，在包装类中，都重写了compareto()方法。查看compareto()源码，可以看出，其实它底层使用的也是通过自动拆箱转成了对应的基本数据类型再进行比较的。

二、java对象的比较

有了上面的介绍之后，对象的比较就比较容易了。原理都是一样的。

1. string类型的比较

需要注意的是，string类型不能直接使用>、<=、>=、<，会报编译异常。

package dailytest;
import org.junit.test;
/**
 * 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); //the operator < is undefined for the argument type(s) java.lang.string, java.lang.string
    system.out.println(s1.compareto(s3) < 0);  //true
  }
}

 2. 类对象的比较

类对象比较结论也是一样的，但是相对于基本数据类型和string类型，较为复杂一点。

根据某一规则，判断两个对象是否相等，需要在被判断类中重写equals()方法，示例代码如下：

package dailytest;
import org.junit.test;
/**
 * java中的比较总结
 * @author yrr
 */
public class javacomparetest {
  @test
  public void test04() {
    person p1 = new person("yrr",18);
    person p2 = new person("yrr",18);
    system.out.println(p1 == p2);  //false
    system.out.println(p2.equals(p1)); //true
  }
}
class person{
  private string name;
  private integer age;

  public person() {
  }
  public person(string name, integer age) {
    this.name = name;
    this.age = age;
  }
  public string getname() {
    return name;
  }
  public integer getage() {
    return age;
  }
  @override
  public boolean equals(object obj) {
    person person = (person) obj;
    return name.equals(person.getname()) && age.equals(person.getage());
  }

}

而如果要比较两个对象的大小（这也是常会问到的面试题），有两种方式：

被比较类实现comparable接口，并重写compareto()方法 自己定义实现了一个comparator接口的类或者利用内部类，重写compare()方法 两者的区别：前者定义在被比较类上，而后者定义在被比较类外。通过这种区别，两者的优缺点也很明显，前者简单，但需要对被比较类进行修改，而后者则不需要修改原代码，更加灵活。

第一种方式，示例代码如下：

package dailytest;
import org.junit.test;
/**
 * java中的比较总结
 * @author yrr
 */
public class javacomparetest {
  @test
  public void test5() {
    person p1 = new person("yrr",18);
    person p2 = new person("wx",19);
    system.out.println(p1.compareto(p2) < 0);
  }
}
class person implements comparable<person>{
  private string name;
  private integer age;
  public person() {
  }
  public person(string name, integer age) {
    this.name = name;
    this.age = age;
  }
  public integer getage() {
    return age;
  }
  @override
  public int compareto(person o) {
    return this.getage() - o.getage();
  }
}

第二种方式，示例代码如下：

package comparator;
import java.util.arrays;
import java.util.comparator;
public class mycomparator {
  public static void main(string[] args) {
    user[] users = new user[] { new user("u1001", 25),
        new user("u1002", 20), new user("u1003", 21) };
    arrays.sort(users, new comparator<user>() {

      @override
      public int compare(user o1, user o2) {
        return o1.getage() - o2.getage();
      }
    });
    for (int i = 0; i < users.length; i++) {
      user user = users[i];
      system.out.println(user.getid() + " " + user.getage());
    }
  }
}
class user {
  private string id;
  private int age;

  public user(string id, int age) {
    this.id = id;
    this.age = age;
  }
  public int getage() {
    return age;
  }
  public void setage(int age) {
    this.age = age;
  }
  public string getid() {
    return id;
  }
  public void setid(string id) {
    this.id = id;
  }
}

以上就是本次给大家讲的java中比较问题的相关内容，大家还有其他问题可以在下方留言区讨论，感谢你的支持。

原文链接：https://my.oschina.net/demonfs/blog/1580084