Bal*_*usC 151
在String#equals()不仅比较字符串的内容,而且还会检查其他的对象也是的一个实例String.在String#contentEquals()只比较的内容(字符序列)和不不检查其他对象也是的一个实例String.只要它是一个实现它可以是任何东西,CharSequence其中包括AO String,StringBuilder,StringBuffer,CharBuffer,等.
Mar*_*aux 37
简单地说:String.contentEquals()是更聪明的兄弟String.equals(),因为它在实现中可以更自由String.equals().
有一些原因可以解释为什么有一个单独的String.contentEquals()方法.我认为最重要的原因是:
equals方法必须是反身的.这意味着:x.equals(y) == y.equals(x).这暗示aString.equals(aStringBuffer)必须与之相同aStringBuffer.equals(aString).这需要Java API开发人员在equals()StringBuffer,StringBuilder和CharSequence 的方法中为Strings做一些特殊的实现.这将是一个烂摊子.所以,那就是当String.contentEquals进来,这是一个独立的方法,它没有必须遵循严格的要求和规则的Object.equals.这样,您就可以更自由地实现"平等内容"的感觉.例如,这允许您在StringBuffer和String之间进行智能比较.
并说明究竟有什么区别:
String.contentEquals()可以比较a String,a StringBuilder,a StringBuffer,a CharSequence和这些的所有派生类的内容.如果参数是String类型,则String.equals()执行.
String.equals()仅比较String对象.所有其他对象类型都被视为不相等.
String.contentEquals()可以比较StringBuffer并StringBuilder以智能的方式.它不叫重toString()方法,其拷贝的全部内容到一个新的String对象.相反,它与底层char[]数组进行比较,这很好.
Pra*_*eek 29
这个答案已经由dbw发布了,但是他删除了它但是他在比较执行时间时会有一些非常有效的差异点,抛出了什么异常,
如果你看一下源代码String#equals和String #contentEquals,很明显有两个重写的方法,String#contentEquals其中一个采取StringBuilder和其他CharSequence.
他们之间的区别,
String#contentEquals如果提供的参数是null但String#equals将返回,将抛出NPEfalseString#equals仅在提供的参数时才比较内容,instance of String否则它将false在所有其他情况下返回,但另一方面String#contentEquals检查实现接口的所有对象的内容CharSequence.您还可以调整代码,以便String#contentEquals通过覆盖equals如下所示传递的参数的方法返回您想要的错误结果或结果,但是您无法进行这些调整String#equals.只要包含任何长度为3个字符的
代码,代码将始终生成truesstring
String s= new String("abc");// "abc";
System.out.println(s.contentEquals(new CharSequence()
{
@Override
public CharSequence subSequence(int arg0, int arg1) {
// TODO Auto-generated method stub
return null;
}
@Override
public int length() {
// TODO Auto-generated method stub
return 0;
}
@Override
public char charAt(int arg0) {
// TODO Auto-generated method stub
return 0;
}
@Override
public boolean equals(Object obj)
{
return true;
}
}));
String#contentEqualsString#Equals在提供参数的情况下instance of String,两者的长度String相同但内容不相等时,会慢一些.
例如,如果字符串是String s = "madam",String argPassed = "madan"那么s.contentEquals(argPassed)在这种情况下将花费几乎两倍的执行时间s.equals(argPassed)
如果两个字符串的内容长度不同,String#contentEquals那么String#Equals在几乎所有可能的情况下,函数将具有更好的性能.
还有一点要补充他的答案
String#contentEquals一个的String对象也将比较的StringBuilder内容,并提供相应的结果,而String#Equals会返回false Ami*_*rma 13
contentEquals(CharSequence cs):
java.lang.CharacterSequence(例如CharBuffer,Segment,String,StringBuffer,StringBuilder)equals(Object anObject):
java.lang.String 只RTFC :)
由于阅读源代码是理解它的最佳方式,因此我将分享这两种方法的实现(截至jdk 1.7.0_45)
public boolean contentEquals(CharSequence cs) {
if (value.length != cs.length())
return false;
// Argument is a StringBuffer, StringBuilder
if (cs instanceof AbstractStringBuilder) {
char v1[] = value;
char v2[] = ((AbstractStringBuilder) cs).getValue();
int i = 0;
int n = value.length;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
// Argument is a String
if (cs.equals(this))
return true;
// Argument is a generic CharSequence
char v1[] = value;
int i = 0;
int n = value.length;
while (n-- != 0) {
if (v1[i] != cs.charAt(i))
return false;
i++;
}
return true;
}
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String) anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
String#contentEquals()还有另一种方法:
public boolean contentEquals(StringBuffer sb) {
synchronized(sb) {
return contentEquals((CharSequence)sb);
}
}
Try*_*ing 11
Stringclass equals(Object o)方法只做String比较.但是contentEquals(CharSequence cs)对类的检查扩展了AbstractStringBuilderie StringBuffer,StringBuilder和Stringclass(它们都是类型CharSequence).
String str = "stackoverflow";
StringBuilder builder = new StringBuilder(str);
System.out.println(str.equals(builder));
System.out.println(str.contentEquals(builder));
输出:
false
true
第一stmt的输出是false因为builder没有的类型String,以便equals()返回false但contentEquals()检查所有类型的内容等StringBuilder,StringBuffer,String和作为内容是相同的,因此true.
contentEqualsNullPointerException如果提供的参数是,则抛出null但是equals()将返回false,因为equals()检查instanceOf(if (anObject instance of String)),如果参数是,则返回false null.equals()和contentEquals()两种方法在String类比较两个strings并string用StringBuffer.
参数contentEquals()是StringBuffer和String(charSequence).equals()用于比较两个strings和contentEquals()用于比较的内容String和StringBuffer.
方法contentEquals和 equals有
public boolean contentEquals(java.lang.StringBuffer);
public boolean contentEquals(java.lang.CharSequence);
public boolean equals(Object o)
这是一个描述这两种方法的代码
public class compareString {
public static void main(String[] args) {
String str1 = "hello";
String str2 = "hello";
StringBuffer sb1 = new StringBuffer("hello");
StringBuffer sb2 = new StringBuffer("world");
boolean result1 = str1.equals(str2); // works nice and returns true
System.out.println(" str1.equals(str2) - "+ result1);
boolean result2 = str1.equals(sb1); // works nice and returns false
System.out.println(" str1.equals(sb1) - "+ result2);
boolean result3 = str1.contentEquals(sb1); // works nice and returns true
System.out.println(" str1.contentEquals(sb1) - "+ result3);
boolean result4 = str1.contentEquals(sb2); // works nice and returns false
System.out.println(" str1.contentEquals(sb2) - "+ result4);
boolean result5 = str1.contentEquals(str2); // works nice and returns true
System.out.println(" str1.contentEquals(str2) - "+ result5);
}
}
输出:
str1.equals(str2) - true
str1.equals(sb1) - false
str1.contentEquals(sb1) - true
str1.contentEquals(sb2) - false
str1.contentEquals(str2) - true
String#equals将Object作为参数,并检查它是否为String对象的实例.如果参数对象是String Object,则它逐个字符地比较内容.如果两个字符串对象的内容相同,则返回true.
String#contentEquals将CharSequence接口作为参数.CharSequence可以通过两种方式实现 - 使用i)String类或(ii)AbstractStringBuilder(StringBuffer的父类,StringBuilder)
在contentEquals()中, 在任何对象实例检查之前比较长度.如果length相同则检查参数对象是否是AbstractStringBuilder的实例.如果是这样(即StringBuffer或StringBuilder),则逐个字符地检查内容.如果参数是String对象的实例,则String#equals从String#contentEquals调用.
简而言之,
String#equals在字符串对象也是String对象的情况下逐个字符地比较内容字符.和String#contentEquals比较case参数对象实现CharSequence接口的内容.
String#contentEquals比较慢,以防我们比较两个相同长度的字符串内容,因为String#contentEquals内部调用String#equals for String object.
如果我们尝试比较具有不同内容长度的对象(比如说"abc"和"abcd"),那么String#contentEquals比String#equals更快.因为在任何对象实例检查之前比较长度.
BTW,差异的历史原因是String最初没有超类,因此String.equals()接受String作为其参数.当CharSequence被引入作为String的超类时,它需要一个自己的相等测试,它在所有CharSequence实现中都有效,并且不会与已经被String使用的equals()发生碰撞......所以我们得到了CharSequence.contentEquals( ),由String继承.
如果CharSequence已存在于Java 1.0中,那么probalby只有CharSequence.equals()而String会简单地实现它.
啊,不断发展的语言的乐趣......