java中equals和==的区别
java中equals方法的用法以及
java中equals方法的用法以及==的用法（转）equals 方法是ng.Object 类的方法。
有两种用法说明：（1）对于字符串变量来说，使用“==”和“equals()”方法比较字符串时，其比较方法不同。
“==”比较两个变量本身的值，即两个对象在内存中的首地址。
“equals()”比较字符串中所包含的内容是否相同。
比如：String s1,s2,s3 = "abc", s4 ="abc" ;s1 = new String("abc");s2 = new String("abc");那么：s1==s2 是false //两个变量的内存地址不一样，也就是说它们指向的对象不一样，故不相等。
s1.equals(s2) 是true //两个变量的所包含的内容是abc，故相等。
注意（1）：如果：StringBuffer s1 = new StringBuffer("a");StringBuffer s2 = new StringBuffer("a");结果：s1.equals(s2) //是false解释：StringBuffer类中没有重新定义equals这个方法，因此这个方法就来自Object类，而Object类中的equals方法是用来比较“地址”的，所以等于false.注意（2）：对于s3和s4来说，有一点不一样要引起注意，由于s3和s4是两个字符串常量所生成的变量，其中所存放的内存地址是相等的，所以s3==s4是true（即使没有s3=s4这样一个赋值语句）（2）对于非字符串变量来说，"=="和"equals"方法的作用是相同的都是用来比较其对象在堆内存的首地址，即用来比较两个引用变量是否指向同一个对象。
比如：class A{A obj1 = new A();A obj2 = new A();}那么：obj1==obj2是falseobj1.equals(obj2)是false但是如加上这样一句：obj1=obj2;那么obj1==obj2 是trueobj1.equals(obj2) 是true总之：equals方法对于字符串来说是比较内容的，而对于非字符串来说是比较其指向的对象是否相同的。
Java判断字符串是否相等
比较两个字符串是否相等是频繁使用的一组操作。
比较两个字符串是否相等一般首先会想到用“==”关系操作符，但这可能会带来问题。
Java中String类提供了比较字符串是否相等的方法equals（）。
为了研究这种方法的不同，暂且做一下知识铺垫，先了解一下Java的基础知识。
一、Java的数据类型Java的数据类型分为两大类：基本数据类型和引用数据类型。
┏数值型━┳━整数型：byte short int long┏基本数据类型━━┫┗━浮点型：float double┃┣字符型：char数据类型╋┗布尔型：boolean┃┏类（class）┗引用数据类型━━╋接口（interface）┗数组（array）二、存储方式基本类型（值类型）的变量存储在内存中的堆栈中，引用数据类型变量在堆栈中存储是变量地址，而本身存储在堆中。
通俗讲，一、上图记住很够用；二、说内存、谈地址基本都是说引用而非基本；三、你可以把内存地址理解是你学号，而对象实体就是你，每次找你通过学号找，这就是引用；三、分析两者的区别1、“==”操作符比较的是两个变量的值是否相等。
对于引用数据类型变量表示的是两个变量在堆存堆栈中的内容是否相同。
2、"equals()"方法表示的是两个变量是否是对同一个对象的引用，即是堆中的内容是否相同。
四、举例String str="abc";String str2="abc";System.out.println(str==str2);输出结果：true。
这是因为在Java中Sting定义的字符串的值是不可改变的，相同的字符串在内存中只会存储一份，所以str,str2指向的都是同一个字符串“abc”。
String str3=new String("abc");String str4=new String("abc");System.out.println(str3==str4);输出结果：false。
equals 方法
equals 方法
1、equals 方法
equals 方法是用来比较两个对象是否相等的，在 Java 语言中，equals 方法可以用来与任何对象比较，而不仅仅是和字符串比较。
与它对应的是 == 比较运算符，它只能用来比较两个变量是不是指向同一个对象，而不能比较两个对象的内容是不是相同的。
2、equals 方法的使用
(1) 所有的类都继承了 Object 类，由于所有的类都继承了Object 类，所有的 Java 对象都可以调用 equals 方法。
(2) 调用 equals 时，先比较两个对象的内存地址，如果相同，则直接返回 true，如果不同，则继续比较两个对象的实际内容是否相等，如果相等，返回 true，否则返回 false。
3、equals 方法的重载
equals 方法是可以被重载的，也就是某些类可以使用 equals 方法来比较对象的实际内容时，它们可以重载 equals 方法，使其可以比较实际内容，而不是指向同一个对象的指针。
例如，String 类是重载了 equals 方法的，当两个字符串指向不同的对象时，可以调用 equals 方法来比较它们的实际内容是否相等。
equals与==的区别
Equals 与 == 的区别概述：A.==可用于基本类型和引用类型：当用于基本类型时候，是比较值是否相同；当用于引用类型的时候，是比较对象是否相同。
B.对于String a = “a”; Integer b = 1;这种类型的特有对象创建方式，==的时候值是相同的。
C.基本类型没有equals方法，equals只比较值（对象中的内容）是否相同（相同返回true）。
D.一个类如果没有定义equals方法，它将默认继承Object中的equals方法，返回值与==方法相同。
详述：①==和equals的实质。
在JAVA中利用"=="比较变量时,系统使用变量在"栈"中所存的值作为比较的依据。
基本数据类型在"栈"中存的是其内容值,而对象类型在"栈"中存的是地址,这些地址指向"堆"中的对象。
ng包中的Object类有public boolean equals(Object obj)方法,它比较两个对象是否相等。
其它对象的equals方法仅当被比较的两个引用指向的对象内容相同时,对象的equals()方法返回true。
总之,"=="和"!="比较的是地址.也可认为"=="和"!="比较的是对象句柄;而equals()比较的是对象内容.或者说"=="和"!="比较的是"栈"中的内容,而equals()比较的是"堆"中的内容.②==操作符。
专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相当，只能用==操作符。
Java的基本数据类型为(char，byte，short，int，long，float，double，boolean)。
java中的包含判断方法
java中的包含判断方法在Java中，可以使用多种方法来进行包含判断。
以下是一些常用的方法：1. 使用equals(方法进行相等判断：equals(方法是用来判断两个对象是否相等的方法。
对于基本类型，可以直接使用"=="来进行相等判断；对于对象类型，则需要使用equals(方法。
例如，对于字符串类型的比较，可以使用以下代码：```javaString str1 = "Hello";String str2 = "World";if (str1.equals(str2))System.out.println("str1 equals str2");} elseSystem.out.println("str1 not equals str2");}```2. 使用endsWith(方法判断字符串是否以指定后缀结尾：endsWith(方法用于判断字符串是否以指定的字符串结尾。
它返回一个布尔值，如果字符串以指定的字符串结尾，则返回true；否则返回false。
```java} else}```3. 使用contains(方法判断字符串是否包含指定的子字符串：contains(方法用于判断一个字符串是否包含指定的子字符串。
它返回一个布尔值，如果字符串包含指定的子字符串，则返回true；否则返回false。
例如，判断一个句子是否包含关键字"Java"，可以使用以下代码：```javaString sentence = "Java is a programming language";if (sentence.contains("Java"))System.out.println("The sentence contains the keyword Java");} elseSystem.out.println("The sentence does not contain the keyword Java");}```4. 使用containsAll(方法判断一个集合是否包含另一个集合：containsAll(方法用于判断一个集合是否包含另一个集合的所有元素。
==和equals的区别
在讲 == 和 equals 的区别前我们需要确认一下 Java 中的数据类型。
在Java中有基本数据类型和引用数据类型两种。
1、8种基本数据类型：四种整数类型(byte、short、int、long)两种浮点数类型(float、double)一种字符类型(char)一种布尔类型(boolean)2、引用数据类型：除了上面我们说的 8 种基本数据类型外，其他在Java中出现的类型都是引用数据类型。
如我们自己写了一个Dog类，而在上面说的8种基本数据类型中不包括Dog类型，所以Dog类型是隶属于引用数据类型的。
==的理解：要理解 == 我们学要从两个方面来理解：（1） == 两边为 8 种基本数据类型时：当 == 两边为8种基本数据类型时， == 判断的是两边变量中存放的内容是否相等。
例：public class Test {public static void main(String[] args) {int a = 10;int b = 10;if (a == b) {System.out.println("变量a和变量b中的值相等");}}}上面的例子的运行结果是在控制台中输出"变量a和变量b中的值相等" 我们可以看出当== 两边为8种基本数据类型时比较的时内容换句话说就是比较变量的值。
（2） == 两边为引用数据类型时：当 == 两边为引用数据类型时，== 判断的是引用数据类型的对象的内存地址是否一样，如果 == 比较的内存地址一样表示 == 两边是同一个对象，否则 == 两边不是同一个对象。
例：public class Test {public static void main(String[] args) {//在8中数据类型中没有String类型所以String是属于引用数据类型的String str1 = new String("abc");//在这里在创建一个str2对象让他的值和str1一样String str2 = new String("abc");//我们在用 == 来进行判断会发现 str1 == str2条件不成立我们可以看出这里比较的不是str1和str2的值if (str1 == str2) {System.out.println("对象str1和对象str2是同一对象，他们的内存地址相同");} else {System.out.println("对象str1和对象str2不是同一对象，他们的内存地址不相同"); }}}equals的理解：equals的理解就容易多了，equals他是一个方法，而方法只有对象才能拥有，所以equals 的左边一定是一个对象他的语法格式因该是：对象名.equals(比较的内容)。
==和equals有什么区别
== 和 equals有什么区别？在Java中比较两个数据是否相等有两种方式：一种是使用 == 进行比较；另外一种是使用equals进行比较。
== 可以比较基本数据类型也可以比较引用数据类型。
在比较基本数据类型的时候比较的是变量中的值是否相等，而比较引用数据类型的时候比较的是两个对象的地址是否相等（也就是看是否指向的是否为同一个对象），请看如下的示例代码。
基本数据类型：引用数据类型：此处对Student的比较可能第一感觉是true，为什么会有这样的错觉呢?因为我们使用现实生活中的眼光去观察这段代码发现名字和年龄都一样了，但是实际上从我们学过的Java程序上来看是false，因为我们new了两个对象，那么肯定会在堆内存中的分配两个不同的空间，而s1、s2分别存储的是这两个对象的空间地址，所以肯定不一样了，请看下面的示意图：看到这里很多同学感觉恍然大悟，哦……我懂了！于是就立马尝试使用equals方法进行比较，equals方法是Object类中定义的一个公共的示例方法，因此所有的对象都可以访问，立即测试：看到上面的结果，瞬间就不开心了，为什么equals比较结果还是false呢？其实这个时候我们应该这样想，上面比较的这句代码首相回到Student中去找equals方法，可是Student中并没有此方法，然后继续向上找父类（Object）,也就是说此处调用的是Object 中的equals方法，而此时我们并不知道Object中的此方法内部的比较规则是什么，所以……，来来来，撸码哥给你上源码：OK,一切尽在不言中（源码中）！但是，在实际开发中希望的结果并不是这样！举个示例，我们现在做的一个学生管理系统，那么从实际的业务上来看，该系统将会有判断两个学生是否是同一个学生的功能（一个系统中出现多个学习信息一样的将无法区分），而我们一般判断的标准是根据学生的一些特征进行判读，如姓名+年龄+性别+身高等等，这个时候就需要用到比较，== 显然不行，Object的equals规则和==一样，那么怎么办呢？此时我们可以在Student类中覆写Object中的equals方法，然后在方法里面写上我们自己的比较规则即可（假设上面的学生类按照姓名+年龄的方式进行比较），来来来，撸码哥给你上代码：在比较名字的时候其实使用equals更好，因为name是String类型的，也是引用类型，而Java在设计String类的时候已经在String类中覆写了Object中的equals方法，其中的规则是比较字符串的自面值是否相等。
判断两个对象是否相等的方法
判断两个对象是否相等的方法在程序设计中，判断两个对象是否相等是一项非常常见的任务。
在Java语言中，判断两个对象是否相等有多种方法，每种方法都有其适用的场景和优缺点。
下面我们将分步骤阐述几种常见的判断两个对象是否相等的方法。
第一步，使用“==”运算符判断两个对象是否相等。
在Java中，对象是通过引用来访问的，如果两个引用指向同一个对象，则这两个引用是相等的。
因此，使用“==”运算符判断两个对象是否相等时，实际上是在比较两个引用是否指向同一个对象。
如果两个引用是相等的，则它们指向同一个对象，也就是相等的；如果两个引用是不相等的，则它们指向不同的对象，也就是不相等的。
对于基本数据类型，使用“==”运算符比较时，实际上是比较它们所代表的值是否相等。
第二步，使用equals方法判断两个对象是否相等。
在Java中，所有的对象都继承了Object类，而Object类中有一个equals方法，它用来判断两个对象是否相等。
该方法有两个重载的版本：一个是没有任何参数的版本，另一个是有一个Object类型的参数的版本。
由于所有的对象都继承自Object类，因此，所有的对象都拥有一个没有参数的equals方法，该方法的默认实现是使用“==”运算符比较两个对象的引用是否相等。
但是，对于某些类而言，两个对象并不相等的条件并不是它们的引用是否相等，因此，有些类会重新实现equals方法，以使两个对象的比较更加准确。
第三步，使用hashCode方法判断两个对象是否相等。
在Java中，每个对象都有一个hashCode方法，该方法返回一个整数，用来表示该对象的哈希值。
哈希值是根据对象的属性计算出来的一个值，它具有唯一性和不可逆性。
由于两个不同的对象可以具有相同的哈希值，因此，在判断两个对象是否相等时，不能仅仅依赖于哈希值，而是要使用equals方法来比较两个对象的属性是否相等。
但是，在某些情况下，我们可以使用hashCode方法来优化程序的性能。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
java中equals和==的区别值类型是存储在内存中的堆栈（以后简称栈），而引用类型的变量在栈中仅仅是存储引用类型变量的地址，而其本身则存储在堆中。
==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。
equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。
==比较的是2个对象的地址，而equals比较的是2个对象的内容。
显然，当equals为true时，==不一定为true；一、Str ing中的equals和==1、public class TestString {public static void main(String[] args) {String s1 = "Monday";String s2 = "Monday";}}上面这段程序中，到底有几个对象呢？来检测一下吧，稍微改动一下程序public class TestString {public static void main(String[] args) {String s1 = "Monday";String s2 = "Monday";if (s1 == s2)System.out.println("s1 == s2");elseSystem.out.println("s1 != s2");}}编译并运行程序，输出：s1 == s2说明：s1 与s2 引用同一个Str ing 对象-- "Monday"!2.再稍微改动一下程序，会有更奇怪的发现：public class TestString {public static void main(String[] args) {String s1 = "Monday";String s2 = new String("Monday");if (s1 == s2)System.out.println("s1 == s2");elseSystem.out.println("s1 != s2");if (s1.equals(s2))System.out.println("s1 equals s2");elseSystem.out.println("s1 not equals s2");}}我们将s2 用new操作符创建程序输出：s1 != s2s1 equals s2说明：s1 s2分别引用了两个"Monday"Str ing对象3. 字符串缓冲池原来，程序在运行的时候会创建一个字符串缓冲池当使用s2 = "Monday" 这样的表达是创建字符串的时候，程序首先会在这个String缓冲池中寻找相同值的对象，在第一个程序中，s1先被放到了池中，所以在s2被创建的时候，程序找到了具有相同值的s1将s2 引用s1 所引用的对象"Monday"第二段程序中，使用了new操作符，他明白的告诉程序："我要一个新的！不要旧的！"于是一个新的"Monday"Sting对象被创建在内存中。
他们的值相同，但是位置不同，一个在池中游泳一个在岸边休息。
哎呀，真是资源浪费，明明是一样的非要分开做什么呢？4.再次更改程序：public class TestString {public static void main(String[] args) {String s1 = "Monday";String s2 = new String("Monday");s2 = s2.intern();if (s1 == s2)System.out.println("s1 == s2");elseSystem.out.println("s1 != s2");if (s1.equals(s2))System.out.println("s1 equals s2");elseSystem.out.println("s1 not equals s2");}}这次加入：s2 = s2.intern();程序输出：s1 == s2s1 equals s2原来，（ng.String的intern()方法"abc".intern()方法的返回值还是字符串"abc"，表面上看起来好像这个方法没什么用处。
但实际上，它做了个小动作：检查字符串池里是否存在"abc"这么一个字符串，如果存在，就返回池里的字符串；如果不存在，该方法会把"abc"添加到字符串池中，然后再返回它的引用。
）更好的办法：把所有的String都intern()到缓冲池去吧最好在用到new的时候就进行这个操作String s2 = new String("Monday").intern();然后就可以用==比较两个字符串的值了二、简单数据类型和封装类中的equals和==Java为每一个简单数据类型提供了一个封装类，每个基本数据类型可以封装成对象类型。
除int（Integer）和char（Char acter），其余类型首字母大写即成封装类类型名。
double (Double),float(Float),long(Long), short(Short),byte(Byte),boolean(Boolean).以int和Integer为例说明Java中int和Integer区别如下：1.int是基本的数据类型,默认值可以为0；2.Integer是int的封装类,默认值为null；3.int和Integer都可以表示某一个数值；4.int和Integer不能够互用，因为他们两种不同的数据类型；int a1=1;int a2=1;Integer b1 =new Integer (1);Integer b2 =new Integer (1);------------------------------a1==a2 这个是成立的,很简单,都知道a1==b1 这个是不成立的.表达式的值为false ,它们是不同的数据类型（在jdk1.5以上版本中为true）b1==b2 这个也是不成立的.表达式的值为false,虽然是相同的数据类型,但是它们是两个对象,==比较的是2个对象的地址,它们的地址是不相等的,内容相等都是1;b1.equals(b2)==true 这个是成立的,表达式的值为true. 相同数据类型,两个对象,地址不同,内容相同, quals比较的是2个对象的内容,所以成立。
(a.equals(b),因为equals比较的是两个对象，所以a,b都不能为基本数据类型，否则会出编译错误。
)（在jdk1.5以上版本中，b可以为基本数据类型，a不可以）同理,其它的封装类和基本类型也是这样的.java中equals和==的区别==比较的是2个对象的地址，而equals比较的是2个对象的内容。
在jdk1.5以上的版本中，基本类型和封装类能自动转化，与Str ing类型的对象和字符串常量类似。
Integer i1 = 123;Integer i2 = 123;int i = 123;Integer i3 = new Integer(123);Integer i4 = new Integer(123);System.out.println("i1 == i2 = "+(i1 == i2));System.out.println("i1.equals(i2) = "+(i1.equals(i2)));System.out.println();System.out.println("i3 == i4 = "+(i3 == i4));System.out.println("i3.equals(i4) = "+(i3.equals(i4)));System.out.println();System.out.println("i2 == i4 = "+(i2 == i4));System.out.println("i2.equals(i4) = "+(i2.equals(i4)));System.out.println();System.out.println("i == i2 = "+(i == i2));System.out.println("i1.equals(i) = "+(i1.equals(i)));System.out.println();System.out.println("i == i4 = "+(i == i4));System.out.println("i4.equals(i) = "+(i4.equals(i)));------------------------------i1 == i2 = truei1.equals(i2) = truei3 == i4 = falsei3.equals(i4) = truei2 == i4 = falsei2.equals(i4) = truei == i2 = truei1.equals(i) = truei == i4 = truei4.equals(i) = true三、其他类怎么使用equals和==API里的类大部分都重写了equals方法，没有重写的一般是自己写的类，如果是你自己定义的一个类，比较自定义类用equals和==是一样的，都是比较句柄地址，因为自定义的类是继承于object，而object中的equals就是用==来实现的，你可以看源码。
四、java里equals和hashCode之间什么关系只是为了维护hashCode 方法的常规协定,才要求用equals比较的两个对象的hashCode相同.equals()和hashCode()都来自ng.Object.你当然可以重写.比如a.equals(b).仅当a的内存地址相等时,才返回true.当然如String等类已经对这个方法进行了重写,比较的就不再是内存地址了.hashCode()的值也是与内存地址相关的.所以仅当内存地址相等时,hashCode才相等.同样很多类也重写了这个方法,还是以String为例:public int hashCode() {int h = hash;if (h == 0) {int off = offset;char val[] = value;int len = count;for (int i = 0; i < len; i++) {h = 31*h + val[off++];}hash = h;}return h;}就不在与内存地址相关了.这样做是为了保证用equals比较返回为true的两个对象,他们的hashCode是相同的.所以一般重写equals的时候都会重写hashCode().当然,这个相当于一个约定,一个协议.你不这么做并不会错.五、hashCode在一般的应用中你不需要了解hashcode的用法，但当你用到hashmap，hashset等集合类时要注意下hashcode。