Jak porównać ciągi w Javie?

Do tej pory używałem ==operatora w moim programie do porównywania wszystkich moich ciągów. Jednak natknąłem się na błąd, .equals()zamiast tego zmieniłem jeden z nich i naprawiłem błąd.

Jest ==źle? Kiedy powinien i nie powinien być używany? Co za różnica?

== testy równości odniesienia (czy są to ten sam obiekt).

.equals() sprawdza równość wartości (czy są one logicznie „równe”).

Objects.equals () sprawdza nullprzed wywołaniem, .equals()więc nie musisz (dostępne od JDK7, dostępne również w Guava ).

W związku z tym, jeśli chcesz przetestować, czy dwa ciągi mają tę samą wartość, prawdopodobnie będziesz chciał użyć 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

Prawie zawsze chcesz używać Objects.equals(). W rzadkich sytuacji, gdy znamy masz do czynienia z internowanych strun, to można użyć ==.

Z JLS 3.10.5. Literały smyczkowe :

Co więcej, literał łańcuchowy zawsze odnosi się do tego samego wystąpienia klasy String. Wynika to z tego, że literały łańcuchowe - lub, bardziej ogólnie, łańcuchy, które są wartościami wyrażeń stałych ( § 15.28 ) - są „internowane” w celu współużytkowania unikalnych instancji przy użyciu tej metody String.intern.

Podobne przykłady można również znaleźć w JLS 3.10.5-1 .

Inne metody do rozważenia

String.equalsIgnoreCase () równość wartości, która ignoruje wielkość liter.

String.contentEquals () porównuje zawartość Stringz zawartością dowolnego CharSequence(dostępnego od Java 1.5). Chroni Cię przed koniecznością zamiany StringBuffer itp. W String przed wykonaniem porównania równości, ale pozostawia ci sprawdzanie wartości null.

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

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ą w rzeczywistości 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 wartości zerowe!

==nulldobrze obsługuje łańcuchy, ale wywołanie .equals()z łańcucha pustego 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 to fooString1może być zerowe, powiedz to czytelnikowi pisząc

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

Poniższe są krótsze, ale mniej oczywiste jest, że sprawdza wartość null:

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

== porównuje odniesienia do obiektów.

.equals() porównuje wartości ciągu.

Czasami ==daje złudzenie porównywania wartości String, jak w następujących przypadkach:

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

Wynika to z faktu, że po utworzeniu dowolnego literału łańcuchowego JVM najpierw szuka tego literału w puli łańcuchów, a jeśli znajdzie dopasowanie, to samo odniesienie zostanie podane do nowego łańcucha. Z tego powodu otrzymujemy:

(a == b) ===> true

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

Jednak ==kończy się niepowodzeniem w następującym przypadku:

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

W tym przypadku dla new String("test")instrukcji zostanie utworzony nowy ciąg na stercie, i to odwołanie zostanie przekazane b, więc bzostanie podane odwołanie na stercie, a nie w puli ciągów.

Teraz awskazuje na ciąg znaków w puli ciągów, podczas gdy bwskazuje ciąg na stercie. Z tego powodu otrzymujemy:

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

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

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

Chociaż .equals()zawsze porównuje wartość parametru String, więc w obu przypadkach daje wartość 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

Dlatego używanie .equals()jest zawsze lepsze.

Do ==kontroli operatora, aby zobaczyć, jeśli dwa ciągi są dokładnie tego samego obiektu.

.equals()Metoda sprawdzi, czy dwa ciągi mają tę samą wartość.

Ciągi w Javie są niezmienne. Oznacza to, że ilekroć spróbujesz zmienić / zmodyfikować ciąg, otrzymasz nową instancję. Nie możesz zmienić oryginalnego ciągu. Dokonano tego, aby można było buforować te instancje ciągów. Typowy program zawiera wiele odwołań do łańcuchów, a buforowanie tych instancji może zmniejszyć zużycie pamięci i zwiększyć wydajność programu.

Kiedy używasz operatora == do porównywania łańcucha, nie porównujesz zawartości łańcucha, ale w rzeczywistości porównujesz adres pamięci. Jeśli oba są równe, zwróci prawdę, a fałsz w przeciwnym razie. Natomiast równość w ciągu znaków porównuje zawartość ciągu.

Pytanie brzmi, czy wszystkie łańcuchy są buforowane w systemie, dlaczego? == zwraca false, a równa zwraca true? To jest możliwe. Jeśli utworzysz nowy ciąg znaków, tak jak w String str = new String("Testing")końcu utworzysz nowy ciąg w pamięci podręcznej, nawet jeśli pamięć podręczna zawiera już ciąg o tej samej zawartości. Krótko mówiąc "MyString" == new String("MyString"), zawsze zwróci fałsz.

Java mówi także o funkcji intern (), której można użyć w ciągu znaków, aby stał się częścią pamięci podręcznej, aby "MyString" == new String("MyString").intern()zwrócił wartość true.

Uwaga: operator == jest znacznie szybszy niż równy tylko dlatego, że porównujesz dwa adresy pamięci, ale musisz mieć pewność, że kod nie tworzy nowych instancji String 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

Upewnij się, że rozumiesz dlaczego. Jest tak, ponieważ ==porównanie porównuje tylko odniesienia; equals()metoda robi porównanie znak po znaku zawartości.

Kiedy wywołujesz new for ai b, każdy otrzymuje nowe odniesienie, które wskazuje na "foo"w tabeli ciągów. Odniesienia są różne, ale treść jest taka sama.

Tak, to źle ...

==oznacza, że ​​dwa odwołania do łańcucha 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 ciągi są ładowane na różne sposoby, zbudowane z innych ciągów itp., Więc nigdy nie należy zakładać, że dwa identyczne ciągi są przechowywane w tym samym miejscu.

Równa się robi dla ciebie prawdziwe porównanie.

Tak, ==źle nadaje się do porównywania ciągów (tak naprawdę obiektów, chyba że wiesz, że są kanoniczne). ==po prostu porównuje odwołania do obiektów. .equals()testy na równość. W przypadku ciągów często będą one takie same, ale jak odkryłeś, nie zawsze jest to gwarantowane.

Java ma pulę String, w której Java zarządza alokacją pamięci dla obiektów String. Zobacz Pule ciągów w Javie

Podczas sprawdzania (porównywania) dwóch obiektów za pomocą ==operatora porównuje się równość adresów do puli ciągów. Jeśli dwa obiekty String mają te same odnośniki adresowych następnie powraca true, inaczej false. Ale jeśli chcesz porównać zawartość dwóch obiektów String, musisz zastąpić equalsmetodę.

equals jest w rzeczywistości 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 uwaga szanuje przypadek String. Jeśli chcesz porównywać bez rozróżniania wielkości 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

Zgadzam się z odpowiedzią zacherates.

Ale to, co możesz zrobić, to przywołać intern()swoje nieliteralne ciągi.

Z przykładu zacherates:

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

Jeśli internujesz nie literalną równość ciągów to true:

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

==porównuje odwołania do obiektów w Javie i nie jest to wyjątkiem dla Stringobiektów.

Aby porównać rzeczywistą zawartość obiektów (w tym String), należy użyć equalsmetody .

Jeśli okaże się , że porównano dwa używane Stringobiekty , to dlatego, że obiekty zostały internowane, a wirtualna maszyna Java ma wiele odwołań do tego samego wystąpienia . Nie należy się spodziewać, że porównanie jednego obiektu zawierającego tę samą zawartość, co inny obiekt wykorzystujący do oceny jako .==trueStringStringStringString==true

.equals()porównuje dane w klasie (przy założeniu, że funkcja jest zaimplementowana). ==porównuje położenia wskaźnika (położenie obiektu w pamięci).

==zwraca true, jeśli oba obiekty (NIE MÓWIĄC O PRIMITIVES) wskazują na SAMĄ instancję obiektu. .equals()zwraca true, jeśli dwa obiekty zawierają te same dane w equals()porównaniu ==z Javą

To może ci pomóc.

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

equals()Metoda sprawdzi, czy zawartość lub te stany z 2 obiektów są takie same.

