equ

equally [5i:kwElI] adv. (1) 平等地，相等地 treated them equally 平等对待他们 Divide it equally. 平均分配这个。 (2) 同样地 equally important 同样重要 The two girls can run equally fast. 这两个女孩能跑得一样快。

equally是平等。英语单词equally，主要用作副词，作副词时译为“同样地；相等地，平等地；公平地”。equally造句1、If the 20th-century entertainment industry was about hits,the 21st will be equally about misses.如果说20世纪的娱乐业是以流行内容为主导的，那么在21世纪，那些非流行的内容将占据同样重要的位置。2、The incident also could have been caused or exacerbated by coal dust,which is equally combustible.这起灾难也可能是由于煤渣引起的，煤渣也同样易燃。3、All these techniques are equally effective.所有这些方法都同等有效。4、Equally important,establish a realistic advertising budget.同样重要的是，建立一个切合实际的广告预算。5、They decide to divide equally the profit.他们决定平分利润。6、This star is clearly not the pulsar as it is about equally bright on both exposures.这颗星很明显不是，中子星，因为它几乎，在两次曝光中一样亮。

["i:kwu0259ls] 伊扩斯

equals[u02c8i:kwu0259lz] n.同样的人( equal的名词复数 )； 相等的数量； 能与之比拟的东西； （地位、实力等）相同的人v.比得上( equal的第三人称单数 )； （质量等方面）赶得上； 与…相等或相同； 使（某物）等于

equals是比较值，只能用于引用类型作比较，比如Integera=1;Integerb=1;就可以用a.equals(b)，原生数据类型不能用此方法比较值，如inta=1;intb=1;要比较，只能用==；对于引用类型，==是比较引用地址，如Integera=1;Integerb=newInteger(1);如果用equals比较，结果为true，用==比较，结果为false

改这句if(password.equals(temp)) 试试if(password.trim().equals(temp.trim()))

简单点说，==比较的是内存地址，而equals比较是的内容本身。比如：String s1 = "abcd"; String s2 = "abcd";String s3 = new String("abc"); String s4 = new String("abc");s1 == s2 和 s1.equals(s2) 以及s3.equals(s4) 均返回true，而s3 == s4返回false。首先s1.equals(s2)与s3.equals(s4) 我相信你能理解，它们比较是两个字符串本身是否相同。而s1 == s2为什么也是返回true呢？因为字符串用String s = "";这种方式定义的时候，虽然它也是对象，但是在比较的时候它默认会调用equals方法，所以返回的结果和equals比较的结果一样都是true，最后s3 == s4比较的就真是的它们在内存中的地址，很显然是不相同的，因此是false。然后说一下equals方法重写：比如我定义了类Person，表示人，然后定义2个对象：Person p1 = Person("张三"); 和 Person p2 = Person("张三");不考虑重名的情况，假设我这里指的就是同一个人，但是我此时比较p1 == p2或者p1.equals(p2)返回的都是false，这是因为前者比较的是内存地址，结果不一样，后者比较的是HashCode，你也可以当作内存地址理解，也是不一样的。但是假如重写equals方法：@Overridepublic boolean equals(Person p) {return this.name.equals(p.name);}之后再调用p1.equals(p2) 就会返回true，是想要的结果。

可以具体点吗？

Object类是所有类的基类，而equals方法也是源自这个类。这个类中关于equals方法的定义就是：public boolean equals(Object obj) { return (this == obj);}所以在不重载这个方法的前提下，equals和==是等价的(bool环，集合划分的等价关系，自己去网上了解一下)。但是，Object类中没有定义任何一个方法，return的是(this != obj)，所以没有一个与equals相反的方法。要达到你的效果，就用!吧，just like what chelin_kaka has said.

“＝＝”是看两个对象是否是同一个对象，也就是两个对象引用是否指向同一个对象（Java分配的内存地址一样）当然如果用于int,long,double就不是看两个值是否相等了。　　equals()是比较两个对象的内容是否相等，一般如果用户自己不定义针对自己的类的equals()方法，那么就会使用Object的活着你的类的父类的这个方法。如果你的类里没有对象引用的域，就不必要覆盖equals()（注意String域也是对象）String有自己的equals()方法（它已经覆盖了Object的该方法了。

因为你的Value类没有重写equals 方法，这个方法是在Object类中定义的，是可以自己按照需要进行重写的，如果没有重写，其默认的逻辑是比较两个相互equals 的对象的内存地址是不是同一个地址，第一个输出的时候v1,v2都是new出来的，所以v1和v2在堆中是不同的内存地址，所以equals结果为falsex0dx0a第二个输出，其调用的是Integer类的equals，Integer类中有重写原有equals方法的逻辑，其逻辑是比较两个Integer对象中封装的数字的值，如果相同就返回true，因此第二个输出truex0dx0a第三个输出false原理同第一个，两个对象之间使用==比较的就是内存地址，因为都是new出来的，堆内存地址不同，所以输出falsex0dx0a简单来讲，如果来自同一个类的两个对象，如果没有重写equals方法的逻辑，其==结果和equals结果是相同的，如果有重写equals方法，则==和equals结果可能会不同

（单独把一个东西说清楚，然后再说清楚另一个，这样，它们的区别自然就出来了，混在一起说，则很难说清楚）==操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如Objet obj = new Object();变量obj是一个内存，new Object()是另一个内存，此时，变量obj 所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用==操作符进行比较。equals 方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。例如，对于下面的代码：String a=new String("foo");String b=new String("foo");两条new 语句创建了两个对象，然后用a,b 这两个变量分别指向了其中一个对象，这是两个不同的对象，它们的首地址是不同的，即a 和b 中存储的数值是不相同的，所以，表达式a==b 将返回false，而这两个对象中的内容是相同的，所以，表达式a.equals(b)将返回true。在实际开发中，我们经常要比较传递进行来的字符串内容是否等，例如，String input= …;input.equals(“quit”)，许多人稍不注意就使用==进行比较了，这是错误的，随便从网上找几个项目实战的教学视频看看，里面就有大量这样的错误。记住，字符串的比较基本上都是使用equals方法。如果一个类没有自己定义equals方法，那么它将继承Object 类的equals方法，Object类的equals方法的实现代码如下：boolean equals(Object o){return this==o;}这说明，如果一个类没有自己定义equals 方法，它默认的equals 方法（从Object 类继承的）就是使用==操作符，也是在比较两个变量指向的对象是否是同一对象，这时候使用equals和使用==会得到同样的结果，如果比较的是两个独立的对象则总返回false。如果你编写的类希望能够比较该类创建的两个实例对内容是相同的。

equals() 是对象的一般方法 比如说 String s1,s2 ;s1.equals(s2) ; 判断 s1和s2是否相等

1、使用equals( )方法比较两个字符串是否相等。它具有如下的一般形式：boolean equals(Object str)这里str是一个用来与调用字符串（String）对象做比较的字符串（String）对象。如果两个字符串具有相同的字符和长度，它返回true，否则返回false。这种比较是区分大小写的。2、为了执行忽略大小写的比较，可以调用equalsIgnoreCase( )方法。当比较两个字符串时，它会认为A-Z和a-z是一样的。其一般形式如下：boolean equalsIgnoreCase(String str)这里，str是一个用来与调用字符串（String）对象做比较的字符串（String）对象。如果两个字符串具有相同的字符和长度，它也返回true，否则返回false。下面的例子说明了equals( )和equalsIgnoreCase( )方法：class equalsDemo {public static void main(String args[]) {String s1 = "Hello";String s2 = "Hello";String s3 = "Good-bye";String s4 = "HELLO";System.out.println(s1 + " equals " + s2 + " -> " +s1.equals(s2));System.out.println(s1 + " equals " + s3 + " -> " +s1.equals(s3));System.out.println(s1 + " equals " + s4 + " -> " +s1.equals(s4));System.out.println(s1 + " equalsIgnoreCase " + s4 + " -> " +s1.equalsIgnoreCase(s4));}}该程序的输出如下所示：Hello equals Hello -> trueHello equals Good-bye -> falseHello equals HELLO -> falseHello equalsIgnoreCase HELLO -> true

Object是根类啊 不同的类是要继承对象的，对Object来说，它所做的事情就是判断比较的两个引用指向的是不是同一个对象。不同的类的equals是不同的，如果你自己实现一个类，你想判断两个引用是否equals，你可以重写equals方法用你需要的逻辑。

2楼说的很好。。。

一苦喔斯

1、java中equals和==的区别 值类型是存储在内存中的堆栈（简称栈），而引用类型的变量在栈中仅仅是存储引用类型变量的地址，而其本身则存储在堆中。2、==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。3、equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。4、==比较的是2个对象的地址，而equals比较的是2个对象的内容，显然，当equals为true时，==不一定为true。

数组equals方法无法重写，要比较2个数组使用java.util.Arrays.equals(a1,a2);

1、java中equals和==的区别 值类型是存储在内存中的堆栈（简称栈），而引用类型的变量在栈中仅仅是存储引用类型变量的地址，而其本身则存储在堆中。2、==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。3、equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。4、==比较的是2个对象的地址，而equals比较的是2个对象的内容，显然，当equals为true时，==不一定为true。

equalsIgnoreCase不区分大小写

equals是比较值，只能用于引用类型作比较，比如Integer a=1;Integer b=1;就可以用a.equals(b)，原生数据类型不能用此方法比较值，如 int a=1;int b=1;要比较，只能用==；对于引用类型，==是比较引用地址，如Integer a=1;Integer b=new Integer(1);如果用equals比较，结果为true，用==比较，结果为false

public class Demo1{ public static void main(String args[]){ Demo2 d1=new Demo2("张三","123"); d1.print(); Demo2 d2=new Demo2("李四","456"); d2.print(); if (d1.equals(d2)){ System.out.println("两个对象一样"); } else{System.out.println("两个对象不一样");} if (d1==(d2)){ System.out.println("两个对象内容相同"); } else{System.out.println("两个对象内容不相同");} }}class Demo2{ String name; String password; public Demo2(String na,String pa){ name=na;password=pa; } public void print(){ System.out.println("对象的name值为："+name+"password值为："+password); }}

=号，在Java里面不是比较，=号叫做赋值符号，注意: =号左边必须是变量！也就是说，把右边的内容拷贝给左边这个变量了，比如int i = 1; 那么int类型变量i的值就是1 了下面帮你详尽分析一下这个程序：public class Example1{public static void main(String[] args){String s1=new String("abc");String s2=new String("abc");s1=s2;System.out.println(s1==s2); //true}}内存中真实的情况是这样的，现在，main方法开始执行，首先第一句话， String s1=new String("abc"); 执行这句话的时候，是new一个String对象，势必调用String类的构造方法，把参数 "abc" 传进去，"abc"是一个字符串常量，字符串常量是String类的一个对象，字符串常量分配在内存的data segment(数据区),现在数据区就有了一个"abc"对象，然后紧接着new String("abc")，又new了一个String对象，new出来的对象分配在内存的heap(堆区)，现在堆内存就有了一个new出来的String对象，方法内部声明的变量属于局部变量，s1是在main方法内部声明的，显然属于局部变量，局部变量分配在内存的Stack(栈区)，现在栈区分配了一个String类型的变量s1，因为String是类，不是基本数据类型，String类是引用数据类型，所以s1在Java里面的标准叫法是引用，s1的值就是一个地址，通过这个地址，就可以找到这个new出来的这个String对象，所以，用一句话来描述：引用s1指向了堆内存中new出来的这个String对象，执行完第一句话以后，内存中有2个String对象现在执行第2句话，String s2=new String("abc");Java虚拟机对于data segment的内容会有一个优化，就是如果已经存在，就不再分配第二个了，因为执行第一句的时候，data segment 已经有一个"abc"了，那么现在就不会分配第二个同样的了，现在，直接new了一个String对象， 引用s2指向了他，所以第2句话只分配了一个对象，执行完第2句话，现在内存中一共有3个String对象了，2个位于heap，1个"abc"位于data segment然后第3句话，s1=s2;=号，在Java里面不是比较，=号叫做赋值符号，是赋值的意思，注意: =号左边必须是变量！也就是说把右边的内容拷贝给左边这个变量，在我们这里，在执行这句话之前，引用s1和s2分别各自指向了堆中的一个String对象，s1和s2的值分别是这两个String对象的地址，因为是两个对象，所以两个地址肯定是不一样的，但是现在，s1=s2 ，就把s2的值拷贝给s1了，就把s2记录的地址拷贝给是s1了，换句话说，s1和s2的值一样了，s1和s2具有相同的地址了，s1和s2此时指向同一个对象了，s1也指向先s2所指向的这个对象了，s1和s2现在都指向这个对象，他们的引用地址相同了！最后一句，System.out.println(s1==s2);打印出 s1==s2 的结果，==比较的是引用地址，现在s1和s2指向同一对象，引用地址当然相同，所以打印结果为 true然后main方法就执行结束了，注意：方法结束以后，为这个方法分配的所有局部变量，全部清空，全部消失,所以这些String对象已经没有引用指向他们了，这就是传说中的垃圾，他们等待垃圾回收器回收总结：= 是赋值== 比较引用地址再说equals方法，有些人上来就说equals方法比较的内容，其实这是不全面的，equals方法和==的区别，面试也经常考，equals方法是父类Object所定义的方法，用来实现两个对象内容是否相等的逻辑，说equals方法要从两个方面:1)从Object角度来说，==与equals是一样的，都是比较引用，因为Object类的equals()方法这样定义的， public boolean equals(Object obj) { return (this == obj); }方法内部的实现就是比较引用地址，用的也是==号，所以对于Object来讲，equals与==是一样的2）对于其它类来说，可以根据需要，在自定义的类中重写(Override) equals方法，实现内容是否相等的逻辑，因为String类重写了equals方法，所以我们才说String的equals比较的是两个字符串的内容

java.lang.String.equals() 方法比较字符串与指定的对象。其结果是true当且仅当参数不为null，并且是一个String对象，这个对象表示相同的字符序列声明以下是声明java.lang.String.equals()方法public boolean equals(Object anObject)参数anObject -- 这是这个String对比较的对象返回值此方法返回true如果给定对象代表一个字符串，这个字符串，否则返回false异常NA实例下面的例子显示使用的java.lang.String.equals()方法package com.pieryon;import java.lang.*;public class StringDemo {public static void main(String[] args) {String str1 = "sachin tendulkar";String str2 = "amrood admin";String str3 = "amrood admin";// checking for equalityboolean retval1 = str2.equals(str1);boolean retval2 = str2.equals(str3);// prints the return valueSystem.out.println("str2 is equal to str1 = " + retval1);System.out.println("str2 is equal to str3 = " + retval2);}}编译和运行上面的程序，这将产生以下结果：str2 is equal to str1 = falsestr2 is equal to str3 = true

java的equals和contains的区别：1、功能不同equals指示其他某个对象是否与此对象“相等”。contains当且仅当此字符串包含指定的 char 值序列时，返回 true。2、用法不同equals实现对象上差别可能性最大的相等关系；即，对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true（x == y 具有值 true）。contains常用与集合中判断某个对象是否含有这个元素。3、含义不同equals是比较两个东西是否等同，适用于任何类别的对象。contains是是否包含的意思，左边的对象是一个容器了。4、参数不同equals参数为obj - 要与之比较的引用对象。contains参数为s - 要搜索的序列。参考资料来源：百度百科——equals百度百科——contains()

功能不同： "=="是判断两个变量或实例是不是指向同一个内存空间。 "equals"是判断两个变量或实例所指向的内存空间的值是不是相同。 扩展资料 　　运行速度不同： 　　"=="比"equals"运行速度快，因为"=="只是比较引用。 　　"equals"比"=="运行速度要慢。 　　equals()方法特点： 　　1、自反性：x.equals（x）返回true； 　　2、对称性：若x.equals（y）为true，则y.equals（x）亦为true； 　　3、传递性：若x.equals（y）为true且y.equals（z）也为true，则x.equals（z）亦为true； 　　4、一致性：x.equals（y）的"第一次调用为true，那么x.equals（y）的第二次、第三次、第n次调用也均为true，前提条件是没有修改x也没有修改y； 　　5、对于非空引用x，x.equals（null）永远返回为false。

equalsignorecase不区分大小写

AequalsB.用法是正确的。句中equal是及物动词，后直接接宾语B。因主语A是第三人称单数形式，所以谓语动词用三单形式equals。AequalstoB.用法是错误的，应改为AisequaltoB.beequalto是一个介词短语，固定用法，句中equal用作形容词，后面接介词to。因主语A是第三人称单数形式，所以be动词用三单形式is。请看equal的用法：1.equal用作形容词，表示“相同的”“相等的”等。如：Theyrefusedtotreatwithusonequalterms.他们拒绝在平等的基础上与我们谈判。用于beequalto表示“等于”“能胜任”“能应付”等，其中的to是介词(其后接动词时应用动名词)。如:Thisisequaltosayingthatheknowsherwell.这就等于说他很熟悉她。有时可用其他连系动词代替be。如：Shedidn"tfeelequaltoreceivingvisitors.她感到身体不适，不能会客。2.equal用作动词，意为“等于”、“比得上”等，是及物动词，不要受其形容词用法的影响，在其后加介词to。如：Nomanequalshiminstrength.没有谁的力气比得上他。但是不能说：Nomanequalstohiminstrength.3.equal用作名词，意为“相等的事物”“(地位等)相同的人”等，是可数名词。如：Noonecouldbehisequalattellingastory.讲故事没有比得上他。

你要比较数组啊还是字符串啊

解释一下==号，他比较的是一个对象在内存中的地址值， 比如2个字符串对象 String s1 = new String("str"); String s2 = new String("str"); 如果用==号比较，会返回false，因为创建了两个对象，他们在内存中地址的位置是不一样的。 equals的情况比较复杂，它是java.lang.Object类中的一个方法。因为java中所有的类都默认继承于Object，所以所有的类都有这个方法。 在Object类源码中是这样写的。 public boolean equals(Object obj) { return (this == obj); } 他同样使用==号进行内存地址的比较。但是许多java类中都重写了这个方法，比如String。 public boolean equals(Object anObject) { if (this == anObject) { return true; } if (anObject instanceof String) { String anotherString = (String)anObject; int n = count; if (n == anotherString.count) { char v1[] = value; char v2[] = anotherString.value; int i = offset; int j = anotherString.offset; while (n-- != 0) { if (v1[i++] != v2[j++]) return false; } return true; } } return false; } String里的方法，如果==号比较不相等，还会进行一下值的比较。 所以equals方法具体的作用要看当前的那个类是如何实现重写父类中该方法的。如果没有重写该方法，那么他和==号等价。

==是比较引用地址。 equals是根据方法内定义的规则比较是否“相等”。如String的equals比较的是内容，Long比较的是数值。

意思就是判断adimin与username是否相等,相等返回true,不相等返回false,你要弄明白==和equals区别,==是比较地址,equals是比较值.equals()是方法没错,正是字符串String的方法,所以字符串可以调用它

字符串对象的比较操作equals区分大小写equalsIgnoreCase不区分大小写

equals()：反映的是对象或变量具体的值，即两个对象里面包含的值--可能是对象的引用，也可能是值类型的值。hashCode()：计算出对象实例的哈希码，并返回哈希码，又称为散列函数。根类Object的hashCode()方法的计算依赖于对象实例的D（内存地址），故每个Object对象的hashCode都是唯一的；当然，当对象所对应的类重写了hashCode()方法时，结果就截然不同了。　　之所以有hashCode方法，是因为在批量的对象比较中，hashCode要比equals来得快，很多集合都用到了hashCode，比如HashTable。　　两个obj，如果equals()相等，hashCode()一定相等。　　两个obj，如果hashCode()相等，equals()不一定相等（Hash散列值有冲突的情况，虽然概率很低）。所以：　　可以考虑在集合中，判断两个对象是否相等的规则是：　　　　第一步，如果hashCode()相等，则查看第二步，否则不相等;　　　　第二步，查看equals()是否相等，如果相等，则两obj相等，否则还是不相等。1、首先equals()和hashcode()这两个方法都是从object类中继承过来的。　　equals()是对两个对象的地址值进行的比较（即比较引用是否相同）。　　hashCode()是一个本地方法，它的实现是根据本地机器相关的。2、Java语言对equals()的要求如下，这些要求是必须遵循的：　　A对称性：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。　　B反射性：x.equals(x)必须返回是“true”。　　C类推性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。　　D一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。　　任何情况下，x.equals(null)，永远返回是“false”；x.equals(和x不同类型的对象)永远返回是“false”。3、equals()相等的两个对象，hashcode()一定相等；　　反过来：hashcode()不等，一定能推出equals()也不等；　　hashcode()相等，equals()可能相等，也可能不等。

1. == 号和equals()方法都是比较是否相等的方法2. ==号在比较基本数据类型时比较的是值，而用==号比较两个对象时比较的是两个对象的地址值：int x = 10;int y = 10;String str1 = new String("abc");String str2 = new String("abc");System.out.println(x == y); // 输出trueSystem.out.println(str1 == str2); // 输出false3. equals()方法存在于Object类中，因为Object类是所有类的直接或间接父类，也就是说所有的类中的equals()方法都继承自Object类，而通过源码我们发现，Object类中equals()方法底层依赖的是==号，那么，在所有没有重写equals()方法的类中，调用equals()方法其实和使用==号的效果一样，也是比较的地址值，然而，Java提供的所有类中，绝大多数类都重写了equals()方法，重写后的equals()方法一般都是比较两个对象的值

给你澄清几个概念，然后再说equals，有助理解，如不感兴趣，可越过此部分。知道什么是引用不？引用也就是引用变量，Java中的变量按照数据类型，可以分为两种，一种是基本数据类型变量，一种是引用数据类型变量：基本数据类型变量：byte，short，char，int，long，float，double，boolean，以这8种基本数据类型声明的变量，如：int i；基本数据类型变量：到目前为止引用数据类型包括 类，接口，数组，枚举，注解，以它们声明的变量叫做引用变量，或者引用，如：String s1 = new String("abc");String s2 = "abc";引用s1里面存的是一个地址，地址什么样你不用管，就知道 通过这个地址就可以准确的找到上面这个new出来的String对象，所以我们说，引用s1指向了这个String对象。同样，s2也指向了一个String对象。再说 == 和 equals 的区别：s1 == s2 是true还是false？== 比较的是引用地址，换句话说，==号两边的这两个变量所记录的地址是不是相同，用new关键字new出来的对象位于内存的堆区，"abc"是一个字符串常量，Java中字符串常量也是String类的一个对象，字符串常量被分配在内存的data segment（数据区），现在它们是两个不同的对象，s1指向new出来的这个，s2指向这个字符串常量，s1和s2指向的是不同的对象，它们的引用地址当然不同，毫无疑问表达式返回false。再说equals方法，s1.equals(s2) 是true还是false？有些人上来就说equals方法比较的内容，其实这是不全面的，equals方法和==的区别，面试也经常考，equals方法是父类Object所定义的方法，用来实现两个对象内容是否相等的逻辑，说equals方法要从两个方面:1)从Object角度来说，==与equals是一样的，都是比较引用，因为Object类的equals()方法是这样定义的， public boolean equals(Object obj) { return (this == obj); }方法内部的实现就是比较引用地址，用的也是==号，所以对于Object来讲，equals与==是一样的。2）对于其它类来说，可以根据需要，在自定义的类中重写(Override) equals方法，实现内容是否相等的逻辑，因为String类重写了equals方法，所以我们才说String的equals比较的是两个字符串的内容，内容就是"abc"，第一个new出来的时候传入构造方法的实参就是"abc"，第二个字符串常量也是"abc"，它们虽然是两个不同的对象，但是它们的内容相同，所以s1.equals(s2)返回真，它们相等。我再给你写一个，String s3 = "abc"; String s4 = new String("abc");s2 == s3 是真是假？答案是true，注意，Java虚拟机 对于内存数据区里面的内容有一个优化，如果已经存在了，不会分配第二个，上面已经 String s2 = "abc";了， 这个"abc"已经存在了，下面String s3 = "abc"; 就不会分配第二个"abc"了，那么s3指向谁？s3也指向上面s2指向的这个对象，现在是s2和s3同时指向同一个对象，那么它们的地址当然一样，==比较的是引用地址，所以s2 == s3 返回true。s2.equals(s3) 呢？ 都是同一个对象了，那自己和自己内容还能不一样？返回true。s1 == s4 是真是假？答案是false，注意，使用new关键字生成的对象分配在内存的堆区（heap），并且只要是用了new关键字了，不管你new多少个，内容是否一样，它们都是不同的对象，new一个就出现一个新的，所以s4指向的这个对象，和s1指向的这个是两个不同的对象，地址不同， 因此s1 == s4为false，使用equals比较返回true，因为内容相同。

java中equals()返回boolean值，true表示相等，false表示不相等。不等于就是对上面的结果取反，！a.equals(b)。Java中equals的区别。可用于基本类型和引用类型：当用于基本类型时候，是比较值是否相同；当用于引用类型的时候，是比较对象是否相同。对于String a = “a”; Integer b = 1;这种类型的特有对象创建方式，==的时候值是相同的基本类型没有equals方法，equals只比较值（对象中的内容）是否相同（相同返回true）。一个类如果没有定义equals方法，它将默认继承Object中的equals方法，返回值与==方法相同。

java中的数据类型，可分为两类： 1.基本数据类型，也称原始数据类型。byte,short,char,int,long,float,double,boolean 他们之间的比较，应用双等号（==）,比较的是他们的值。 2.复合数据类型(类) 当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。 JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地 址，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。 对于复合数据类型之间进行equals比较，在没有覆写equals方法的情况下，他们之间的比较还是基于他们在内存中的存放位置的地址值的，因为Object的equals方法也是用双等号（==）进行比较的，所以比较后的结果跟双等号（==）的结果相同。1 public class TestString { 2 public static void main(String[] args) { 3 String s1 = "Monday"; 4 String s2 = "Monday"; 5 if (s1 == s2) 6 { 7 System.out.println("s1 == s2");} 8 else{ 9 System.out.println("s1 != s2");}10 }11 }编译并运行程序，输出：s1 == s2说明：s1 与 s2 引用同一个 String 对象 -- "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");}else{System.out.println("s1 != s2");}if (s1.equals(s2)) {System.out.println("s1 equals s2");}else{System.out.println("s1 not equals s2");}}}我们将s2用new操作符创建程序输出：s1 != s2s1 equals s2说明：s1 s2分别引用了两个"Monday"String对象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");}else{System.out.println("s1 != s2");}if (s1.equals(s2)) {System.out.println("s1 equals s2");}else{System.out.println("s1 not equals s2");}}}这次加入：s2 = s2.intern();程序输出：s1 == s2s1 equals s2原 来，（java.lang.String的intern()方法"abc".intern()方法的返回值还是字符串"abc"，表面上看起来好像这个方 法没什么用处。但实际上，它做了个小动作：检查字符串池里是否存在"abc"这么一个字符串，如果存在，就返回池里的字符串；如果不存在，该方法会 把"abc"添加到字符串池中，然后再返回它的引用。）

