equals和 ==的区别?
详细点

1，equals（）方法比较的是两个对象的内容是否一致；
2，==操作比较的是两个变量的值是否相等。
3，举例子
string a = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });
string b = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });
Console.WriteLine(a == b);//true
Console.WriteLine(a.Equals(b));//true
object g = a;
object h = b;
Console.WriteLine(g == h);//false
Console.WriteLine(g.Equals(h));//true
Person p1 = new Person("jia");
Person p2 = new Person("jia");
Console.WriteLine(p1 == p2);//false
Console.WriteLine(p1.Equals(p2));//false
Person p3 = new Person("jia");
Person p4 = p3;
Console.WriteLine(p3 == p4);//true
Console.WriteLine(p3.Equals(p4));//true
Console.ReadLine();

==比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。
equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。

equals是比较对象的内容,它是个方法,继承自Object类,可以被用户覆盖.

==是个关系运算符,当被比较者是基本类型时,比较其值是否相等;当被比较者是引用类型时,比较其是否引用同一个对象(或者说比较其是否指向同一个内存地址).

关于equals与==的区别从以下几个方面来说：

（1） 如果是基本类型比较，那么只能用==来比较，不能用equals

比如：
public class TestEquals {
public static void main(String[] args)
{
int a = 3;
int b = 4;
int c = 3;
System.out.println(a == b);//结果是false
System.out.println(a == c);//结果是true
System.out.println(a.equals(c));//错误，编译不能通过，equals方法
//不能运用与基本类型的比较
}
}

（2） 对于基本类型的包装类型，比如Boolean、Character、Byte、Shot、Integer、Long、Float、Double等的引用变量，==是比较地址的，而equals是比较内容的。比如：
public class TestEquals {
public static void main(String[] args)
{ Integer n1 = new Integer(30);
Integer n2 = new Integer(30);
Integer n3 = new Integer(31);
System.out.println(n1 == n2);//结果是false 两个不同的Integer对象，故其地址不同，
System.out.println(n1 == n3);//那么不管是new Integer(30)还是new Integer(31) 结果都显示false
System.out.println(n1.equals(n2));//结果是true 根据jdk文档中的说明，n1与n2指向的对象中的内容是相等的，都是30，故equals比较后结果是true
System.out.println(n1.equals(n3));//结果是false 因对象内容不一样，一个是30一个是31
}
}

equals比较的是内容，==比较的是内存地址。

equals比较的是内容，==比较的是内存地址。

楼上的总结很精辟哦。这里再累赘一下。

对于值类型，如果对象的值相等，则相等运算符 (==) 返回 true，否则返回 false。对于string 以外的引用类型，如果两个对象引用同一个对象，则 == 返回 true。对于 string 类型，== 比较字符串的值。
    “ == ”操作比较的是两个变量的值是否相等。
    “ equals（）”方法比较的是两个对象的内容是否一致．equals也就是比较引用类型是否是对同一个对象的引用。

    对于值类型的比较，这里就不做描述了，下面讨论引用类型的比较：
首先我们看一段程序

1. <font size="3"><font face="Verdana">using System;
   
2. using System.Collections.Generic;
   
3. using System.Linq;
   
4. using System.Text;
   
5. 
   
6. namespace ConsoleApplication1
   
7. {
   
8.     class Person
   
9.     {
   
10.         private string name;
    
11. 
    
12.         public string Name
    
13.         {
    
14.             get { return name; }
    
15.             set { name = value; }
    
16.         }
    
17. 
    
18.         public Person(string name)
    
19.         {
    
20.             this.name = name;
    
21.         }
    
22.     }
    
23. }
    
24. using System;
    
25. using System.Collections.Generic;
    
26. using System.Linq;
    
27. using System.Text;
    
28. 
    
29. namespace ConsoleApplication1
    
30. {
    
31.     class Program
    
32.     {
    
33.         static void Main(string[] args)
    
34.         {
    
35.             string a = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });
    
36.             string b = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });
    
37.             Console.WriteLine(a == b);
    
38.             Console.WriteLine(a.Equals(b));
    
39. 
    
40.             object g = a;
    
41.             object h = b;
    
42.             Console.WriteLine(g == h);
    
43.             Console.WriteLine(g.Equals(h));
    
44. 
    
45.             Person p1 = new Person("jia");
    
46.             Person p2 = new Person("jia");
    
47.             Console.WriteLine(p1 == p2);
    
48.             Console.WriteLine(p1.Equals(p2));
    
49. 
    
50. 
    
51.             Person p3 = new Person("jia");
    
52.             Person p4 = p3;
    
53.             Console.WriteLine(p3 == p4);
    
54.             Console.WriteLine(p3.Equals(p4));
    
55. 
    
56.             Console.ReadLine();
    
57.         }
    
58.     }
    
59. }</font></font>

复制代码

运行程序，会输出什么呢？
答案是 true，true，false，true，false，false，true，true。
为什么会出现这个答案呢？因为值类型是存储在内存中的堆栈（以后简称栈），而引用类型的变量在栈中仅仅是存储引用类型变量的地址，而其本身则存储在堆中。
    ==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。
    equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。
    而字符串是一个特殊的引用型类型，在C#语言中，重载了string 对象的很多方法方法(包括equals()方法)，使string对象用起来就像是值类型一样。
    因此在上面的例子中，字符串a和字符串b的两个比较是相等的。

    对于object g 和object h 时内存中两个不同的对象，所以在栈中的内容是不相同的，故不相等。而g.equals(h)用的是sting的equals()方法故相等（多太）。如果将字符串a和b作这样的修改：
        string a="aa";
        string b="aa";
则，g和h的两个比较都是相等的。这是因为系统并没有给字符串b分配内存，只是将"aa"指向了b。所以a和b指向的是同一个字符串（字符串在这种赋值的情况下做了内存的优化）。
对于p1和p2，也是内存中两个不同的对象，所以在内存中的地址肯定不相同，故p1==p2会返回false，又因为p1和p2又是对不同对象的引用，所以p1.equals(p2)将返回false。
对于p3和p4，p4=p3，p3将对对象的引用赋给了p4，p3和p4是对同一个对象的引用，所以两个比较都返回true。
如果我们对person的equals方法重写：

1. <font size="3"><font face="Verdana">using System;
   
2. using System.Collections.Generic;
   
3. using System.Linq;
   
4. using System.Text;
   
5. 
   
6. namespace ConsoleApplication1
   
7. {
   
8.     class Person
   
9.     {
   
10.         private string name;
    
11. 
    
12.         public string Name
    
13.         {
    
14.             get { return name; }
    
15.             set { name = value; }
    
16.         }
    
17. 
    
18.         public Person(string name)
    
19.         {
    
20.             this.name = name;
    
21.         }
    
22. 
    
23.         public override bool Equals(object obj)
    
24.         {
    
25.             if (!(obj is Person))
    
26.                 return false;
    
27.             Person per = (Person)obj;
    
28.             return this.Name == per.Name;
    
29.         }
    
30.     }</font></font>

复制代码

}那么p1.equals(p2),就会返回true。

基本数据类型用==比较
非基本数据类型equals比较内容，==比较内存地址
equals方法可以被覆盖