equals

帮你修改一下：Pain-freelifeequalshappinessactuallyreducestheirchancesofeverattainingrealhappiness.翻译：没有苦痛的生活相当于幸福，（但）事实上降低了人们获得真正幸福的机会。

动词

E equals m times c squared

翻译不是一成不变的，要根据语义灵活贯通。不能将定语简单统一翻译成“……的”，而是要根据该定语的具体含义来决定中文措辞。本句的直译是：能量等于质量（被乘以）（被平方后的）光速。您可以看到，括号里分别就是multiplied和squared这两个过去分词的直译。当然正式的翻译要在直译的基础上加以润色，使之通顺，因此就有了以下的翻译：“能量等于质量乘以光速的平方”

区分，有一个不区分的，equalsIgnoreCase boolean equals(Object anObject) 将此字符串与指定的对象比较。 boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写。

str == null ?"":str;str.equalsIgnoreCase("")?"":str;equalsIgnoreCase(null)这样写会抛异常吗？会抛出异常可以这样写：(str == null || str.equalsIgnoreCase("") ) == true ? "":str;

Stringtrim()//截去字符串两端的空格，但对于中间的空格不处理。java.lang.String.equalsIgnoreCase()这个方法比较字符串到另一个字符串，忽略大小写的考虑

equals 区分大小写 abc==ABC falseequalsIgnoreCase 不区分 abc==ABC true

->是成员提取， A ->B表示提取A中的成员B，A只能是指向类、结构、联合的指针常引用声明方式：const 类型标识符 &引用名=目标变量名；

比较字符串s1和s2的内容是否相同,比较时忽略大小写的区别

beequalswith是等于equalsn.同样的人(equal的名词复数);相等的数量;能与之比拟的东西;（地位、实力等）相同的人;v.比得上(equal的第三人称单数);（质量等方面）赶得上;与…相等或相同;使（某物）等于;[例句]AsquaredplusBsquaredequalsCsquared.A的平方加上B的平方等于C的平方。[其他]形近词：equaly

