关于equals()和==区别

equals的读音是/u02c8iu02d0kwu0259lz/，发音类似于“EE-kwuhls”。详细介绍如下：1、什么是equals？equals是一个英文单词，表示相等或一样的意思；在Java编程中也有一个方法叫做 equals()，用于判断两个对象是否相等；除此之外，equals 这个词还有其他的用法，比如在代数学中常用于表示等于号的符号“=”。2、equals在代码中的应用在Java语言中，equals()方法是Object类中的一个方法，可以被所有Java对象继承使用，用于判断两个对象是否相等；在使用equals()方法时，通常需要重写Object中的equals()方法来实现实际的相等判定，因为默认的equals()方法只是简单地比较两个对象的地址值是否相等。在重写equals()方法时，通常需要考虑多种判断条件，包括对象是否为空、对象类型是否相同、属性是否相等等等。3、equals在代数学中的应用在代数学中，equals通常用于表示等于号的符号“=”；在求解方程时，等于号常用于将式子的两边连接起来，表示两边具有相同的值，如：2x+3=7；在等式的两边加减乘除相同的数字或式子时，等号两边的值仍相等。4、知识拓展：equals和hashCode方法在Java语言中，除了equals()方法以外，还有hashCode()方法，用于为对象生成一个哈希码，以便提高对象的查找效率；在使用hashCode()方法时，通常也需要重写Object中的 hashCode()方法，保证在对象相等时其hashCode值也相同。

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

1.equals的本意——即在Object对象中定义的equals()方法有什么样的意义。（此处先附上==的作用，后面仍有叙述。因为==和equals()方法的关系是很密切的，后面有我自己的看法。 ==用于比较引用和比较基本数据类型时具有不同的功能： 比较基本数据类型，如果两个值相同，则结果为true 而在比较引用时，如果引用指向内存中的同一对象，结果为true） public boolean equals(Object obj) 其比较规则为：当参数obj引用的对象与当前对象为同一个对象时，就返回true,否则返回false.public class Fish { private int weight; private String color; public Fish(int weight, String color) { this.color = color; this.weight = weight; } public int getWeight() { return weight; } public void setWeight(int weight) { this.weight = weight; } public String getColor() { return color; } public void setColor(String color) { this.color = color; }}public class EqualsTest { public static void main(String[] args) { Fish f1 = new Fish(1, "blue"); Fish f2 = new Fish(1, "blue"); System.out.println(f1 == f2); System.out.println(f1.equals(f2)); }}——————运行结果为——————falsefalse由此可见，equals()方法的本意为确定两个对象的引用是否相同。2.而JDK类中有一些类覆盖了oject类的equals()方法，比较规则为：如果两个对象的类型一致，并且内容一致，则返回true,这些类有：java.io.file,java.util.Date,java.lang.string,包装类（Integer,Double等）public class EqualsTest { public static void main(String[] args) { String s1=new String("sss"); String s2=new String("sss"); System.out.println(s1==s2); System.out.println(s1.equals(s2)); }}————————运行结果为——————falsetrue由此知道，在String中equals()方法被进行了覆盖，使其意义变为比较两个对象的内容是否一致3.如果我们要自己覆盖equals()方法，让其比较内容或者有别的使用方法（当然我们一般都是用于比较内容的，但是覆盖的方法中真正的实现究竟是什么样的，谁知道呢O(∩_∩)O~）public class Fish { private int weight; private String color; public Fish(int weight, String color) { this.color = color; this.weight = weight; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((color == null) ? 0 : color.hashCode()); result = prime * result + weight; return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Fish other = (Fish) obj; if (color == null) { if (other.color != null) return false; } else if (!color.equals(other.color)) return false; if (weight != other.weight) return false; return true; } public int getWeight() { return weight; } public void setWeight(int weight) { this.weight = weight; } public String getColor() { return color; } public void setColor(String color) { this.color = color; }}public class EqualsTest { public static void main(String[] args) { Fish f1 = new Fish(1, "blue"); Fish f2 = new Fish(1, "blue"); System.out.println(f1 == f2); System.out.println(f1.equals(f2)); }}——————运行结果为——————falsetrue此例子中我复写了equals()方法和hashcode()方法，使得equals()方法脱离的本意，不再是比较两个对象的引用是否相同，而是比较其内容是否相同。以上内容为一般书上的总结，下面是我自己想到的一些东西。我们可以知道计算机归根到底进行的只是一些二进制数的与或非运算，加法乘法运算。由此有了些基本的运算符，所有的函数本质上其实现都是使用基本运算符来实现的。而==是基本运算符中的一个，它的作用：用于比较引用和比较基本数据类型时具有不同的功能： 比较基本数据类型，如果两个值相同，则结果为true 而在比较引用时，如果引用指向内存中的同一对象，结果为true而equals()作为方法，我们可以推测知道，它其中的实现所使用的肯定是==运算符。再进一步的思考，equals()本意不正是==运算符进行对象比较时候的作用吗。那么，既然是两者有同样的作用，为什么还要弄出一个equals()方法来呢。因为==运算符不允许我们进行覆盖，也就是说它限制了我们的表达。在上面的第三个例子中，我们复写equals()方法，达到比较对象内容是否相同的目的。而这些通过==运算符是做不到的。

