==与equals的区别

简单总结一下区别
//==
基本类型比较的是值
引用类型比较的是地址
//equals()
只对于引用类型而言，因为equals()是Object 的方法，如果对象不对他进行重写，则他们就直接继承Object的，比较的是对象的地址值，

如果对他进行重写就按照他重写的规则，例如String Integer就重新定义了，它比较的是内容

public class Test1 {
	public static void main(String[] args) {
		Demo_2();
		System.out.println("--------------");
		Demo_1();
	}

	public static void Demo_1() {
		Integer a = new Integer(3);
		Integer b = 3;
		int c = 3;
		System.out.println(a.equals(b));
		System.out.println(a == b);
		System.out.println(a == c);
	}

	public static void Demo_2() {
		String s = new String("hello");
		String s1 = "hello";
		System.out.println(s == s1);
		System.out.println(s1.equals(s));

	}
}

查看API文档可知String中重新定义了Equals(）语法

再举一个例子

package 面试宝典;

public class Test2 {
	public static void main(String[] args) {
		demo_1();

	}

	public static void demo_1() {
		Student a = new Student(16, "张佩");
		Student b = new Student(16, "张佩");
		System.out.println(a == b);
		System.out.println(a.equals(b));
	}
}

class Student {
	private int age;
	private String name;

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

例3

答案是这样的

为什么
Integer b =3，c=3;
System.out.println(bc);//是True;
而Integer e=200，f=200;
System.out.println(ef);//会是false呢
这是是因为第一个，==对于引用类型比较的是地址值，b.c都为栈区变量地址一致，所以返回true；
而 e,f 根据Integer源码；
` public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}

`
Integer实际上先从IntegerCache里取数据，如果数据值不在IntegerCache.low(-128)和IntegerCache.high(127)范围内，会new新的Integer对象，所以值超过127的都创建新的对象实例，两者对象值相等，但地址不一样，“==”返回false，由于Integer重写的equals，实现值比对。所以"equals"返回true。同理String也一样道理

   private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }