String # equals와 String # contentEquals 메소드의 차이점

String # equals와 String # contentEquals 메소드의 차이점

---

String#equals방법과 방법 의 차이점은 무엇입니까 String#contentEquals?

---

는 String#equals()다른 객체도의 인스턴스의 경우 문자열의 내용뿐만 아니라 검사를 비교뿐만 아니라 String. String#contentEquals()뿐만 내용 (문자 시퀀스)를 비교 않는 하지 다른 객체가 인스턴스인지 확인 String. 그것의 구현으로이만큼 아무것도 할 수있다 CharSequenceAO 다루고있는 String, StringBuilder, StringBuffer, CharBuffer, 등

---

보다 쉽게 구현할 수 있습니다 :의 구현은보다 구현이 더 자유롭기 때문에 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 의 메소드 에서 문자열에 대한 특별한 구현을 해야합니다. 이것은 엉망이 될 것입니다.

그래서, 그입니다 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지능적인 방법이다. 전체 내용을 새 String 객체로 복사 하는 heavy 메소드를 호출 하지 않습니다toString() . 대신 기본 char[]배열 과 비교하면 좋습니다.

---

이 답변은 이미 dbw 에 의해 게시 되었지만 삭제했지만 실행 시간을 비교하는 동안 차이점에 대해 매우 유효한 점이 있었으며 예외는 무엇인지,

소스 코드 String # equals 및 String # contentEquals 를 살펴보면 String#contentEquals하나 StringBuilder와 다른 메소드에 대해 두 가지 재정의 된 메소드가 있음이 분명합니다 CharSequence.
그들 사이의 차이점

1. String#contentEquals제공된 인수가 NPE가 발생합니다 null하지만 String#equals돌아갑니다false
2. String#equals제공된 인수가 instance of String그렇지 않은 경우 에만 내용을 비교합니다. 그렇지 않으면 false다른 모든 경우에 반환 되지만 String#contentEquals인터페이스를 구현하는 모든 객체의 내용을 확인합니다 CharSequence.

3. 아래에 표시된 것처럼 전달 된 인수의 메소드를 String#contentEquals재정 의하여 원하는 잘못된 결과 또는 결과 를 리턴 하도록 코드를 조정할 수도 equals있지만을 사용하여 조정할 수는 없습니다 String#equals.
   아래 코드true 는 3 자 길이의 문자 를 s포함하는 string한 항상 생성합니다.

       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;
           }
       }));
   

4. String#contentEquals will be slower then String#Equals in the case when argument supplied is instance of String and the length of both String is same but contents are not equal.
   Example if the string are String s = "madam" and String argPassed = "madan" then s.contentEquals(argPassed) will take almost double execution time in this case as compared to s.equals(argPassed)

5. If the content length are not same for both the strings then function String#contentEquals will have better performance then String#Equals in almost all possible cases.

One more point to add to his answer

6. String#contentEquals of a String object will also compare to the StringBuilder contents and provide the appropriate result while String#Equals will return false

---

contentEquals(CharSequence cs):

• Lets you check equality of given string value with any implementation instance of interface java.lang.CharacterSequence (eg, CharBuffer, Segment, String, StringBuffer, StringBuilder )

equals(Object anObject):

• Lets you check equality of given string value with any instance of type java.lang.String only

RTFC :)

Since reading the source is the best way to understand it, I am sharing the implementations of both the methods (as of 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;
 }

---

There is another method of String#contentEquals():

public boolean contentEquals(StringBuffer sb) {
    synchronized(sb) {
        return contentEquals((CharSequence)sb);
    }
}

---

• String class equals(Object o) method does only String comparison. But contentEquals(CharSequence cs) checks for classes extends AbstractStringBuilder i.e. StringBuffer, StringBuilder and String class also (They all are of type CharSequence).

  String str = "stackoverflow";
  StringBuilder builder = new StringBuilder(str);
  System.out.println(str.equals(builder));
  System.out.println(str.contentEquals(builder));
  

output:

false
true

The output of first stmt is false because builder is not of type String so equals() returns false but the contentEquals() checks for the content of all the type like StringBuilder, StringBuffer, String and as the content is same hence true.

• contentEquals will throw NullPointerException if the argument supplied is null but equals() will return false because the equals() checks for instanceOf ( if (anObject instance of String) ) which returns false if the argument is null.

---

equals() and contentEquals() are two methods in String class to compare two strings and string with StringBuffer.

The parameters of contentEquals() are StringBuffer and String(charSequence). equals() is used to compare two strings and contentEquals() is used to compare the contents of String and StringBuffer.

Method contentEquals and equals are

public boolean contentEquals(java.lang.StringBuffer);
public boolean contentEquals(java.lang.CharSequence);
public boolean equals(Object o)

Here is an code which describes both methods

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);
    }
}

Output:

 str1.equals(str2) - true
 str1.equals(sb1) - false
 str1.contentEquals(sb1) - true
 str1.contentEquals(sb2) - false
 str1.contentEquals(str2) - true

---

The contentEquals() method checks is the contents are same between a String, StringBuffer, etc which some kind of char sequence.

---

String#equals takes Object as an argument and checks it is instance of String object or not. If the argument object is String Object then it compares content character by character. It returns true in case content of both string objects are same.

String#contentEquals takes CharSequence interface as an argument. CharSequence can be implements in 2 ways-by using i) String class or (ii) AbstractStringBuilder( parent class of StringBuffer, StringBuilder)

In contentEquals() length is compared before any object instance check. If length is same then it checks argument object is instance of AbstractStringBuilder or not. If it is so(i.e. StringBuffer or StringBuilder ) then content is checked character by character. In case argument is an instance of String object then String#equals called from String#contentEquals.

So in short,

String#equals compares the content character by character in case argument is String object also. And String#contentEquals compares the content in case argument object implement CharSequence interface.

String#contentEquals is slower in case we compare two same length string content as String#contentEquals internally calls String#equals for String object.

In case we try to compare objects with difference content length (say "abc" with "abcd") then String#contentEquals is faster than String#equals. Because length is compared before any object instance checking.

---

BTW, the historical reason for the difference is that String originally had no superclass, so String.equals() takes a String as its argument. When CharSequence was introduced as the superclass of String, it needed an equality test of its own that worked across all CharSequence implementations, and that would not collide with the equals() already in use by String... so we got CharSequence.contentEquals(), which is inherited by String.

If CharSequence has been present in Java 1.0, we would probalby have only CharSequence.equals() and String would simply implement that.

Ah, the joys of evolving languages...

참고URL : https://stackoverflow.com/questions/6476600/difference-between-stringequals-and-stringcontentequals-methods