Oczywiście ==jest szybszy, ale da (może) dać fałszywe wyniki w wielu przypadkach, jeśli chcesz tylko powiedzieć, czy 2 Strings zawierają ten sam tekst.

Zdecydowanie zaleca się użycie equals()metody.

Nie martw się o wydajność. Niektóre rzeczy zachęcające do korzystania String.equals():

1. Wdrożenie String.equals()pierwszych kontroli równości odniesienia (za pomocą ==), a jeśli 2 ciągi znaków są takie same przez odniesienie, dalsze obliczenia nie są przeprowadzane!
2. Jeśli odniesienia do 2 ciągów znaków nie są takie same, String.equals()następnie sprawdzi długości ciągów. Jest to również szybka operacja, ponieważ Stringklasa przechowuje długość łańcucha, nie trzeba liczyć znaków ani punktów kodowych. Jeśli długości różnią się, nie jest przeprowadzana dalsza kontrola, wiemy, że nie mogą być równe.
3. Tylko jeśli dotrzemy tak daleko, zawartość 2 łańcuchów zostanie faktycznie porównana i będzie to porównanie skrótowe: nie wszystkie znaki zostaną porównane, jeśli znajdziemy niedopasowany znak (w tej samej pozycji w 2 łańcuchach ), dalsze znaki nie będą sprawdzane.

Kiedy wszystko jest już powiedziane i zrobione, nawet jeśli mamy gwarancję, że ciągi są stażystami, użycie tej equals()metody nie jest tak ogólne, jak mogłoby się wydawać, zdecydowanie zalecany sposób. Jeśli chcesz wydajnego sprawdzania referencji, używaj wyliczeń, jeśli jest to zagwarantowane przez specyfikację języka i implementację, że ta sama wartość wyliczenia będzie tym samym obiektem (przez odniesienie).

Jeśli jesteś podobny do mnie, kiedy po raz pierwszy zacząłem używać Javy, chciałem użyć operatora „==”, aby sprawdzić, czy dwa wystąpienia String są równe, ale na lepsze lub gorsze, nie jest to właściwy sposób na zrobienie tego w Javie.

W tym samouczku pokażę kilka różnych sposobów prawidłowego porównywania ciągów Java, zaczynając od podejścia, którego używam przez większość czasu. Na końcu tego samouczka porównywania ciągów Java również omówię, dlaczego operator „==” nie działa podczas porównywania ciągów Java.

Opcja 1: Porównanie ciągów Java z metodą równości Przez większość czasu (może w 95% przypadków) porównuję ciągi z metodą równości klasy Java String, jak poniżej:

if (string1.equals(string2))

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

Patrząc na szybki przykład porównania ciągów z metodą równości, gdyby przeprowadzono następujący test, dwa ciągi nie byłyby 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 ciągi zawierają dokładnie ten sam ciąg znaków, metoda równości 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 ciągów z metodą equalsIgnoreCase

W niektórych testach porównania ciągów zignorujesz, czy ciągi znaków są wielkie czy małe. Jeśli chcesz przetestować ciągi pod kątem równości w sposób bez rozróżniania wielkości liter, użyj metody equalsIgnoreCase klasy String, w następujący sposób:

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: Porównanie Java String z metodą CompareTo

Istnieje również trzeci, mniej powszechny sposób porównywania ciągów Java, i to z wykorzystaniem metody StringTerm porównania. Jeśli dwa ciągi są dokładnie takie same, metoda CompareTo zwróci wartość 0 (zero). Oto szybki przykład tego, jak wygląda ta metoda porównywania ciągów:

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

Pisząc o tej koncepcji równości w Javie, należy zauważyć, że język Java zawiera metodę równości w podstawowej klasie Java Object. Ilekroć tworzysz własne obiekty i chcesz zapewnić sposób sprawdzenia, czy dwa wystąpienia Twojego obiektu są „równe”, powinieneś zastąpić (i zaimplementować) tę metodę równości w swojej klasie (w taki sam sposób, jak zapewnia język Java) to zachowanie równości / porównania w metodzie String equals).

Możesz rzucić okiem na to ==, .equals (), CompareTo () i Compare ()

Funkcjonować:

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

