equals和==的区别

Integer 、int比较

public class Equality {
    public static void main(String[] args) {
        //基本数据类型互相比较
        int a = 1;
        int b = 1;
        System.out.println(a == b);//true


        //包装类和包装类比较
        Integer a1 = 1;
        Integer b1 = new Integer(1);
        System.out.println(a1 == b1);//false  比较引用 且地址不同
        System.out.println(a1.equals(b1));//ture   Integer重写了equals方法 intValue对比


        //基本数据类型和基本数据类型的包装类比较
        int a2 = 1;
        Integer b2 = new Integer(1);
        System.out.println(b2 == a2);//true 用==比较   b2自动拆箱 比较值 所以为true
        System.out.println(b2.equals(a2));true //用equals比较  equals方法被重写 intValue 之间的比较 所以为true


        //基本数据类型和基本数据类型的包装类比较
        Integer a3 = 127;
        Integer b3 = new Integer(127);
        System.out.println(a3 == b3);//false  a3装箱后 ==对比 引用地址不同 所以false
        System.out.println(a3.equals(b3));//true  a3装箱后 equals对比 由于equals方法被重写 所以最终用==

        //基本数据类型装箱后比较  -128到127之前（包含）
        Integer a4 = 127;
        Integer b4 = 127;
        System.out.println(a4 == b4);//true  自动装箱过程调用valueof() 在-128和127之间（包含）从换从缓存中查找  所以是同一个对象用==比较内存地址  所以为true
        System.out.println(a4.equals(b4));//true  由于equals方法被重写 所以最终用==比较各自的intvlaue所以为true


        //基本数据类型装箱后比较 小于-128大于127
        Integer a5 = 128;
        Integer b5 = 128;
        System.out.println(a5 == b5);//false
        // 自动装箱过程调用valueof() 在-128和127之间（包含）从换从缓存中查找 大于128
        // new包装类对象 所以是两个个对象用==比较内存地址  所以为false
        System.out.println(a5.equals(b5));//true  由于equals方法被重写 所以最终用==比较各自的intvlaue所以为true
    }
}

String比较

        //String 比较
        String s = "10";
        String s1 = new String("10");
        System.out.println(s==s1);//false 比较内存地址是否相等  "10"在常量池中 s引用"10"在常量池的地址  s1引用的是堆上新开的地址

相关源码（部分）

• Integer

    /**
     * Returns an {@code Integer} instance representing the specified
     * {@code int} value.  If a new {@code Integer} instance is not
     * required, this method should generally be used in preference to
     * the constructor {@link #Integer(int)}, as this method is likely
     * to yield significantly better space and time performance by
     * caching frequently requested values.
     *
     * This method will always cache values in the range -128 to 127,
     * inclusive, and may cache other values outside of this range.
     *
     * @param  i an {@code int} value.
     * @return an {@code Integer} instance representing {@code i}.
     * @since  1.5
     */
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

    /**
     * Compares this object to the specified object.  The result is
     * {@code true} if and only if the argument is not
     * {@code null} and is an {@code Integer} object that
     * contains the same {@code int} value as this object.
     *
     * @param   obj   the object to compare with.
     * @return  {@code true} if the objects are the same;
     *          {@code false} otherwise.
     */
    public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

• String

/**
     * Compares this string to the specified object.  The result is {@code
     * true} if and only if the argument is not {@code null} and is a {@code
     * String} object that represents the same sequence of characters as this
     * object.
     *
     * @param  anObject
     *         The object to compare this {@code String} against
     *
     * @return  {@code true} if the given object represents a {@code String}
     *          equivalent to this string, {@code false} otherwise
     *
     * @see  #compareTo(String)
     * @see  #equalsIgnoreCase(String)
     */
    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = length();
            if (n == anotherString.length()) {
                int i = 0;
                while (n-- != 0) {
                    if (charAt(i) != anotherString.charAt(i))
                            return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

总结

1.== 用于基本数据类型时，是比较两个变量的值是否相等；如果用于比较对象，则是比较对象变量在堆内存中引用地址是否相等。当用于比较由一个基本数据类型自动装箱后的两个对象时，要看这个值是否在-128到127区间内（包含），如果在区间内，==此时比较的是两个指向同一个对象地址的引用，所以为true；如果不在区间内，自动装箱时是通过new Integer()、new Long()来实现的（可以看valueOf方法），此时==比较的是两个指向不同内存地址的引用，所以为false。
2.equals()方法默认比较两个对象内存地址是否相等，如果用于比较基本数据类型的包装类，由于包装类重写了equals方法，所以比较的是intvalue longValue之类的大小是否相等。如果用于比较String类，由于String类重写了equals方法，所以比较的是对象内容是否相等。