equals是完全相等，equalsIgnoreCase是忽略大小写之后相等String a = "hello";String b = "Hello";String c = "hello";那么：a.equals(c) 结果为trua.equalsIgnoreCase(b) 结果为 true

这个应该是指 等号 键，就是 = 这个符号，在键盘数字0的右边第二个

不会

在string类中的equals（）是用于判断字符串内容是否相同，相同返回ture，否则返回false

也可以用。生僻字匹配是指相近或等同于，而equals英文意思等于或等同于。所以可以用。

equals()是object的方法,所以只是适合对象,不适合于基本类型,equals()默认是用"=="比较两个对象的内存地址,如果想要比较两个对象的内容,要重写equals()方法才可。equal:是用来比较两个对象内部的内容是否相等的，由于所有的类都是继承自java.lang.Object类的，所以如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的equal方法返回的却是==的判断，因此，如果在没有进行该方法的覆盖后，调用该方法是没有任何意义的。

判断ultraGrid1.Rows[i].Cells["订单号"].Value.ToString()与panduan的值是不是一样，如果一样返回true，否则返回false

equals 对象？

你说的是什么语言里的

解释一下==号,他比较的是一个对象在内存中的地址值,比如2个字符串对象String s1 = new String("str");String s2 = new String("str");如果用==号比较,会返回false,因为创建了两个对象,他们在内存中地址的位置是不一样的.equals的情况比较复杂,它是java.lang.Object类中的一个方法.因为java中所有的类都默认继承于Object,所以所有的类都有这个方法.在Object类源码中是这样写的.public boolean equals(Object obj) {return (this == obj);}他同样使用==号进行内存地址的比较.但是许多java类中都重写了这个方法,比如String.public boolean equals(Object anObject) {if (this == anObject) {return true;}if (anObject instanceof String) {String anotherString = (String)anObject;int n = count;if (n == anotherString.count) {char v1[] = value;char v2[] = anotherString.value;int i = offset;int j = anotherString.offset;while (n-- != 0) {if (v1[i++] != v2[j++])return false;}return true;}}return false;}String里的方法,如果==号比较不相等,还会进行一下值的比较.所以equals方法具体的作用要看当前的那个类是如何实现重写父类中该方法的.如果没有重写该方法,那么他和==号等价.