可以把==想象成人的长相是否一样把equals想象成人的本质是否一样==比较两个地址是不是一样的equals比较两个地址指向的 实际对象的内容 是不是同一个

重写

equals 是函数：（是String类从它的超类Object中继承的）被用来检测两个对象是否相等，即两个对象的内容是否相等，区分大小写。

有这么个键吗？

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

==是一个判断是否相等的符号equals()是判断内容的函数对于两个变量进行判断时候,你首先要弄清楚它的类型.对于刚学java的来说,对于这个很模糊.比如:两个整型 int a=3 , b=4;用if(a==b)和用if(a.equals(b))效果相同然而,对于 两个字符串类型的 Sting a="chia",b="boy";用if(a==b)和用if(a.equals(b))效果不相同为什么呢?其实java 讲得很清楚,对于属于基本类型它的存储方式与c语言的变量一样,是直接存储.然后对于引用类型的来说,它相当于c语言中的 指针或数组.所以对于不属于基本类型的其他类型判断的时候应该用equals()来判断,而不是用==判断.我也刚学java,应该是这吧!

equals：名词复数形式，意思是：(同等的)人或事物

“==”是关系运算符，equals()是方法，同时他们的结果都返回布尔值；“==”使用情况如下： 1) 基本类型，比较的是值 2) 引用类型，比较的是地址 3) 不能比较没有父子关系的两个对象equals()方法使用如下： 1) 系统类一般已经覆盖了equals()，比较的是内容。 2) 用户自定义类如果没有覆盖equals()，将调用父类的equals （比如是Object），而Object的equals的比较是地址（return (this == obj);） 3) 用户自定义类需要覆盖父类的equals()注意：Object的==和equals比较的都是地址，作用相同

一、含义不同：==是一个比较运算符，基本数据类型比较的是值，引用数据类型比较的是地址值。（比较地址值即是指是否为同一个对象的引用）equals()是一个方法，只能比较引用数据类型。重写前比较的是地址值，重写后比一般是比较对象的属性。二、引用不同：值类型（int,char,long,bolean等）都是用=判断相等性。对象引用的话，=判断引用所指的对象是否是同一个。equals是Object的成员函数，有些类会覆盖（overide）这个方法，用于判断对象的等价性。三、方法不同：String里的方法，如果==号比较不相等，还会进行一下值的比较。所以equals方法具体的作用要看当前的那个类是如何实现重写父类中该方法的。如果没有重写该方法，那么他和==号等价。扩展资料：Eg:s1 = new String("sony"); //创建的是字符串对象s1.equals("sony"); //返回trues1 == "sony" //返回false//如果s1 = "sony";s1 == "sony" //返回true//如果s1 = "sony";s2 = "sony";s1.equals(s2); 或者string.equals(s1,s2);//返回true参考资料来源：百度百科-equals

"equals" 在英语中的发音为 [u02c8iu02d0kwu0259lz]，其中重音在第一音节，读音可以分为三部分：1. "e"：发长的前元音 [i:]，口型类似于汉语的"衣"字发音。2. "qua"：发短的构清的后元音 [kwu0259]，口型类似于汉语的"夸"字发音。3. "ls"：发浊辅音 [z]，发音时牙齿稍微合上，让舌头靠近牙齿，舌尖接近齿龈，尽量使风流动声带，从而发出清晰的浊辅音。因此，"equals" 的英语发音为 [u02c8iu02d0kwu0259lz]，可在各大英语网站或字典中查到其发音的音频和语音实例。

平衡，平等，均衡麻烦采纳下呢

1.==比较的是地址2.至于为啥比较的是地址？不是内容。这个是JAVA规定的，不是我们可以控制的3.说equals比较的是值是完全不对的。要看他是否有重写object的equals方法。如果没有，他比较的肯定是也地址。如果有，那么很有可能他比较的是值，但也不尽然 。可以看他的源码。比如Integer a=1.Doubleb=1;a.equals(b)那肯定是false。因为他在重写时还判断了类型

加一个叹号。

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

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

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

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

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里包含这个数字");}

代表空字符串。

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

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 对象表示的字符序列与参数字符串所表示的字符序列进行比较。

/"i:kwlz/

加一个叹号。

equals是一个方法，用于比较两个对象的内容是否相同，通常被重写以实现自定义的比较规则。equal是一个操作符，用于比较两个基本类型的值或对象引用是否相等。在Java中，基本类型（如int、float、boolean等）使用equal进行比较，而对象类型（如String、Integer、List等）使用equals进行比较。此外，对于对象类型，我们可以重写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比较的是当前线程名称是否为"T1"或"T2",equals比较的是字符串的内容是否一致,这里String类已经对equals方法进行了重写,所以这里不用重写.双等于号比较的是字符串的地址是否一致,所以这里不能用双等号.

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

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

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

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

char 用等于判断~

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

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

=号，在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比较的是两个字符串的内容

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

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

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

在加减乘除时 用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

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

!xxx.equals(xxx)

解释一下==号,他比较的是一个对象在内存中的地址值,比如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 对象？

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