在deepEquals()在 java.util.Arraysjdk 帮助文档里是这样写的：deepEquals(Object[] a1, Object[] a2) 如果两个指定数组彼此是深层相等 的，则返回 true。 比较的什么呢？ 比较的是 数组a1 和 数组a2 中的元素是否深层相等 也就是 a1[1].equels(a2[1]), a1[2].equels(a2[2]), a1[3].equels(a2[3])........给你找了一个例子：import java.util.*;public class deepEqualsArray { public static void main(String[] args) { //creating an object array Object o[]={"Rose","India","Net","Limited","Rohini"}; //Object o1[]={"Rose","India","Net","Limited","Rohini"}; Object o1[]={"Rohini","Limited","Net","India","Rose"}; boolean b=Arrays.deepEquals(o, o1); System.out.println("Array are equal:-" +b); }} 另外我查了下jdk源码 deepEquals(Object[] a1, Object[] a2) 你可以看着理解一下 public static boolean deepEquals(Object[] a1, Object[] a2) { if (a1 == a2) return true; if (a1 == null || a2==null) return false; int length = a1.length; if (a2.length != length) return false; for (int i = 0; i < length; i++) { Object e1 = a1[i]; Object e2 = a2[i]; if (e1 == e2) continue; if (e1 == null) return false; // Figure out whether the two elements are equal boolean eq; if (e1 instanceof Object[] && e2 instanceof Object[]) eq = deepEquals ((Object[]) e1, (Object[]) e2); else if (e1 instanceof byte[] && e2 instanceof byte[]) eq = equals((byte[]) e1, (byte[]) e2); else if (e1 instanceof short[] && e2 instanceof short[]) eq = equals((short[]) e1, (short[]) e2); else if (e1 instanceof int[] && e2 instanceof int[]) eq = equals((int[]) e1, (int[]) e2); else if (e1 instanceof long[] && e2 instanceof long[]) eq = equals((long[]) e1, (long[]) e2); else if (e1 instanceof char[] && e2 instanceof char[]) eq = equals((char[]) e1, (char[]) e2); else if (e1 instanceof float[] && e2 instanceof float[]) eq = equals((float[]) e1, (float[]) e2); else if (e1 instanceof double[] && e2 instanceof double[]) eq = equals((double[]) e1, (double[]) e2); else if (e1 instanceof boolean[] && e2 instanceof boolean[]) eq = equals((boolean[]) e1, (boolean[]) e2); else eq = e1.equals(e2); if (!eq) return false; } return true; }对于equals 我就不多说了 就是比较的在堆内存里存放的值， “==”是比较栈内存中的地址

15 divided by 3 equals to 5.中的equals为什么要加“s”?除出来的数字是单数阿！

divide【数】除[(+by/into)]12 divided by 4 equals 3. 十二除以四等于三。 be divided by被..除Twenty can be divided by four. 20能被4除。Twelve can be divided by three. 12可以用3除尽。

hashCode 的常规协定是：在 Java 应用程序执行期间，在同一对象上多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是对象上 equals 比较中所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。如果根据 equals(Object) 方法，两个对象是相等的，那么在两个对象中的每个对象上调用 hashCode 方法都必须生成相同的整数结果。以下情况不 是必需的：如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么在两个对象中的任一对象上调用hashCode 方法必定会生成不同的整数结果。但是，程序员应该知道，为不相等的对象生成不同整数结果可以提高哈希表的性能。实际上，由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。（这一般是通过将该对象的内部地址转换成一个整数来实现的，但是 JavaTM 编程语言不需要这种实现技巧。）这么理解,在你调用equals()方法比较两个对象的时候,编译器会自动调用hashCode()来比较两个对象是否产生相同的整数结果.equals()返回true,则hashCode()必返回true.equals()返回false,则hashCode()必返回false.那么你重写equals()方法,肯定必须重写hashCode方法来保证二者的同步关系(暂且称这种关系为同步关系).

做加减乘除时的等于用equal如twoplustwoequalsfour.因为前面是单数意义，所以equal加sbeequalto用于下面这种例子如adimeisequalto10cents.一角等于10分。供参考，希望能够帮到你。如有疑问欢迎追问。

1.句型“beequalto...”属于等比句型，比较双方基本等同，标准形式是“主语十beequalto+等比对象”。形容词“equal”的意思是“相等的、同样的”。该句型翻译为“……和……相当”。例句：we"reequaltothem.我们和他们一样。2.equalto..意思是等于，相当，胜任。例句：Equaltoonebilliononemegatonhydrogenbombs.等于10亿个百万吨级的氢弹。

前者中的equal是形容词，后者中的是动词，在等于，相等这个意思上没有区别，但前者还有胜任的意思，后者没有

1.句型“be equal to...”属于等比句型，比较双方基本等同，标准形式是“主语十be equal to+等比对象”。形容词“equal”的意思是“相等的、同样的”。该句型翻译为“……和……相当”。例句：we"re equal to them. 我们和他们一样。2.equal to ..意思是等于，相当，胜任。例句：Equal to one billion one megaton hydrogen bombs. 等于10亿个百万吨级的氢弹。

matches是正则匹配不是任何对象都有matches方法的

根据老外的解释就是说assertEqual与assertEquals没有区别，可以说是完全一样的函数，而现在assertEquals函数已经被弃用，也就说不建议你使用了，以后可能这个方法就在python中消失了，在python3.0中已经趋向使用不带s的assert方法了，但是现在仍然没有删掉的原因是因为有一些旧代码和项目在使用带s的方法，语言要保持旧代码的兼容性。 至于assert那就很好解释了，就是判断0,1 也就是python中的真假关系 assertAlmostEquals这2个方法存在的原因与上面的相同，建议你不要使用带s的方法了，这个方法是做一个粗略判断，判断的值为你4舍5入后的值，也就是说5.1与5.2是相等的，如果使用这样的assert方法。

assertEquals数原型1：assertEquals([String message],expected,actual) 参数说明： message是个可选的消息，假如提供，将会在发生错误时报告这个消息。 expected是期望值，通常都是用户指定的内容。 actual是被测试的代码返回的实际值。

Assert.assertEquals的含义是：这是个可选的消息，假如提供，将会在发生错误时报告这个消息。assert 简介：编写代码时，我们总是会做出一些假设，断言就是用于在代码中捕捉这些假设，可以将断言看作是异常处理的一种高级形式。断言表示为一些布尔表达式，程序员相信在程序中的某个特定点该表达式值为真。可以在任何时候启用和禁用断言验证，因此可以在测试时启用断言，而在部署时禁用断言。同样，程序投入运行后，最终用户在遇到问题时可以重新起用断言。

这两个没什么区别，造两个句子就明白，The shop treats us "as equals". 这铺头平等待客The shop treats us "equally".

["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()

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方法，返回值与==方法相同。

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 用等于判断~