Ang Java String ay katumbas ng()

Ang paghahambing ng mga bagay para sa equivalence ay isa sa pinakamahalagang pagpapatakbo ng programming. Gayunpaman, para sa lahat ng pagiging malinaw nito sa numeric na mundo, hindi palaging malinaw kung paano ihambing ang iba pang mga uri ng data. Ang klase ng Java Object , isang pangunahing, ay tumutukoy sa equals() at compareTo() na mga pamamaraan para sa paghahambing. Ino-override ng klase ng string ang equals() na pamamaraan nito . Ang Java String equals() method ay naghahambing ng dalawang string ayon sa mga nilalaman nito. String equals() method signature ay ganito ang hitsura:

public boolean equals(Object anotherObject)

String equals() method ay inihahambing ang string sa tinukoy na object. Kung ang mga string ay pantay, ito ay nagbabalik ng totoo, kung hindi man ito ay mali. Maaaring nagtataka ka kung bakit hindi ihambing ang mga string gamit ang == paghahambing operator? Sa katunayan, posible rin ito, ngunit ang resulta ay medyo naiiba. Ang katotohanan ay ang == operator ay naghahambing ng mga address sa memorya. Kaya kung ang s1 == s2 ay nagbabalik true , ang dalawang string na ito ay may parehong address sa memorya. Kasabay nito, sinusuri ng equals ang mga nilalaman ng mga string para sa pagkakapantay-pantay. Kumuha tayo ng isang halimbawa ng paghahambing ng dalawang string.

public class StringEqualsTest {
   //program to test Java equals() method
   public static void main(String[] args) {
       String myString1 = "here is my favorite string";
       String myString2 = "here is my favorite string"; //this string is the same as the previous one, at least we think so
       String myString3 = "here is My favorite string"; //this string looks a little bit like previous two, but the first letter is big M instead of small m
       String myString4 = new String("here is my favorite string");
//here we create a String in an object manner… Why? Find out soon
       String myString5 = "equals to myString1? No, not at all..."; //here we have absolutely different string. Just for fun
    //let’s compare myString1 with myString2 using “==” operator
       System.out.println(myString1 == myString2); //true
    //let’s compare myString1 with myString4 using “==” operator
       System.out.println(myString1 == myString4); //false
//and now we are going to use equals() method to compare myString1 with myString4, myString2 and myString5
     System.out.println(myString1.equals(myString4));//true
       System.out.println(myString1.equals(myString2));//true
       System.out.println(myString1.equals(myString5)); //false

   }
}

Ang output ng program na ito ay: Tingnan natin kung ano ang nangyayari dito. Kapag gumawa tayo ng string, inilalagay ito sa string pool, isang espesyal na lugar ng memorya. Ang mga string ay tumatagal ng isang malaking bahagi ng lahat ng mga bagay sa anumang malaking programa. Kaya para makatipid ng memorya, nilikha ang String Pool, kung saan inilalagay ang isang string na may tekstong kailangan mo. Sa ibang pagkakataon, ang mga bagong likhang link ay tumutukoy sa parehong lugar ng memorya, hindi na kailangang maglaan ng karagdagang memorya sa bawat oras. Kung lumikha ka ng isang string na walang bagong operator, iyon ay, kapag sumulat ka

String  myStringName = "...........................................",

o isang bagay na tulad nito, sinusuri ng programa kung mayroong isang String na may ganoong teksto sa String pool. Kung oo, walang bagong String na gagawin. At ang bagong link ay ituturo sa parehong address sa String Pool kung saan naka-imbak na ang String na iyon . Kaya noong nagsulat kami sa programa

String myString1 = "here is my favorite string";
String myString2 = "here is my favorite string";

ang reference myString1 tumuturo sa eksaktong parehong lugar sa memorya bilang myString2 . Ang unang utos ay lumikha ng isang bagong string sa String Pool kasama ang teksto na kailangan namin, at pagdating sa pangalawa, ito ay tumutukoy lamang sa parehong lugar ng memorya bilang myString1 . Ngunit ang string myString4 ay nilikha bilang isang bagay gamit ang bagong operator. Ang operator na ito ay naglalaan ng isang bagong lugar sa memorya para sa isang bagay kapag ito ay nilikha. Isang string na ginawa gamit ang bago

String myString1 = new String ("here is my favorite string");
String myString2 = new String ("here is my favorite string");

ay hindi nahuhulog sa String Pool, ngunit nagiging isang hiwalay na bagay, kahit na ang teksto nito ay ganap na tumutugma sa parehong string mula sa String Pool. Bukod dito, kung ihahambing natin ang mga string gamit ang String equals() na pamamaraan, susuriin nito hindi ang address, ngunit ang mga nilalaman ng string, ang pagkakasunud-sunod ng mga character sa mga string. At kung ang teksto sa mga string ay pareho, hindi mahalaga kung paano nilikha ang mga ito at kung saan sila naka-imbak, sa String Pool, o sa isang hiwalay na lugar ng memorya. Iyon ang dahilan kung bakit ang myString1 , myString2 at myString4 ay pantay sa paghahambing na ito. Sa pamamagitan ng paraan, napansin mo ba na ang String equals() na pamamaraan ay nagbibigay-daan sa iyo na ihambing nang tama ang mga string sa isang case-sensitive na paraan? Iyon ay, kung ihahambing natin ang string na "my string" sa mga string na "My string" at "MY STRING" makakakuha tayo ng false.

public class StringEqualsTest {

   public static void main(String[] args) {

       String myString1 = new String ("here is my favorite string");
       String myString2 = new String ("here is My favorite string");
       String myString3 = new String("HERE IS MY FAVORITE STRING");

       System.out.println(myString1.equals(myString2)); //false because first string myString1 has small m and myString2 has big M instead
       System.out.println(myString1.equals(myString3));//false because myString1 is in lowercase while myString3 is in uppercase

   }
}

Ang output ay narito: Upang ihambing ang mga string sa isang case insensitive na paraan, ang Java ay may isang paraan na halos kapareho sa equals :

boolean equalsIgnoreCase​(String anotherString)

Gamitin natin ito sa ating halimbawa.

public class StringEqualsTest {

   public static void main(String[] args) {

       String myString1 = new String ("here is my favorite string");
       String myString2 = new String ("here is My favorite string");
       String myString3 = new String("HERE IS MY FAVORITE STRING");
     /* here we are going to use the brother of equals() method, equalsIgnoreCase(). It can help to check user input when case isn’t
important */
       System.out.println(myString1.equalsIgnoreCase(myString2));

       System.out.println(myString1.equalsIgnoreCase(myString3));

   }
}

Ngayon ang output ay: