Jak porównać ciągi w Javie?

== testuje odwołania do obiektów, .equals() testuje wartości ciągu znaków.

Czasami wygląda na to, że == porównuje wartości, ponieważ Java robi pewne rzeczy za kulisami, aby upewnić się, że identyczne ciągi w wierszu są rzeczywiście tym samym obiektem.

Na przykład:

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";

Ale uważaj na null!

== obsługuje null ciągi znaków w porządku, ale wywołanie {[5] } z null string spowoduje wyjątek:

String nullString1 = null;
String nullString2 = null;

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

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

Więc jeśli wiesz, że fooString1 może być null, powiedz czytelnikowi, że pisząc

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

Poniższy tekst jest krótszy, ale mniej oczywiste jest, że sprawdza null (Z Javy 7):

System.out.print(Objects.equals(fooString1, "bar"));

== porównuje odniesienia do obiektów.

.equals() porównuje wartości łańcuchów.

Czasami == daje iluzje porównywania wartości łańcuchów, jak w następujących przypadkach:

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

Dzieje się tak dlatego, że kiedy tworzysz dowolny literał Łańcuchowy, JVM najpierw wyszukuje ten literał w Puli łańcuchów, a jeśli znajdzie dopasowanie, to to samo odniesienie zostanie podane do nowego ciągu. Z tego powodu otrzymujemy:

(a= = b) = = = > true

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

Jednak == zawodzi w następującym przypadku:

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

W Tym Przypadku dla new String("test") Instrukcja new String zostanie utworzona na stercie, a odniesienie to zostanie podane do b, więc b zostanie podane odniesienie na stercie, a nie w Puli łańcuchów.

Teraz a wskazuje na łańcuch w Puli łańcuchów, podczas gdy {[10] } wskazuje na łańcuch na stercie. Z tego powodu otrzymujemy:

If (a= = b) = = = > false.

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

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

While .equals() zawsze porównuje wartość ciągu więc daje prawda w obu przypadkach:

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

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

Więc używanie .equals() jest zawsze lepsze.

Operator == sprawdza, czy oba łańcuchy są dokładnie tym samym obiektem.

Metoda .equals() sprawdzi, czy oba łańcuchy mają tę samą wartość.

Ciągi w Javie są niezmienne. Oznacza to, że za każdym razem, gdy próbujesz zmienić / zmodyfikować ciąg znaków, otrzymujesz nową instancję. Nie można zmienić oryginalnego ciągu znaków. Zostało to zrobione tak, że te instancje ciągu mogą być buforowane. Typowy program zawiera wiele odwołań ciągów, a buforowanie tych wystąpień może zmniejszyć ślad pamięci i zwiększyć wydajność programu.

Używając operatora = = do porównywania łańcuchów nie porównujesz zawartości łańcucha, ale są właściwie porównuję adres pamięci. Jeśli obie są równe, w przeciwnym razie zwróci się prawda i fałsz. Natomiast equals w łańcuchu porównuje zawartość łańcucha.

Więc pytanie brzmi, jeśli wszystkie łańcuchy są buforowane w systemie, dlaczego == zwraca false, podczas gdy równa się zwraca true? To możliwe. Jeśli tworzysz nowy ciąg znaków jak String str = new String("Testing"), w końcu tworzysz nowy ciąg w buforze, nawet jeśli bufor zawiera już ciąg o tej samej zawartości. W skrócie "MyString" == new String("MyString") zawsze powróci fałsz.

Java mówi również o funkcji intern (), która może być używana na łańcuchu znaków, aby stała się częścią pamięci podręcznej, więc "MyString" == new String("MyString").intern() zwróci true.

Uwaga: operator = = jest o wiele szybszy niż equals tylko dlatego, że porównujesz dwa adresy pamięci, ale musisz mieć pewność, że kod nie tworzy nowych instancji ciągu w kodzie. W przeciwnym razie napotkasz błędy.

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

Po wywołaniu new dla a i b, każdy z nich otrzymuje nowe odniesienie, które wskazuje na "foo" w tabeli łańcuchów. Odniesienia są różne, ale treść jest taka sama.

Tak, jest źle...

