Java 문자열 비교 방법

Java 문자열 비교 방법

이 질문의 답변은 지역사회의 노력입니다.기존 답변을 편집하여 이 게시물을 개선하십시오.현재 새로운 답변이나 상호작용을 받아들이지 않고 있습니다.

는 계속 ==이치노 그 중 를 '어느 쪽인가'로 요..equals()이치노

이는?==나쁜가요? 언제 사용해야 하고 사용하면 안 되나요?가른른른른?

==기준 동일성 검정(같은 개체인지 여부)입니다.

.equals()값의 동일성(논리적으로 "정확한"지 여부)을 테스트합니다.

Objects.equals()는 다음을 확인합니다.null를 호출하기 .equals()(JDK7부터 이용 가능, Guava에서도 이용 가능) 할 필요가 없습니다.

두 , ""를 사용할 수 .Objects.equals().

// These two have the same value
new String("test").equals("test") // --> true 

// ... but they are not the same object
new String("test") == "test" // --> false 

// ... neither are these
new String("test") == new String("test") // --> false 

// ... but these are because literals are interned by 
// the compiler and thus refer to the same object
"test" == "test" // --> true 

// ... string literals are concatenated by the compiler
// and the results are interned.
"test" == "te" + "st" // --> true

// ... but you should really just call Objects.equals()
Objects.equals("test", new String("test")) // --> true
Objects.equals(null, "test") // --> false
Objects.equals(null, null) // --> true

당신은 거의 항상 사용하고 싶어합니다.Objects.equals()내부 스트링을 취급하고 있는 것을 알고 있는 드문 상황에서는==.

JLS 3.10.5부터 문자열 리터럴:

또한 문자열 리터럴은 항상 같은 클래스의 인스턴스를 참조합니다.String이는 스트링 리터럴(또는 일반적으로 상수 표현의 값인 스트링(1515.28))이 고유한 인스턴스를 공유하기 위해 메서드를 사용하여 "interned"되기 때문입니다.String.intern.

같은 예는 JLS 3.10.5-1에서도 볼 수 있습니다.

고려해야 할 기타 방법

String.equals대소문자를 무시하는 Ignore Case() 값의 동등성.단, 이 메서드는 다양한 로케일 관련 케이스에서 예기치 않은 결과를 초래할 수 있으므로 주의해 주십시오.이 질문을 참조해 주십시오.

