Java 数据类型及其判断

一、Java 的两类数据类型

1.基本数据类型，也称原始数据类型

byte、short、char、int、long、float、double、boolean它们之间的比较，应该用双等号(==)，比较的是它们的值。

2.引用数据类型

Java 所有的类都继承于Object这个基类的，其中定义了一个equals的方法，该方法的初始行为是比较变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作。
但在一些类库当中该方法被覆盖掉了，如 String、Integer、Date。在这些类当中 equals 有其自身的实现，而不再是比较类在堆内存中的存放地址了。
对于引用数据类型之间进行 equals 比较，在没有重写 equals 方法的情况下，它们之间的比较还是基于它们在内存中的存放位置的地址值的，因为 Object 的 equals 方法也是用双等号进行比较的，所以比较后的结果跟双等号的结果相同。

注意：

1. 比较的是操作符两端的操作数是否是同一个对象。
2. 两边的操作数必须是同一类型的(可以是父子类之间)才能编译通过。
3. 比较的是地址。如果是具体的阿拉伯数字的比较，值相等则为true，如：
   int a=10 与 long b=10L 与 double c=10.0都是相同的(为true)，因为它们都指向地址为10的堆。
4. String s=“abc"是一种非常特殊的形式，和 new 有本质的区别。它是Java中唯一不需要new就可以产生对象的途径。以 String s=“abc”; 形式赋值在Java中叫直接量，它是在常量池中而不是象new一样放在压缩堆中。这种形式的字符串，在JVM内部发生字符串拘留，即当声明这样的一个字符串后，JVM会在常量池中先查找有有没有一个值为"abc"的对象。如果有，就会把它赋给当前引用。即原来那个引用和现在这个引用指向了同一对象。如果没有，则在常量池中新创建一个"abc"，下一次如果有 String s1 = “abc”; 又会将s1指向"abc"这个对象，即以这种形式声明的字符串，只要值相等，任何多个引用都指向同一对象。而 String s = new String(“abcd”); 和其它任何对象一样，每调用一次就产生一个对象，只要它们调用。
   也可以这么理解：
   String str = "hello";先在内存中找是否存在“hello”这个对象，如果有，就让str指向那个"hello"。如果没有，就创建一个新的对象保存“hello”。
   String str=new String ("hello")就是不管内存里有没有“hello”这个对象，都新建一个对象保存“hello”。

具体可以看下面的代码：

public static void main(String[] args) {
    String a1 = new String("a"); //a1 为一个引用
    String a2 = new String("a"); //a2 为另一个引用，对象的内容一样
    System.out.println("a1==a2：" + (a1 == a2));// false，非同一对象
    System.out.println("a1EQa2：" + a1.equals(a2));// true

    String a3 = "a"; //a3 为另一个引用，对象的内容一样
    System.out.println("a1==a3：" + (a1 == a3));// false，非同一对象
    System.out.println("a2==a3：" + (a2 == a3));// false，非同一对象
    System.out.println("a1EQa3：" + a1.equals(a3));// true

    String b1 = "b"; //放在常量池中
    String b2 = "b"; //从常量池中查找
    System.out.println("b1==b2：" + (b1 == b2));// true
    
    System.out.println("42 == 42.0：" + (42 == 42.0));// true
}

二、equals 和 == 的区别

equals 方法定义在基类 Object，源码：

public boolean equals(Object obj) {    
   return (this == obj);
}

由 equals 的源码可以看出这里定义的 equals 与双等号是等效的(Object类中的equals与双等号没什么区别)。不同的原因就在于有些类(像String、Integer等类)对 equals 进行了重写，但是没有对 equals 进行重写的类(比如自定义的类)就只能从 Object 类中继承 equals 方法，其 equals 方法与 == 就也是等效的，除非在此类中重写 equals。

对equals重新需要注意五点：
1️⃣自反性：对任意引用值X，x.equals(x)的返回值一定为true。
2️⃣对称性：对于任何引用值x、y，当且仅当y.equals(x)返回值为true时，x.equals(y)的返回值一定为true。
3️⃣传递性：如果x.equals(y)=true，y.equals(z)=true，则x.equals(z)=true。
4️⃣一致性：如果参与比较的对象没任何改变，则对象比较的结果也不应该有任何改变。
5️⃣非空性：任何非空的引用值X，x.equals(null)的返回值一定为false 。

String 类对 equals 的重写如下：

public boolean equals(Object var1) {
		if (this == var1) {
			return true;
		} else {
			if (var1 instanceof String) {
				String var2 = (String) var1;
				int var3 = this.value.length;
				if (var3 == var2.value.length) {
					char[] var4 = this.value;
					char[] var5 = var2.value;

					for (int var6 = 0; var3-- != 0; ++var6) {
						if (var4[var6] != var5[var6]) {
							return false;
						}
					}
					return true;
				}
			}
			return false;
		}
	}

另外，双等号比“equals”运行速度快，因为双等号“==”只是比较引用。

三、经典面试

如果Integer a = 3;Integer b = 3;那么【a==b】的结果是什么？-----true
如果Integer a = 273;Integer b = 273;那么【a==b】的结果是什么？-----false

原因：
对于Integer var = ?在 -128 至 127 范围内的赋值，Integer 对象是在 IntegerCache.cache 产生，会复用已有对象，这个区间内的 Integer 值可以直接使用 == 进行判断，但是这个区间之外的所有数据，都会在堆上产生，并不会复用已有对象，推荐使用 equals 方法进行判断。