== oznacza, że Twoje dwa odwołania łańcuchowe są dokładnie tym samym obiektem. Być może słyszałeś, że tak jest, ponieważ Java zachowuje rodzaj dosłownej tabeli (co robi), ale nie zawsze tak jest. Niektóre struny są ładowane na różne sposoby, zbudowane z innych strun itp., więc nigdy nie należy zakładać, że dwa identyczne ciągi są przechowywane w tym samym miejscu.

Equals robi prawdziwe porównanie dla Ciebie.

Tak, == jest złe do porównywania łańcuchów (dowolne obiekty naprawdę, chyba że wiesz, że są kanoniczne). == po prostu porównuje odniesienia do obiektów. .equals() testy na równość. Dla strun, często będą takie same, ale jak odkryłeś, że nie zawsze jest to gwarantowane.

Java posiada pulę łańcuchów, w ramach której Java zarządza alokacją pamięci dla obiektów łańcuchowych. Zobacz też baseny strunowe w Javie

Podczas sprawdzania (porównywania) dwóch obiektów za pomocą operatora == porównuje równość adresu do puli łańcuchów. Jeśli dwa obiekty łańcuchowe mają te same odwołania do adresów, to zwraca true, w przeciwnym razie false. Ale jeśli chcesz porównać zawartość dwóch obiektów String, musisz nadpisać metodę equals.

equals w rzeczywistości jest metodą klasy Object, ale jest ona nadpisywana do klasy String i podana jest nowa definicja, która porównuje zawartość obiektu.

Example:
    stringObjectOne.equals(stringObjectTwo);

Ale pamiętaj, że szanuje przypadek String. Jeśli chcesz porównywać wielkość liter, musisz wybrać metodę equalsIgnoreCase klasy String.

Zobaczmy:

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

.equals() porównuje dane w klasie (zakładając, że funkcja jest zaimplementowana). == porównuje lokalizacje wskaźników (położenie obiektu w pamięci).

== zwraca true, jeśli oba obiekty (nie mówiąc o PRYMITYWACH) wskazują na tę samą instancję obiektu. .equals() zwraca true, jeśli oba obiekty zawierają te same dane equals() Versus == w Javie

== porównuje odniesienia do obiektów w Javie , co nie jest wyjątkiem dla obiektów String.

Do porównywania rzeczywistej zawartości obiektów (w tym String) należy użyć metody equals .

Jeśli porównanie dwóch obiektów String za pomocą == okazuje się być true, dzieje się tak dlatego, że obiekty String zostały internowane, a maszyna wirtualna Java ma wiele odniesień do tej samej instancji String. Nie należy się spodziewać, że porównując String obiekt zawierający tę samą zawartość co Inny String obiekt wykorzystujący == do oceny jako true.

Zgadzam się z odpowiedzią zachera.

Ale to, co możesz zrobić, to wywołać intern() na swoich Nie dosłownych ciągach.

Od zacherasa przykład:

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

Jeśli intern nie dosłowną równością ciągu jest true

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

== wykonuje reference sprawdzenie równości, czy 2 obiekty (w tym przypadku łańcuchy znaków) odnoszą się do tego samego obiektu w pamięci.

Metoda equals() sprawdzi, czy zawartość lub Stany dwóch obiektów są takie same.

Oczywiście == jest szybszy, ale w wielu przypadkach da fałszywe wyniki, jeśli chcesz tylko powiedzieć, czy 2 Stringsą zgodne z tym samym tekstem.

Zdecydowanie użycie metody equals() jest polecam.

Nie martw się o występ. Niektóre rzeczy zachęcające do używania String.equals():

1. implementacja String.equals() pierwszych sprawdzeń równości odniesienia (za pomocą ==), a jeśli 2 ciągi są takie same przez odniesienie, dalsze obliczenia nie są wykonywane!
2. Jeśli 2 odwołania łańcuchowe nie są takie same, String.equals() sprawdzi następnie długość łańcuchów. Jest to również szybka operacja, ponieważ klasa String przechowuje Długość łańcucha, nie ma potrzeby liczenia znaki lub punkty kodu. Jeśli długości różnią się, nie jest przeprowadzana dalsza kontrola, wiemy, że nie mogą być równe.
3. tylko jeśli doszliśmy tak daleko, zawartość 2 łańcuchów zostanie faktycznie porównana, a będzie to porównanie krótkie: nie wszystkie znaki zostaną porównane, jeśli znajdziemy niedopasowany znak (w tej samej pozycji w 2 łańcuchach), żadne dalsze znaki nie będą sprawdzane.