!xxx.equals(xxx)

一个是比地址 一个是比值,

equals的作用是对字符串进行比较,返回boolean类型，一致返回true,不一致返回false.1楼是正确的，对于取不相等，就的用关系运算符：||、&&、！(或、与、非)

在加减乘除时 用equal 用作verb 时第三身单数要加s 用作noun 时则众数要加s. 例: 1 + 1 equals 2. (verb) 1 x 1 is the equal of 1 / 1 is 用作第三身单数 are 则用作第一 二身及众数. make 等动词在第三身单数时要加s = makes 第一 二身及众数时用原式. equal can be a verb or an adjective . When it is used as an adjective it can be followed by "to " e.g. Women are demanding equal pay for equal work ie. equal to that of men. When it is used as a verb it cannot be followed by "to" e.g. 1+1 equals 2. 参考: me Equal doesn"t need to be used in 加减乘除 because it needs to have an "s" so we need to use equals. 其他 I don"t know sorry...... 参考: myself

　　1、java中equals和==的区别 值类型是存储在内存中的堆栈（简称栈），而引用类型的变量在栈中仅仅是存储引用类型变量的地址，而其本身则存储在堆中。　　2、==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。　　3、equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。　　4、==比较的是2个对象的地址，而equals比较的是2个对象的内容，显然，当equals为true时，==不一定为true。