String.contentEquals()는 의 내용을 비교합니다.String의 내용을 CharSequence(Java 1.5 후 ( ( ( ( ( ( ( ( ( ( 。동등 비교를 수행하기 전에 StringBuffer 등을 String으로 변환할 필요가 없어지지만 늘 체크는 사용자에게 맡깁니다.

==합니다.「 」 、 「 」.equals()는 문자열 값을 테스트합니다.

마치 로는치 sometimes처럼 보일 수 있다.==는 값을 비교합니다.Java는 동일한 인라인 문자열이 실제로 동일한 객체인지 확인하기 위해 몇 가지 백그라운드 작업을 하기 때문입니다.

예를 들어 다음과 같습니다.

String fooString1 = new String("foo");
String fooString2 = new String("foo");

// Evaluates to false
fooString1 == fooString2;

// Evaluates to true
fooString1.equals(fooString2);

// Evaluates to true, because Java uses the same object
"bar" == "bar";

하지만 무효를 조심하라!

== 「」null정상이지만 은 "" " " " " 입니다..equals()합니다. null 문자열은 null 을 사용합니다.

String nullString1 = null;
String nullString2 = null;

// Evaluates to true
System.out.print(nullString1 == nullString2);

// Throws a NullPointerException
System.out.print(nullString1.equals(nullString2));

그 사실을 fooString1 수 에게 '무효가 되다'라고.

System.out.print(fooString1 != null && fooString1.equals("bar"));

다음은 더 짧지만 null을 확인하는 것은 덜 명확합니다.

System.out.print("bar".equals(fooString1));  // "bar" is never null
System.out.print(Objects.equals(fooString1, "bar"));  // Java 7 required

==에 오브젝트 참조를 비교합니다.

.equals()에 문자열 값을 비교합니다.

★★★★★★★★★★★★★★★★★.==값을 .String 값은 다음과 .

String a="Test";
String b="Test";
if(a==b) ===> true

그 이유는 String 리터럴을 작성하면 JVM이 먼저 String 풀에서 해당 리터럴을 검색하기 때문입니다.일치를 검출하면 새로운 String에 동일한 참조가 부여되기 때문입니다.이 때문에, 다음과 같은 이점이 있습니다.

(a==b) ===> 참

                       String Pool
     b -----------------> "test" <-----------------a

★★★★★★★★★★★★★★.== 경우에 실패합니다.

String a="test";
String b=new String("test");
if (a==b) ===> false

, 「」의 경우는,new String("test") new 는 statement new String에 대해 됩니다.b, (그래서)b스트링입니다.

, 이제a String 풀 때 String은 String 풀 내의 String을 클릭합니다.b는 힙상의 문자열을 가리키고 있습니다. 때문에 우리는 과 같은것을 얻게 됩니다.

if(a==b) ===> false 입니다.

                String Pool
     "test" <-------------------- a

                   Heap
     "test" <-------------------- b

한편, 「 」는, 「 」, 「 」의 사이에.equals()의 값을 하여 두가 됩니다.String은 true가 됩니다.

String a="Test";
String b="Test";
if(a.equals(b)) ===> true

String a="test";
String b=new String("test");
if(a.equals(b)) ===> true

이렇게 쓰면서.equals()항상 더 낫습니다.

==연산자는 두 문자열이 정확히 동일한 개체인지 확인합니다.

.equals()메서드는 두 문자열의 값이 동일한지 여부를 확인합니다.

Java 문자열은 불변입니다.즉, 문자열을 변경 또는 변경하려고 할 때마다 새 인스턴스가 생성됩니다.원래 문자열은 변경할 수 없습니다.이는 이러한 문자열 인스턴스를 캐시할 수 있도록 하기 위해 수행되었습니다.일반적인 프로그램에는 많은 문자열 참조가 포함되어 있으며 이러한 인스턴스를 캐싱하면 메모리 사용 공간이 줄어들고 프로그램의 성능이 향상될 수 있습니다.

문자열 비교에 == 연산자를 사용하는 경우 문자열의 내용을 비교하는 것이 아니라 메모리 주소를 비교하는 것입니다.둘 다 같으면 true, 그렇지 않으면 false가 반환됩니다.반면 문자열에서는 equals가 문자열의 내용을 비교합니다.

는 모든 왜 이 문자열이 캐시되어 있는가 하는 입니다.==false를 반환하는 반면 equals는 true를 반환합니까?, 건, 건, 면, 면, 면 같은 문자열을 새로 만들면String str = new String("Testing")캐시에 동일한 내용을 가진 문자열이 이미 포함되어 있더라도 캐시에 새 문자열을 생성하게 됩니다.로 말하면 ★★★"MyString" == new String("MyString")거짓

할 수 있는 intern에 합니다.따라서 Java는 캐시를 ."MyString" == new String("MyString").intern()true가 됩니다.

참고: == 연산자는 단지 두 개의 메모리 주소를 비교한다는 이유만으로 동등한 연산자보다 훨씬 빠르지만, 코드에 새로운 String 인스턴스가 생성되지 않는지 확인해야 합니다.그렇지 않으면 버그가 발생합니다.

String a = new String("foo");
String b = new String("foo");
System.out.println(a == b); // prints false
System.out.println(a.equals(b)); // prints true

그 이유를 이해하도록 하세요.그이 it ==는 참고합니다.equals()방법

「 」의 a ★★★★★★★★★★★★★★★★★」b"foo"이치노참조는 다르지만 내용은 동일합니다.

그래, 안 좋아...

==는 2개의 문자열 참조가 완전히 같은 오브젝트임을 의미합니다.Java가 리터럴테이블을 유지하고 있기 때문에 이러한 경우가 있다고 들어보셨을 수도 있지만 항상 그런 것은 아닙니다.일부 문자열은 다른 방법으로 로드되므로 동일한 문자열 2개가 같은 위치에 저장되어 있다고 가정해서는 안 됩니다.

실제 비교는 당신에게도 마찬가지입니다.

ㅇㅇ.==Strings를 비교하는 데 좋지 않습니다(정규적인 개체인지 모를 경우 실제로 모든 개체). ==는 오브젝트 참조만 비교합니다. .equals() 된 것처럼 항상 그런Strings의 경우, 같은 경우가 많지만, 당신이 발견한 것처럼, 그것이 항상 보장되는 것은 아닙니다.

Java에는 String 객체의 메모리 할당을 관리하는 String 풀이 있습니다."Java 문자열 풀" 참조

를 오브젝트를 체크== 는 을 string-pool합니다.의 String 객체는 2개의 String을 반환합니다.true그 이외의 경우false, 객체의 하려면 2개의 String을 가 있습니다.equals★★★★★★ 。

equals는 실제로는 오브젝트 클래스의 메서드이지만 String 클래스로 덮어쓰기되어 오브젝트의 내용을 비교하는 새로운 정의가 제공됩니다.

Example:
    stringObjectOne.equals(stringObjectTwo);

하지만 그건 스트링의 경우를 존중한다는 걸 명심해대소문자를 구분하지 않고 비교하려면 대소문자를 구분하지 않고 대소문자를 구분하여 비교해야 합니다.String 클래스의 IgnoreCase 메서드.

보기:

String one   = "HELLO"; 
String two   = "HELLO"; 
String three = new String("HELLO"); 
String four  = "hello"; 

one == two;   // TRUE
one == three; // FALSE
one == four;  // FALSE

one.equals(two);            // TRUE
one.equals(three);          // TRUE
one.equals(four);           // FALSE
one.equalsIgnoreCase(four); // TRUE

나는 자헤라테스의 대답에 동의한다.

할 수 건 '네'로 전화하는 intern()네 끈에 맞춰져 있어

zacherates의 예:

// ... but they are not the same object
new String("test") == "test" ==> false 

만약 당신이 인턴을 한다면, 비문자적 문자열의 평등은true:

new String("test").intern() == "test" ==> true 

== Java에서 오브젝트 참조를 비교합니다.이것은 예외는 아닙니다.String★★★★★★★★★★★★★★★★★★.

오브젝트(포함)의 실제 내용을 비교하려면 이 방법을 사용해야 합니다.

의 가 있는 String를 사용한 == 보니 '아예'인 것 같다.true 「 」가String의 Java Virtual Machine을 있습니다.String는 안 String String==true.

.equals()는 클래스 내의 데이터를 비교합니다(함수가 실장되어 있는 것을 나타냅니다). ==는 포인터 위치(메모리 내의 오브젝트 위치)를 비교합니다.

==두 개체(PRIMITIVES에 대해 말하지 않음)가 동일한 개체 인스턴스를 가리키면 true를 반환합니다. .equals()두 개체에 동일한 데이터가 포함된 경우 true를 반환합니다(Java).

그게 도움이 될 거야

==는, 2개의 오브젝트(이 경우는 참조)가 메모리내의 같은 오브젝트를 참조하고 있는지 아닌지를 확인합니다.

equals()메서드는 두 개체의 내용 또는 상태가 동일한지 여부를 확인합니다.

론. 뻔. obviously. obviously.==더 , 수 .String는 같은 텍스트를 유지합니다.

'시시 defin equals()방법을 권장합니다.

공연 걱정은 하지 마세요.String.equals():

1. ★★★의 String.equals()의 동일성을합니다(「」를 사용).==2개의 문자열이 참조로 동일할 경우 추가 계산이 수행되지 않습니다!
2. 하지 않은 2개의 문자열 참조가 동일하지 않은 경우String.equals()이제 문자열의 길이를 확인합니다. 할 수이에요.String 또는 포인트는 셀 .class는 문자열의 길이를 저장합니다.문자 또는 코드 포인트는 셀 필요가 없습니다.길이가 다르면 더 이상의 검사가 수행되지 않으므로 동일할 수 없습니다.
3. 여기까지 온 경우에만 실제로 2개의 문자열의 내용을 비교합니다.이것은 간단한 비교입니다.모든 문자가 비교되는 것은 아닙니다.2개의 문자열에서 같은 위치에 일치하는 문자가 발견되면 더 이상의 문자는 체크되지 않습니다.

에도 '인턴'을 합니다.equals()방법은 여전히 생각만큼 오버헤드가 높지 않습니다. 이치노효율적인 참조 체크를 원하는 경우 언어 지정 및 구현에 의해 동일한 열거 값이 동일한 개체(참조 기준)가 보장되는 경우 enum을 사용하십시오.

저와 같다면, 처음 Java를 사용하기 시작했을 때 "==" 연산자를 사용하여 두 String 인스턴스가 동일한지 테스트하고 싶었지만, 좋든 나쁘든 Java에서는 그렇지 않습니다.

이 튜토리얼에서는 Java 문자열을 올바르게 비교할 수 있는 몇 가지 방법을 시연합니다.이 방법에서는 주로 사용하는 접근법부터 시작합니다.이 Java String 비교 튜토리얼의 마지막에 Java 스트링을 비교할 때 "==" 연산자가 작동하지 않는 이유에 대해서도 설명합니다.

옵션 1: Java String과 동등한 메서드의 비교 대부분의 경우(대부분 95%)다음과 같이 Java String 클래스의 동등한 메서드와 문자열을 비교합니다.

if (string1.equals(string2))

이 String equals 메서드는 2개의 Java 스트링을 조사합니다.이 두 문자열에 동일한 문자열이 포함되어 있으면 동일한 문자열로 간주됩니다.

equals 메서드를 사용한 간단한 String 비교 예를 보면 다음 테스트를 실행한 경우 문자가 완전히 동일하지 않기 때문에 두 문자열은 동일하다고 간주되지 않습니다(문자의 대소문자가 다릅니다).

String string1 = "foo";
String string2 = "FOO";

if (string1.equals(string2))
{
    // this line will not print because the
    // java string equals method returns false:
    System.out.println("The two strings are the same.")
}

단, 두 문자열에 동일한 문자열이 포함되어 있는 경우 다음 예시와 같이 equals 메서드는 true를 반환합니다.

String string1 = "foo";
String string2 = "foo";

// test for equality with the java string equals method
if (string1.equals(string2))
{
    // this line WILL print
    System.out.println("The two strings are the same.")
}

옵션 2: 동등한 문자열과의 비교Ignore Case 메서드

일부 문자열 비교 테스트에서는 문자열이 대문자인지 소문자인지 무시해야 합니다.이 대소문자를 구분하지 않는 방법으로 문자열의 동일성을 테스트하려면 equals를 사용합니다.String 클래스의 IgnoreCase 메서드는 다음과 같습니다.

String string1 = "foo";
String string2 = "FOO";

 // java string compare while ignoring case
 if (string1.equalsIgnoreCase(string2))
 {
     // this line WILL print
     System.out.println("Ignoring case, the two strings are the same.")
 }

옵션 3: compareTo 메서드를 사용한 Java 문자열 비교

Java 문자열을 비교하는 세 번째 방법으로는 String class compareTo 메서드가 있습니다.두 문자열이 완전히 동일한 경우 compareTo 메서드는 값 0을 반환합니다.다음은 이 String 비교 접근방식의 간단한 예입니다.

String string1 = "foo bar";
String string2 = "foo bar";

// java string compare example
if (string1.compareTo(string2) == 0)
{
    // this line WILL print
    System.out.println("The two strings are the same.")
}

Java에서 이 평등 개념에 대해 쓰고 있는 동안 Java 언어는 기본 Java Object 클래스에 equal 메서드를 포함하고 있다는 점에 유의해야 합니다.독자적인 오브젝트를 작성할 때 오브젝트의 2개의 인스턴스가 "동일"지 여부를 확인할 수 있는 수단을 제공하려면 클래스 내에서 this equal 메서드를 덮어쓰기(및 구현)해야 합니다(String equals 메서드에서 Java 언어가 이 동등/비교 동작을 제공하는 것과 동일).

이 ==, .syslog compareTo() 및 compare()를 볼 수 있습니다.

그==연산자는 두 참조가 동일한 객체를 가리키는지 여부를 확인합니다. .equals()실제 문자열 내용(값)을 확인합니다.

주의:.equals()메서드는 클래스에 속합니다.Object(모든 클래스의 슈퍼 클래스).클래스 요건에 따라 덮어쓸 필요가 있지만 String의 경우 이미 구현되어 있으며 두 문자열의 값이 동일한지 여부를 확인합니다.

• 케이스 1

  String s1 = "Stack Overflow";
  String s2 = "Stack Overflow";
  s1 == s2;      //true
  s1.equals(s2); //true
  

  이유: null 없이 작성된 문자열 리터럴은 힙의 permgen 영역의 String 풀에 저장됩니다.따라서 s1과 s2는 모두 풀 내의 동일한 개체를 가리킵니다.

• 케이스 2

  String s1 = new String("Stack Overflow");
  String s2 = new String("Stack Overflow");
  s1 == s2;      //false
  s1.equals(s2); //true
  

  이유: 를 사용하여 String 개체를 작성하는 경우new키워드를 지정하면 히프상의 공간에 별도의 공간이 할당됩니다.

기능:

public float simpleSimilarity(String u, String v) {
    String[] a = u.split(" ");
    String[] b = v.split(" ");

    long correct = 0;
    int minLen = Math.min(a.length, b.length);

    for (int i = 0; i < minLen; i++) {
        String aa = a[i];
        String bb = b[i];
        int minWordLength = Math.min(aa.length(), bb.length());

        for (int j = 0; j < minWordLength; j++) {
            if (aa.charAt(j) == bb.charAt(j)) {
                correct++;
            }
        }
    }

    return (float) (((double) correct) / Math.max(u.length(), v.length()));
}

테스트:

String a = "This is the first string.";

String b = "this is not 1st string!";

// for exact string comparison, use .equals

boolean exact = a.equals(b);

// For similarity check, there are libraries for this
// Here I'll try a simple example I wrote

float similarity = simple_similarity(a,b);

==오브젝트의 참조값을 비교합니다만,equals()에 존재하는 방법java.lang.Stringclass는 의 내용을 비교합니다.String오브젝트(다른 오브젝트)를 설정하다

내 생각에 네가 이 모든 것을 정의한다면String오브젝트를 정의합니다.그래서 당신은 그것을 사용할 필요가 있다..equals()원시 데이터 유형을 사용할 때 사용하는 경우==하지만String(및 모든 오브젝트)를 사용해야 합니다..equals().

이 경우,equals()메서드는 에 있습니다.java.lang.Object클래스, 오브젝트 상태의 동등성을 체크합니다!즉, 사물의 내용입니다.반면,==연산자는 실제 개체 인스턴스가 동일한지 여부를 확인해야 합니다.

예

두 개의 다른 기준 변수를 고려합니다.str1그리고.str2:

str1 = new String("abc");
str2 = new String("abc");

를 사용하는 경우equals()

System.out.println((str1.equals(str2))?"TRUE":"FALSE");

출력은 다음과 같습니다.TRUE사용한다면==.

System.out.println((str1==str2) ? "TRUE" : "FALSE");

자, 이제 당신은FALSE출력으로 사용할 수 있습니다.str1그리고.str2는, 같은 문자열의 내용을 공유하고 있어도, 2개의 다른 오브젝트를 가리키고 있습니다.때문이다new String()매번 새로운 오브젝트가 생성됩니다.

연산자 ==는 항상 개체 참조 비교를 의미하지만 String 클래스 .timeout() 메서드는 콘텐츠 비교를 위해 재정의됩니다.

String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1 == s2); // It prints false (reference comparison)
System.out.println(s1.equals(s2)); // It prints true (content comparison)

모든 오브젝트에는 반드시.equals()method는 객체에 메서드가 포함되어 있기 때문에.equals()부울을 반환합니다.추가 정의가 필요한 경우 이 메서드를 재정의하는 것이 하위 클래스의 작업입니다.이 기능이 없는 경우(즉, 사용)==) 메모리 주소만 2개의 오브젝트 간에 동일하게 체크됩니다.문자열이 이것을 덮어씁니다..equals()method는 메모리주소를 사용하는 대신 동일성을 위해 문자 수준의 문자열 비교를 반환합니다.

중요한 점은 문자열이 하나의 덩어리 풀에 저장되므로 문자열이 생성되면 동일한 주소의 프로그램에 영구히 저장된다는 것입니다.끈은 변하지 않고 불변합니다.그렇기 때문에 처리해야 할 문자열의 양이 심각한 경우에는 일반 문자열 연결을 사용하는 것이 좋지 않습니다.그 대신에,StringBuilder제공되고 있습니다.이 문자열에 대한 포인터는 변경될 수 있으며 두 포인터가 동일한지 여부를 확인할 수 있습니다.==가는 게 좋을 것 같아요스트링 자체는 그렇지 않습니다.

를 사용할 수도 있습니다.compareTo()두 문자열을 비교하는 메서드.compareTo 결과가 0이면 두 문자열이 같고 그렇지 않으면 비교되는 문자열이 동일하지 않습니다.

그==는 참조를 비교하고 실제 스트링은 비교하지 않습니다.모든 문자열을 작성한 경우new String(somestring).intern()그 후 를 사용할 수 있습니다.==연산자는 두 문자열을 비교합니다.그렇지 않으면 equals() 또는 compareTo 메서드만 사용할 수 있습니다.

자바에서는,==연산자는 두 개체를 비교하는 데 사용되며, 개체가 메모리 내의 동일한 위치를 참조하는지 확인합니다.즉, 2개의 오브젝트명이 기본적으로 같은 메모리 위치에 대한 참조인지 여부를 확인합니다.

자바Stringclass는 디폴트를 실제로 덮어씁니다.equals()에서의 실장Objectclass:메서드를 덮어쓰고 메모리 내 위치가 아닌 문자열 값만 체크합니다.즉, 만약 당신이 전화한다면equals()비교 방법 2String오브젝트에서는 실제 문자 시퀀스가 동일하면 양쪽 오브젝트가 동일한 것으로 간주됩니다.

그==연산자는 두 문자열이 정확히 동일한 개체인지 확인합니다.

그.equals()method는 두 문자열의 값이 동일한지 여부를 확인합니다.

언급URL : https://stackoverflow.com/questions/513832/how-do-i-compare-strings-in-java