Kiedy wszystko jest powiedziane i zrobione, nawet jeśli mamy gwarancję, że ciągi są stażyści, stosowanie metody equals() nadal nie jest tak napowietrzne, że można by pomyśleć, zdecydowanie zalecany sposób. Jeśli chcesz sprawnego sprawdzania referencji, użyj enums, gdzie specyfikacja języka i implementacja gwarantują, że ta sama wartość enum będzie tym samym obiektem (przez referencję).

Jeśli jesteś taki jak ja, kiedy zaczynałem używać Javy, chciałem użyć operatora"==", aby sprawdzić, czy dwie instancje łańcuchów są równe, ale na dobre i na złe, to nie jest poprawny sposób, aby to zrobić w Javie.

W tym tutorialu zademonstruję kilka różnych sposobów poprawnego porównywania ciągów Javy, zaczynając od podejścia, którego używam przez większość czasu. Na końcu tego kursu Java String comparison omówię również, dlaczego operator "==" nie działa podczas porównywania Javy struny.

Option 1: Java String comparison with the equals method Przez większość czasu (może 95%) porównuję stringi z metodą equals klasy Java String, tak:

if (string1.equals(string2))

Ta metoda String equals sprawdza dwa ciągi znaków Java i jeśli zawierają dokładnie ten sam ciąg znaków, są one uważane za równe.

Przyjrzyjmy się przykładowi szybkiego porównywania łańcuchów z metodą equals. ciągi znaków nie będą uważane za równe, ponieważ znaki nie są dokładnie takie same (przypadek znaków jest inny):

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.")
}

Ale gdy dwa łańcuchy znaków zawierają dokładnie ten sam łańcuch znaków, metoda equals zwróci true, jak w tym przykładzie:

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.")
}

Opcja 2: Porównanie łańcuchów z metodą equalsIgnoreCase

W niektórych testach porównywania łańcuchów będziesz chciał zignorować, czy łańcuchy są wielkie czy małe. Kiedy chcesz przetestuj swoje ciągi pod kątem równości w tym przypadku-niewrażliwe na przypadki, użyj metody equalsIgnoreCase klasy String, tak:

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.")
 }

Opcja 3: Java String comparison with the compareTo method

Istnieje również trzeci, mniej popularny sposób porównywania łańcuchów Javy, a jest to metoda klasy String compareTo. Jeśli dwa ciągi znaków są dokładnie takie same, metoda compareTo zwróci wartość 0 (zero). Oto szybki przykład tego porównania ciągów podejście wygląda następująco:

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.")
}

Kiedy piszę o tej koncepcji równości w Javie, ważne jest, aby pamiętać, że język Java zawiera metodę equals w podstawowej klasie Java Object. Ilekroć tworzysz własne obiekty i chcesz zapewnić sposób sprawdzania, czy dwie instancje Twojego obiektu są "równe", powinieneś nadpisać (i zaimplementować) metodę this equals w swojej klasie (w ten sam sposób, w jaki język Java zapewnia zachowanie równości / porównywania w łańcuchu equals metoda).

Możesz rzucić okiem na to ==,.equals (), compareTo () i compare()

Funkcja:

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

Test:

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

Operator == sprawdza, czy oba odniesienia wskazują na ten sam obiekt, czy nie. .equals() Sprawdź aktualną zawartość łańcucha (wartość).

Zauważ, że metoda .equals() należy do klasy Object (super Klasa wszystkich klas). Musisz nadpisać go zgodnie z wymaganiami twojej klasy, ale dla String jest już zaimplementowany i sprawdza, czy dwa łańcuchy mają tę samą wartość, czy nie.

• Przypadek 1

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

  Powód: literały ciągu utworzone bez null są przechowywany w Puli ciągów w obszarze permgen sterty. Tak więc zarówno s1, jak i s2 wskazują na ten sam obiekt w basenie.