一般用于字符串对象的比较。比较的是对象的值。

和equals的区别是功能不同，定义不同，运行速度不同。1、功能不同"=="是判断两个变量或实例是不是指向同一个内存空间。"equals"是判断两个变量或实例所指向的内存空间的值是不是相同。2、定义不同"equals"在JAVA中是一个方法。"=="在JAVA中只是一个运算符合。3、运行速度不同"=="比"equals"运行速度快，因为"=="只是比较引用。"equals"比"=="运行速度要慢。==既可以比较基本类型也可以比较引用类型 ，对于基本类型就是比较值，对于引用类型比较的就是内存地址，equals是属于java.lang.Ojbect类里的方法，如果该方法没有被重写过，默认也是==。我们可以看到string类的equals方法是被重写过的，而且string类在日常开发中用的比较多，久而久之，就形成了equals是比较值得错误观点，具体要看这里有没有重写Ojbect的hashCode方法和equals方法来判断。

=号，在Java里面不是比较，=号叫做赋值符号，注意: =号左边必须是变量！也就是说，把右边的内容拷贝给左边这个变量了，比如int i = 1; 那么int类型变量i的值就是1 了下面帮你详尽分析一下这个程序：public class Example1{public static void main(String[] args){String s1=new String("abc");String s2=new String("abc");s1=s2;System.out.println(s1==s2); //true}}内存中真实的情况是这样的，现在，main方法开始执行，首先第一句话， String s1=new String("abc"); 执行这句话的时候，是new一个String对象，势必调用String类的构造方法，把参数 "abc" 传进去，"abc"是一个字符串常量，字符串常量是String类的一个对象，字符串常量分配在内存的data segment(数据区),现在数据区就有了一个"abc"对象，然后紧接着new String("abc")，又new了一个String对象，new出来的对象分配在内存的heap(堆区)，现在堆内存就有了一个new出来的String对象，方法内部声明的变量属于局部变量，s1是在main方法内部声明的，显然属于局部变量，局部变量分配在内存的Stack(栈区)，现在栈区分配了一个String类型的变量s1，因为String是类，不是基本数据类型，String类是引用数据类型，所以s1在Java里面的标准叫法是引用，s1的值就是一个地址，通过这个地址，就可以找到这个new出来的这个String对象，所以，用一句话来描述：引用s1指向了堆内存中new出来的这个String对象，执行完第一句话以后，内存中有2个String对象现在执行第2句话，String s2=new String("abc");Java虚拟机对于data segment的内容会有一个优化，就是如果已经存在，就不再分配第二个了，因为执行第一句的时候，data segment 已经有一个"abc"了，那么现在就不会分配第二个同样的了，现在，直接new了一个String对象， 引用s2指向了他，所以第2句话只分配了一个对象，执行完第2句话，现在内存中一共有3个String对象了，2个位于heap，1个"abc"位于data segment然后第3句话，s1=s2;=号，在Java里面不是比较，=号叫做赋值符号，是赋值的意思，注意: =号左边必须是变量！也就是说把右边的内容拷贝给左边这个变量，在我们这里，在执行这句话之前，引用s1和s2分别各自指向了堆中的一个String对象，s1和s2的值分别是这两个String对象的地址，因为是两个对象，所以两个地址肯定是不一样的，但是现在，s1=s2 ，就把s2的值拷贝给s1了，就把s2记录的地址拷贝给是s1了，换句话说，s1和s2的值一样了，s1和s2具有相同的地址了，s1和s2此时指向同一个对象了，s1也指向先s2所指向的这个对象了，s1和s2现在都指向这个对象，他们的引用地址相同了！最后一句，System.out.println(s1==s2);打印出 s1==s2 的结果，==比较的是引用地址，现在s1和s2指向同一对象，引用地址当然相同，所以打印结果为 true然后main方法就执行结束了，注意：方法结束以后，为这个方法分配的所有局部变量，全部清空，全部消失,所以这些String对象已经没有引用指向他们了，这就是传说中的垃圾，他们等待垃圾回收器回收总结：= 是赋值== 比较引用地址再说equals方法，有些人上来就说equals方法比较的内容，其实这是不全面的，equals方法和==的区别，面试也经常考，equals方法是父类Object所定义的方法，用来实现两个对象内容是否相等的逻辑，说equals方法要从两个方面:1)从Object角度来说，==与equals是一样的，都是比较引用，因为Object类的equals()方法这样定义的， public boolean equals(Object obj) { return (this == obj); }方法内部的实现就是比较引用地址，用的也是==号，所以对于Object来讲，equals与==是一样的2）对于其它类来说，可以根据需要，在自定义的类中重写(Override) equals方法，实现内容是否相等的逻辑，因为String类重写了equals方法，所以我们才说String的equals比较的是两个字符串的内容

1、equals，读音：美/u02c8iu02d0kwu0259lz/；英/i:kwu0259lz/。 2、释义：n.对手；（地位、实力等）相同或相等的人；相等物（equal的复数形式）。v.平等（equal的第三人称单数形式）；与…相同。 3、例句：6 multiplied by 2 equals 12.6乘以2等于12。

1. == 是一个运算符。　　2.Equals则是string对象的方法，可以.（点）出来。　　　　我们比较无非就是这两种 1、基本数据类型比较 2、引用对象比较　　1、基本数据类型比较　　==和Equals都比较两个值是否相等。相等为true 否则为false；　　　　2、引用对象比较　　==和Equals都是比较栈内存中的地址是否相等 。相等为true 否则为false；　　　　需注意几点：　　1、string是一个特殊的引用类型。对于两个字符串的比较，不管是 == 和 Equals 这两者比较的都是字符串是否相同；　　2、当你创建两个string对象时，内存中的地址是不相同的，你可以赋相同的值。　　所以字符串的内容相同。引用地址不一定相同，（相同内容的对象地址不一定相同），但反过来却是肯定的；　　3、基本数据类型比较(string 除外) == 和 Equals 两者都是比较值；

javabean规范一般都是重写equals的,其中比较什么就看你自己的业务逻辑比较了就目前jdk的“1”和new String("1") 是equals为true的 ==为false的

char 用等于判断~

1 plus 1 equals 2和1 plus 1 is equal to 2 两句一样。前者动词，后者形容词

String y=request.getParameter("hu");这个不就是获得jsp页面中的值吗？

比较两个对象的内容是否相等时用。

题目中的equals比较的是当前线程名称是否为"T1"或"T2",equals比较的是字符串的内容是否一致,这里String类已经对equals方法进行了重写,所以这里不用重写.双等于号比较的是字符串的地址是否一致,所以这里不能用双等号.

答非所问~垃圾

C#中的相等有两种类型：引用相等(ReferenceEquals)和值相等(Equals)。值相等就是说两个对象包含相同的值。而引用相等则比较的是两个对象的引用是否是同一个对象。也就是说，如果ReferenceEquals为True，则Equals必然为True，反过来就不一定了。这样的话可以看出来，ReferenceEquals我们没有比较去管他什么，系统自动解决，object类实现的静态RefrenceEquals函数就够了。而对于自定义的类型的话，如果想要实现判断值相等，是需要重写Equals函数的。可以看一下string和自定义类的对比：string strA = "Hello";string strB = string.Copy(strA);Console.WriteLine(strA == strB); //TrueConsole.WriteLine(strA.Equals(strB)); //TrueConsole.WriteLine(object.Equals(strA, strB)); //TrueConsole.WriteLine(object.ReferenceEquals(strA, strB)); //Falseclass MyClass{ public int value = 1;}...MyClass oA = new MyClass();MyClass oB = new MyClass();Console.WriteLine(oA == oB); //FalseConsole.WriteLine(oA.Equals(oB)); //FalseConsole.WriteLine(object.Equals(oA, oB)); //FalseConsole.WriteLine(object.ReferenceEquals(oA, oB)); //False先不考虑==号，看几个Equals的表现，Equals是要实现值相等比较的效果的，.net 在实现string的时候就重写了Equals(object) ,并添加重载函数Equals(string) ,因此两个比较才会返回True。而不实现这两个函数的后果就是都返回False，无法符合Equals函数应有的作用。由此看来，对于之前的需求：比较两个自定义类的内容是否相同，还是应该重写Equals(Object)，并建议重载对类的实现Equals(MyClass)。而对于==运算符的解释为：通过过判断两个引用是否指示同一对象来测试是否相等。也就是引用相等了，可对于上面对string的测试，RefrenceEquals为False时，==却返回的True，这是因为还有这么一条：当类型不可变（即实例中包含的数据不可更改）时，通过重载运算符== 来比较值是否相等而不是比较引用是否相等可能会很有用。大部分情况下写的自定义类都是可变的，所以一般用不到也不应该对==进行重载。

equals是一个方法，用于比较两个对象的内容是否相同，通常被重写以实现自定义的比较规则。equal是一个操作符，用于比较两个基本类型的值或对象引用是否相等。在Java中，基本类型（如int、float、boolean等）使用equal进行比较，而对象类型（如String、Integer、List等）使用equals进行比较。此外，对于对象类型，我们可以重写equals方法来实现自己的比较方式。

加一个叹号。

/"i:kwlz/

1..equals() 用于引用数据类型(除了上面的8个,都是引用数据类型,包括封装类,Object子类等), 比较是否指向相同的对象, 例如 String str = "abc";等效于： char data[] = {"a", "b", "c"}; String str = new String(data); 就是str 指向了 new String(data) 这个对象. 如果再有其他变量也指向这个对象,他们比较的结果就返回true;由于此方法在Object里, 所以它有很多重写, 具体要看说明;另外``` equalsIgnoreCase()可以忽略大小写; Object和String的equals()实现存在区别，所以上面的例子不太友好。有demo在最后2. compareTO可以比较两个字符串并且得到顺序.按字典顺序比较两个字符串。该比较基于字符串中各个字符的 Unicode 值。将此 String 对象表示的字符序列与参数字符串所表示的字符序列进行比较。

亲，你想说不相同是不？用关系运算符“非”符号表示就是! 。例如 a.equals(b); 表示相同，取“非”表示不相同 !a.equals(b);

代表空字符串。

List<String> numList = new ArrayList<String>();for(int i=0; i< 24; i++){ numList.add(i + "");}String testStr = "15";if(numList.contains(testStr)){ System.out.println("0-23里包含这个数字");}

equal是对比字符串是否相等==是对比字符串的地址是否相等

==是一种比较运算符,既可以用来比较基本数据类型,又可以比较引用数据类型.A:==基本类型：比较的是值是否相同引用类型：比较的是地址值是否相同B:equals()只能比较引用类型。默认情况下，比较的是地址值是否相同。但是，我们可以根据自己的需要重写该方法。

A equals B. 用法是正确的。句中equal是及物动词，后直接接宾语B。因主语A是第三人称单数形式，所以谓语动词用三单形式equals。A equals to B. 用法是错误的，应改为A is equal to B. be equal to是一个介词短语，固定用法，句中equal用作形容词，后面接介词to。因主语A是第三人称单数形式，所以be动词用三单形式is。请看equal的用法：1. equal用作形容词，表示“相同的”“相等的”等。如：They refused to treat with us on equal terms. 他们拒绝在平等的基础上与我们谈判。用于be equal to 表示“等于”“能胜任”“能应付”等，其中的 to 是介词(其后接动词时应用动名词)。如:This is equal to saying that he knows her well. 这就等于说他很熟悉她。有时可用其他连系动词代替 be。如：She didn"t feel equal to receiving visitors. 她感到身体不适，不能会客。2. equal用作动词，意为“等于”、“比得上”等，是及物动词，不要受其形容词用法的影响，在其后加介词 to。如：No man equals him in strength. 没有谁的力气比得上他。但是不能说：No man equals to him in strength.3. equal用作名词，意为“相等的事物”“(地位等)相同的人”等，是可数名词。如：No one could be his equal at telling a story. 讲故事没有比得上他。

　　1、java中equals和==的区别 值类型是存储在内存中的堆栈（简称栈），而引用类型的变量在栈中仅仅是存储引用类型变量的地址，而其本身则存储在堆中。 　　2、==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。 　　3、equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。 　　4、==比较的是2个对象的地址，而equals比较的是2个对象的内容，显然，当equals为true时，==不一定为true。

java中equals()返回boolean值，true表示相等，false表示不相等。不等于就是对上面的结果取反，！a.equals(b)。Java中equals的区别。可用于基本类型和引用类型：当用于基本类型时候，是比较值是否相同；当用于引用类型的时候，是比较对象是否相同。对于String a = “a”; Integer b = 1;这种类型的特有对象创建方式，==的时候值是相同的基本类型没有equals方法，equals只比较值（对象中的内容）是否相同（相同返回true）。一个类如果没有定义equals方法，它将默认继承Object中的equals方法，返回值与==方法相同。

加一个叹号。