==Check operator jeśli oba odwołania kierowane do tego samego obiektu, czy też nie. .equals()sprawdź rzeczywistą zawartość ciągu (wartość).

Zauważ, że .equals()metoda należy do klasy Object(superklasa wszystkich klas). Musisz go zastąpić zgodnie z wymaganiami 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ągów utworzone bez wartości zerowej są przechowywane w puli ciągów w obszarze permgen sterty. Zatem zarówno s1, jak i s2 wskazują na ten sam obiekt w puli.

• 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 za pomocą newsłowa kluczowego, na stercie zostanie mu przydzielone oddzielne miejsce.

==porównuje wartość referencyjną obiektów, podczas gdy equals()metoda obecna w java.lang.Stringklasie porównuje zawartość Stringobiektu (do innego obiektu).

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

Jeśli equals()metoda jest obecna w java.lang.Objectklasie i oczekuje się, że sprawdzi równoważność stanu obiektów! Oznacza to zawartość przedmiotów. Natomiast== operator powinien sprawdzić, czy rzeczywiste instancje obiektów są takie same, czy nie.

Przykład

Rozważ dwie różne zmienne odniesienia str1i str2:

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

Jeśli korzystasz z equals()

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

Otrzymasz wynik tak TRUE, jakbyś go używał ==.

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

Teraz dostaniesz FALSEjako wyjście, ponieważ oba str1i str2są skierowane do dwóch różnych obiektów, chociaż obaj dzielić tę samą treść napisów. Jest tak, ponieważ new String()za każdym razem tworzony jest nowy obiekt.

Operator == jest zawsze przeznaczony do porównywania referencji obiektowych , podczas gdy metoda String .equals () jest nadpisywana do porównywania treś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ą .equals()metodę, ponieważ Object zawiera metodę .equals(), która zwraca wartość logiczną. Zadaniem podklasy jest zastąpienie tej metody, jeśli wymagana jest dalsza definicja. Bez tego (tj. Przy użyciu ==) tylko adresy pamięci są sprawdzane między dwoma obiektami pod kątem równości. Ciąg zastępuje tę .equals()metodę i zamiast używać adresu pamięci zwraca porównanie ciągów znaków na poziomie równości.

Kluczową uwagą jest to, że łańcuchy są przechowywane w jednej puli brył, więc po utworzeniu łańcucha są one zawsze przechowywane w programie pod tym samym adresem. Ciągi się nie zmieniają, są niezmienne. Dlatego złym pomysłem jest stosowanie regularnej konkatenacji ciągów, jeśli masz poważne problemy z przetwarzaniem ciągów. Zamiast tego skorzystasz z StringBuilderdostarczonych klas. Pamiętaj, że wskaźniki tego ciągu mogą się zmienić, a jeśli chciałbyś sprawdzić, czy dwa wskaźniki były takie same, ==byłby to dobry sposób. Same łańcuchy nie.

Możesz także użyć tej compareTo()metody do porównania dwóch ciągów. Jeśli wynikiem porównania jest 0, wówczas dwa ciągi są równe, w przeciwnym razie porównywane ciągi nie są równe.

==Porównuje referencje i nie porównać rzeczywiste ciągi. Jeśli utworzyłeś każdy ciąg za pomocą new String(somestring).intern(), możesz użyć ==operatora do porównania dwóch ciągów, w przeciwnym razie można użyć tylko metod equals () lub CompareTo.

W Javie, gdy operator „==” jest używany do porównywania 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ą w zasadzie odniesieniami do tej samej lokalizacji pamięci.

Klasa Java String faktycznie przesłania domyślną implementację equals () w klasie Object - i przesłania metodę, tak aby sprawdzała tylko wartości łańcuchów, a nie ich położenia w pamięci. Oznacza to, że jeśli wywołasz metodę equals () w celu porównania 2 obiektów String, to dopóki rzeczywista sekwencja znaków jest równa, oba obiekty są uważane za równe.

Do ==kontroli operatora, jeśli dwa ciągi są dokładnie tego samego obiektu.

.equals()Check metoda, jeśli dwa ciągi mają tę samą wartość.