• Przypadek 2

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

  Powód: jeśli utworzysz obiekt String używając słowa kluczowego new, na stercie zostanie mu przydzielona osobna spacja.

== porównuje wartość odniesienia obiektów, podczas gdy metoda equals() obecna w klasie java.lang.String porównuje zawartość obiektu String (do innego obiektu).

Myślę, że kiedy definiujesz String definiujesz obiekt. Więc musisz użyć .equals(). Kiedy używasz prymitywnych typów danych, używasz ==, ale z String (i dowolnym obiektem) musisz użyć .equals().

Jeśli metoda equals() jest obecna w klasie java.lang.Object i oczekuje się, że sprawdzi równoważność stanu obiektów! To znaczy, zawartość przedmiotów. Podczas gdy oczekuje się, że operator == sprawdzi rzeczywiste instancje obiektu są takie same lub nie.

przykład

Rozważmy dwie różne zmienne referencyjne, str1 i str2:

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

Jeśli używasz equals()

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

Otrzymasz wyjście jako TRUE jeśli użyjesz ==.

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

Teraz otrzymasz FALSE jako wyjście, ponieważ oba str1 i str2 wskazują na dwa różne obiekty, mimo że oba mają tę samą zawartość łańcucha. Jest to spowodowane new String() za każdym razem tworzony jest nowy obiekt.

Operator == jest zawsze przeznaczony do porównywania obiektów , podczas gdy Klasa String .equals () metoda jest nadpisana dla porównanie zawartości :

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)

Wszystkie obiekty mają zagwarantowaną metodę .equals(), ponieważ obiekt zawiera metodę .equals(), która zwraca wartość logiczną. Zadaniem podklasy jest nadpisanie tej metody, jeśli wymagana jest dalsza definicja. Bez niego (tzn. używając ==) tylko adresy pamięci są sprawdzane pomiędzy dwoma obiektami pod kątem równości. String nadpisuje tę metodę .equals() i zamiast używać adresu pamięci zwraca porównanie łańcuchów na poziomie znaków dla równości.

Najważniejsze jest to, że ciągi są przechowywane w jednej puli, więc po utworzeniu ciąg jest na zawsze przechowywany w programie pod tym samym adresem. Ciągi nie zmieniają się, są niezmienne. To dlatego jest to zły pomysł, aby używać regularnego ciągu konkatenacji, jeśli masz poważne ilości przetwarzania ciągów do zrobienia. Zamiast tego użyłbyś klas StringBuilder. Pamiętaj, że wskaźniki do tego ciągu mogą się zmieniać i jeśli jesteś zainteresowany, aby zobaczyć, czy Dwa wskaźniki są takie same == byłoby dobrym sposobem. Struny sami nie.

Możesz również użyć metody compareTo() do porównania dwóch łańcuchów. Jeśli wynik porównania jest równy 0, to dwa ciągi są równe, w przeciwnym razie porównywane ciągi nie są równe.

== porównuje odwołania i nie porównuje rzeczywistych łańcuchów. Jeśli utworzyłeś każdy łańcuch za pomocą new String(somestring).intern(), możesz użyć operatora == do porównania dwóch łańcuchów, w przeciwnym razie można użyć metody equals() lub compareTo.

W Javie, gdy "==" operator jest używany do porównania 2 obiektów, sprawdza, czy obiekty odnoszą się do tego samego miejsca w pamięci. Innymi słowy, sprawdza, czy 2 nazwy obiektów są zasadniczo odniesieniami do tej samej lokalizacji pamięci.

Klasa Java String faktycznie nadpisuje domyślną implementację equals () w klasie obiektu – i nadpisuje metodę tak, że sprawdza tylko wartości łańcuchów, a nie ich lokalizacje w pamięci. Oznacza to, że jeśli wywołanie metody equals() do porównania 2 obiektów łańcuchowych, wtedy tak długo, jak rzeczywista kolejność znaków jest równa, oba obiekty są uważane za równe.

Operator == sprawdza, czy oba łańcuchy są dokładnie tym samym obiektem.

Metoda .equals() sprawdza, czy oba łańcuchy mają tę samą wartość.