java中的：++、--、==、equals

本篇主要来说说 Ja va 中这几个经常让人头疼的运算符和函数：`++`、`--`、`==` 和 `equals`。

++ 与 --

先看 `++` 和 `--`。注释里已经写得很直白了，这儿就不啰嗦了，直接上代码感受一下。

public static void test1(){
    // ++i 是先让 i 自加 1，然后使用 i 的值
    // i++ 是先用 i 的值，再让 i 自加 1
    int i = 1;
    System.out.println(++i); // 2     ++i: i先加1变成2，然后输出2
    System.out.println(i++); // 2     i++: 先输出当前的2，然后i再加1变成3
    System.out.println(i);   // 3
    System.out.println(--i); // 2     同上，先减1，再输出
    System.out.println(i--); // 2     先输出2，再减1
    System.out.println(i);   // 1
    // 可以这么理解：后缀的 ++ 和 -- 是在整行代码执行完之后才进行自增或自减，
    // 在执行当前行的过程中，取的都是自增/自减之前的原始值。
}

== 与 equals

接下来聊聊 `==` 和 `equals`。 首先要明确一个关键点：`==` 在判断时有两种场景——基本类型和引用类型。 - **基本类型**：`==` 比较的是它们的值。 - **引用类型**：`==` 比较的是引用所指向的对象在内存中的地址值。也就是说，除非是同一个 `new` 出来的对象，否则比较结果都是 `false`。 来看一段代码：

Integer i1 = new Integer(1);
Integer i2 = new Integer(1);
System.out.println(i1 == i2); // false
System.out.println(i1.equals(i2)); // true

String s1 = new String("a");
String s2 = new String("a");
System.out.println(s1 == s2); // false
System.out.println(s1.equals(s2)); // true

`Integer` 和 `String` 都是引用类型，`i1 == i2` 比较的是两个对象的地址值。每 `new` 一次，JVM 都会在堆中分配一个新的内存地址，所以两个 `new` 出来的对象地址肯定不一样，结果自然是 `false`。`String` 同理。 > 注意：`new Integer()` 创建的整型不是常量，不能在编译期确定，所以不放入常量池，每个对象都有自己的地址空间。 那 `equals` 呢？Ja va 中所有类都继承自 `Object`，`Object` 里的 `equals` 方法默认用的也是 `==`：

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

问题来了——既然都继承自 `Object`，那上面的 `i1.equals(i2)` 和 `s1.equals(s2)` 按理说应该比较地址值，返回 `false` 才对，为什么实际返回了 `true`？ 答案很简单：`String` 和 `Integer` 类都重写了 `equals` 方法，不再单纯用 `==` 比较了。 来看看 `String` 的 `equals` 源码：

public boolean equals(Object var1) {
    if (this == var1) {
        // 如果传进来的 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` 会先判断是不是同一个对象，然后逐字符比较内容。所以 `s1.equals(s2)` 比较的是字符串内容是否相同，内容都是 `"a"`，自然返回 `true`。有兴趣的话，你也可以自己定义一个类，在里面重写 `equals` 方法试试。 再看 `Integer` 的 `equals` 源码，更干脆：

public boolean equals(Object var1) {
    if (var1 instanceof Integer) {
        return this.value == (Integer)var1;
    }
    return false;
}

直接取出对象中的数值来比较，所以 `i1.equals(i2)` 也是 `true`，因为两个对象的值都是 `1`。 下面再来看一个例子：

String s3 = "abc";
String s4 = "abc";
System.out.println(s3 == s4); // true
System.out.println(s3.equals(s4)); // true

咦？`==` 比较引用类型不是比地址值吗？这里怎么又是 `true` 了？ 这就涉及到内存中的**常量池**了。常量池属于方法区的一部分。当执行到 `s3` 创建对象时，如果常量池中没有 `"abc"`，就在常量池中创建一个；第二次创建 `s4` 时，直接复用已有的对象。所以 `s3` 和 `s4` 指向的是同一个对象，地址值相同。而 `String str1 = new String("abc")` 其实创建了两次对象：一次在常量池中，一次在堆内存中，所以 `str1` 和 `new` 出来的另一个 `str2` 地址值不相等，`==` 比较的是堆内存中的地址值，自然不相等。

---

Integer 的缓存机制

再附一个关于 `Integer` 的特殊之处。 `Integer` 的取值有一个缓存范围：**-128 到 127** 之间的整数会被缓存。当 `i5` 赋值为 `127` 时，JVM 会到缓存中查找，发现已经存在这个对象，于是 `i5` 直接指向缓存中的那个对象。`==` 比较的是地址值，自然相等。 而 `i6` 和 `i7` 赋值为 `128` 时，128 不在缓存范围内，JVM 不会去缓存中找，而是重新 `new` 一个对象。两个对象地址不同，`==` 返回 `false`。

Integer i4 = 127;
Integer i5 = 127;
System.out.println(i4 == i5); // true

Integer i6 = 128;
Integer i7 = 128;
System.out.println(i6 == i7); // false

Integer i8 = 126;
Integer i9 = 126;
System.out.println(i8 == i9); // true

这个缓存机制在实际开发中很容易踩坑，记住：**在 -128 到 127 范围内，`==` 比较的是同一个缓存对象；超出这个范围，每次都是新对象**。