జావాలో స్ట్రింగ్ మరియు ఈక్వల్స్ పోలికలను సరిపోల్చండి

హాయ్! ఈ రోజు మనం చాలా ముఖ్యమైన మరియు ఆసక్తికరమైన అంశం గురించి మాట్లాడుతాము, అవి వస్తువులతో వస్తువులను పోల్చడం (తీగలను మరియు సమానాలను సరిపోల్చండి). కాబట్టి జావాలో, ఆబ్జెక్ట్ A ఎప్పుడు ఆబ్జెక్ట్ B కి సమానంగా ఉంటుంది ? ఒక ఉదాహరణ రాయడానికి ప్రయత్నిద్దాం:

public class Car {

   String model;
   int maxSpeed;

   public static void main(String[] args) {
      
       Car car1 = new Car();
       car1.model = "Ferrari";
       car1.maxSpeed = 300;

       Car car2 = new Car();
       car2.model = "Ferrari";
       car2.maxSpeed = 300;

       System.out.println(car1 == car2);
   }
}

కన్సోల్ అవుట్‌పుట్: తప్పుడు వేచి ఉండండి, ఆపు. ఈ రెండు కార్లు ఎందుకు సమానంగా లేవు? మేము వారికి ఒకే లక్షణాలను కేటాయించాము, కానీ పోలిక యొక్క ఫలితం తప్పు. సమాధానం సులభం. == ఆపరేటర్ ఆబ్జెక్ట్ రిఫరెన్స్‌లను పోలుస్తుంది, ఆబ్జెక్ట్ లక్షణాలను కాదు. రెండు వస్తువులు ఒకే విలువలతో 500 ఫీల్డ్‌లను కలిగి ఉండవచ్చు, కానీ వాటిని పోల్చడం ఇప్పటికీ తప్పుగా ఉంటుంది. అన్ని తరువాత, సూచనలు car1 మరియు car2రెండు వేర్వేరు వస్తువులను, అంటే రెండు వేర్వేరు చిరునామాలను సూచించండి. మీరు వ్యక్తులను పోల్చే పరిస్థితిని ఊహించుకోండి. ఖచ్చితంగా, ప్రపంచంలో ఎక్కడో ఒక వ్యక్తి మీ అదే పేరు, కంటి రంగు, వయస్సు, ఎత్తు, జుట్టు రంగు మొదలైనవాటిని పంచుకుంటారు. ఇది మిమ్మల్ని చాలా విషయాలలో సారూప్యతను కలిగిస్తుంది, కానీ మీరు ఇప్పటికీ కవలలు కాదు — మరియు మీరు స్పష్టంగా లేరు అదే వ్యక్తి. == ఆపరేటర్ మనం రెండు వస్తువులను పోల్చడానికి ఉపయోగించినప్పుడు దాదాపు ఇదే లాజిక్‌ని ఉపయోగిస్తుంది. అయితే మీ ప్రోగ్రామ్ వేరే లాజిక్‌ని ఉపయోగించడానికి మీకు అవసరమైతే ఏమి చేయాలి? ఉదాహరణకు, మీ ప్రోగ్రామ్ DNA విశ్లేషణ చేస్తుందనుకుందాం. ఇది ఇద్దరు వ్యక్తుల జన్యు సంకేతాన్ని పోలుస్తుంది మరియు వారు కవలలు కాదా అని నిర్ణయిస్తుంది.

public class Man {

   int geneticCode;

   public static void main(String[] args) {

       Man man1 = new Man();
       man1.geneticCode = 1111222233;

       Man man2 = new Man();
       man2.geneticCode = 1111222233;

       System.out.println(man1 == man2);
   }
}

కన్సోల్ అవుట్‌పుట్: తప్పు మనం అదే లాజికల్ ఫలితాన్ని పొందుతాము (ఎందుకంటే మనం పెద్దగా మారలేదు), కానీ ఇప్పుడు ఆ లాజిక్ మంచిది కాదు! అన్నింటికంటే, నిజ జీవితంలో, DNA విశ్లేషణ మనకు కవలలు మన ముందు నిలబడి ఉన్నారని 100% హామీని ఇవ్వాలి. కానీ మా ప్రోగ్రామ్ మరియు == ఆపరేటర్ మాకు వ్యతిరేకం చెబుతాయి. మేము ఈ ప్రవర్తనను ఎలా మార్చాలి మరియు DNA సరిపోలినప్పుడు ప్రోగ్రామ్ సరైన ఫలితాన్ని ఇస్తుందని నిర్ధారించుకోవడం ఎలా? దీని కోసం జావా ఒక ప్రత్యేక పద్ధతిని కలిగి ఉంది: సమానం() . మేము ఇంతకుముందు చర్చించిన toString() పద్ధతి వలె , సమానం() అనేది ఆబ్జెక్ట్ క్లాస్‌కు చెందినది — జావాలోని అత్యంత ముఖ్యమైన తరగతి, ఇతర తరగతులన్నీ ఉత్పన్నమయ్యే తరగతి. కానీ సమానం()మా ప్రోగ్రామ్ యొక్క ప్రవర్తనను పూర్తిగా మార్చదు:

public class Man {

   String geneticCode;

   public static void main(String[] args) {

       Man man1 = new Man();
       man1.geneticCode = "111122223333";

       Man man2 = new Man();
       man2.geneticCode = "111122223333";

       System.out.println(man1.equals(man2));
   }
}

కన్సోల్ అవుట్‌పుట్: తప్పు సరిగ్గా అదే ఫలితం, కాబట్టి మనకు ఈ పద్ధతి దేనికి అవసరం? :/ ఇదంతా చాలా సులభం. ఇక్కడ సమస్య ఏమిటంటే, మేము ప్రస్తుతం ఈ పద్ధతిని ఆబ్జెక్ట్ క్లాస్‌లో అమలు చేస్తున్నందున ఉపయోగిస్తున్నాము . మరియు మేము ఆబ్జెక్ట్ క్లాస్ కోడ్‌లోకి వెళ్లి , పద్ధతి యొక్క అమలును చూస్తే, ఇది మనం చూస్తాము:

public boolean equals(Object obj) {
   return (this == obj);
}

ప్రోగ్రామ్ ప్రవర్తన మారకపోవడానికి కారణం అదే! అదే == ఆపరేటర్ (ఇది రిఫరెన్స్‌లను పోలుస్తుంది) ఆబ్జెక్ట్ క్లాస్ యొక్క సమాన() పద్ధతిలో ఉపయోగించబడుతుంది . కానీ ఈ పద్ధతిలో ఉన్న ఉపాయం ఏమిటంటే మనం దానిని అధిగమించవచ్చు. ఓవర్‌రైడ్ చేయడం అంటే మా మ్యాన్ క్లాస్‌లో మీ స్వంత ఈక్వల్స్() పద్ధతిని వ్రాయడం , దానికి మనకు అవసరమైన ప్రవర్తన ఇవ్వడం! ప్రస్తుతం, man1.equals(man2) తప్పనిసరిగా man1 == man2 కి సమానం కావడం మాకు ఇష్టం లేదు . ఈ పరిస్థితిలో మేము ఏమి చేస్తాము:

public class Man { 

   int dnaCode; 

   public boolean equals(Man man) { 
       return this.dnaCode ==  man.dnaCode; 

   } 

   public static void main(String[] args) { 

       Man man1 = new Man(); 
       man1.dnaCode = 1111222233; 

       Man man2 = new Man(); 
       man2.dnaCode = 1111222233; 

       System.out.println(man1.equals(man2)); 

   } 
} 

కన్సోల్ అవుట్‌పుట్: నిజం ఇప్పుడు మేము పూర్తిగా భిన్నమైన ఫలితాన్ని పొందుతాము! మా స్వంత సమాన() పద్ధతిని వ్రాయడం ద్వారా మరియు ప్రామాణిక పద్ధతికి బదులుగా దాన్ని ఉపయోగించడం ద్వారా, మేము సరైన ప్రవర్తనను రూపొందించాము: ఇప్పుడు ఇద్దరు వ్యక్తులు ఒకే DNA కలిగి ఉంటే, ప్రోగ్రామ్ "DNA విశ్లేషణ వారు కవలలు అని నిరూపించబడింది" అని నివేదిస్తుంది మరియు నిజమని చూపుతుంది! మీ తరగతుల్లో ఈక్వల్స్() పద్ధతిని భర్తీ చేయడం ద్వారా , మీకు అవసరమైన ఏదైనా వస్తువు పోలిక తర్కాన్ని మీరు సులభంగా సృష్టించవచ్చు. నిజానికి, మేము కేవలం వస్తువు పోలికను మాత్రమే తాకాము. మా ముందు, ఈ అంశంపై ఇంకా పెద్ద స్వతంత్ర పాఠం ఉంది (మీకు ఆసక్తి ఉంటే ఇప్పుడు మీరు దాన్ని దాటవేయండి).

జావాలో తీగలను పోల్చడం

స్ట్రింగ్ పోలికలను అన్నిటి నుండి విడిగా ఎందుకు పరిగణిస్తున్నాము? రియాలిటీ ఏమిటంటే ప్రోగ్రామింగ్‌లో స్ట్రింగ్‌లు వాటి స్వంత అంశం. ముందుగా, మీరు ఇప్పటివరకు వ్రాసిన అన్ని జావా ప్రోగ్రామ్‌లను తీసుకుంటే, వాటిలోని దాదాపు 25% వస్తువులు స్ట్రింగ్‌లు అని మీరు కనుగొంటారు. కాబట్టి ఈ అంశం చాలా ముఖ్యమైనది. రెండవది, తీగలను పోల్చే ప్రక్రియ నిజంగా ఇతర వస్తువుల నుండి చాలా భిన్నంగా ఉంటుంది. ఒక సాధారణ ఉదాహరణను పరిగణించండి:

public class Main {

   public static void main(String[] args) {

       String s1 = "CodeGym is the best website for learning Java!";
       String s2 = new String("CodeGym is the best website for learning Java!");
       System.out.println(s1 == s2);
   }
}

కన్సోల్ అవుట్‌పుట్: తప్పు కానీ మనం ఎందుకు తప్పు చేసాము? అన్నింటికంటే, స్ట్రింగ్‌లు సరిగ్గా ఒకే విధంగా ఉంటాయి, పదానికి పదం :/ మీరు కారణాన్ని ఊహించి ఉండవచ్చు: == ఆపరేటర్ రిఫరెన్స్‌లను పోల్చినందున ! స్పష్టంగా, s1 మరియు s2 మెమరీలో వేర్వేరు చిరునామాలను కలిగి ఉన్నాయి. మీరు దాని గురించి ఆలోచించినట్లయితే, మా ఉదాహరణను మళ్లీ పని చేద్దాం:

public class Main {

   public static void main(String[] args) {

       String s1 = "CodeGym is the best website for learning Java!";
       String s2 = "CodeGym is the best website for learning Java!";
       System.out.println(s1 == s2);
   }
}

ఇప్పుడు మనకు మళ్లీ రెండు సూచనలు ఉన్నాయి, కానీ ఫలితం సరిగ్గా వ్యతిరేకం: కన్సోల్ అవుట్‌పుట్: నిజమైన నిస్సహాయంగా గందరగోళంగా ఉందా? ఏం జరుగుతుందో తెలుసుకుందాం. == ఆపరేటర్ నిజంగా మెమరీ చిరునామాలను సరిపోల్చుతుంది. ఇది ఎల్లప్పుడూ నిజం మరియు మీరు అనుమానించాల్సిన అవసరం లేదు. అంటే s1 == s2 నిజమని తిరిగి ఇస్తే, ఈ రెండు స్ట్రింగ్‌లు ఒకే చిరునామాను కలిగి ఉంటాయి. మరియు ఇది నిజంగా నిజం! స్ట్రింగ్‌లను నిల్వ చేయడానికి మెమరీ యొక్క ప్రత్యేక ప్రాంతాన్ని మీకు పరిచయం చేయడానికి ఇది సమయం: స్ట్రింగ్ పూల్ స్ట్రింగ్ పూల్ అనేది మీ ప్రోగ్రామ్‌లో మీరు సృష్టించే అన్ని స్ట్రింగ్ విలువలను నిల్వ చేయడానికి ఒక ప్రాంతం. అది ఎందుకు సృష్టించబడింది? మేము ముందు చెప్పినట్లుగా, తీగలు అన్ని వస్తువులలో భారీ శాతాన్ని సూచిస్తాయి. ఏదైనా పెద్ద ప్రోగ్రామ్ చాలా స్ట్రింగ్‌లను సృష్టిస్తుంది. మెమరీని సేవ్ చేయడానికి స్ట్రింగ్ పూల్ సృష్టించబడింది: స్ట్రింగ్‌లు అక్కడ ఉంచబడతాయి మరియు ఆ తర్వాత సృష్టించబడిన స్ట్రింగ్‌లు అదే మెమరీ ప్రాంతాన్ని సూచిస్తాయి-ప్రతిసారి అదనపు మెమరీని కేటాయించాల్సిన అవసరం లేదు. మీరు స్ట్రింగ్ = "........" అని వ్రాసిన ప్రతిసారీ స్ట్రింగ్ పూల్‌లో ఒకే విధమైన స్ట్రింగ్ ఉందో లేదో ప్రోగ్రామ్ తనిఖీ చేస్తుంది. ఉంటే, కొత్త స్ట్రింగ్ సృష్టించబడదు. మరియు కొత్త సూచన స్ట్రింగ్ పూల్‌లో (ఒకేలా స్ట్రింగ్ ఉన్న చోట) అదే చిరునామాను సూచిస్తుంది. కాబట్టి మేము వ్రాసినప్పుడు

String s1 = "CodeGym is the best website for learning Java!";

String s2 = "CodeGym is the best website for learning Java!";

s2 అదే స్థలానికి s1 పాయింట్లు . మొదటి స్టేట్‌మెంట్ స్ట్రింగ్ పూల్‌లో కొత్త స్ట్రింగ్‌ను సృష్టిస్తుంది. రెండవ ప్రకటన కేవలం s1 వలె మెమరీ యొక్క అదే ప్రాంతాన్ని సూచిస్తుంది . మీరు మరో 500 సారూప్య తీగలను తయారు చేయవచ్చు మరియు ఫలితం మారదు. ఒక నిమిషం ఆగు. అది నిజమైతే, ఈ ఉదాహరణ ఇంతకు ముందు ఎందుకు పని చేయలేదు?

public class Main {

   public static void main(String[] args) {

       String s1 = "CodeGym is the best website for learning Java!";
       String s2 = new String("CodeGym is the best website for learning Java!");
       System.out.println(s1 == s2);
   }
}

మీ అంతర్ దృష్టి మీకు కారణం చెప్పిందని నేను భావిస్తున్నాను =) మరింత చదవడానికి ముందు ఊహించడానికి ప్రయత్నించండి. ఈ రెండు తీగలు వేర్వేరు మార్గాల్లో ప్రకటించబడినట్లు మీరు చూడవచ్చు. ఒకటి కొత్త ఆపరేటర్‌తో, మరొకటి అది లేకుండా. ఇక్కడే కారణం ఉంది. ఆబ్జెక్ట్‌ని సృష్టించడానికి కొత్త ఆపరేటర్‌ని ఉపయోగించినప్పుడు , అది ఆబ్జెక్ట్ కోసం కొత్త మెమరీ ప్రాంతాన్ని బలవంతంగా కేటాయిస్తుంది. మరియు కొత్తదాన్ని ఉపయోగించి సృష్టించబడిన స్ట్రింగ్ స్ట్రింగ్ పూల్‌లో ముగియదు - దాని వచనం స్ట్రింగ్ పూల్‌లోని స్ట్రింగ్‌తో సరిగ్గా సరిపోలినప్పటికీ, అది ప్రత్యేక వస్తువుగా మారుతుంది. అంటే, మేము ఈ క్రింది కోడ్‌ను వ్రాస్తే:

public class Main {

   public static void main(String[] args) {

       String s1 = "CodeGym is the best website for learning Java!";
       String s2 = "CodeGym is the best website for learning Java!";
       String s3 = new String("CodeGym is the best website for learning Java!");
   }
}

మెమరీలో, ఇది ఇలా కనిపిస్తుంది: మరియు మీరు కొత్త ఆబ్జెక్ట్‌ని సృష్టించిన ప్రతిసారీ కొత్త స్ట్రింగ్‌లోని టెక్స్ట్ ఒకేలా ఉన్నప్పటికీ, కొత్త మెమరీ ప్రాంతం కేటాయించబడుతుంది! మేము == ఆపరేటర్‌ని కనుగొన్నట్లు కనిపిస్తోంది . కానీ మా కొత్త పరిచయం, సమానం() పద్ధతి గురించి ఏమిటి?

public class Main {

   public static void main(String[] args) {

       String s1 = "CodeGym is the best website for learning Java!";
       String s2 = new String("CodeGym is the best website for learning Java!");
       System.out.println(s1.equals(s2));
   }
}

కన్సోల్ అవుట్‌పుట్: నిజమైన ఆసక్తికరం. s1 మరియు s2 మెమరీలోని వివిధ ప్రాంతాలను సూచిస్తాయని మాకు ఖచ్చితంగా తెలుసు . కానీ సమాన () పద్ధతి ఇప్పటికీ మాకు వారు సమానమని చెబుతుంది. ఎందుకు? మనకు కావలసిన వస్తువులను పోల్చడానికి సమాన () పద్ధతిని భర్తీ చేయవచ్చని మేము ఇంతకు ముందు చెప్పినట్లు గుర్తుందా ? స్ట్రింగ్ క్లాస్‌తో వారు చేసినది అంతే . ఇది సమానం()ని భర్తీ చేస్తుందిపద్ధతి. మరియు సూచనలను పోల్చడానికి బదులుగా, ఇది తీగలలోని అక్షరాల క్రమాన్ని పోల్చింది. వచనం ఒకేలా ఉంటే, అవి ఎలా సృష్టించబడ్డాయి లేదా అవి ఎక్కడ నిల్వ చేయబడ్డాయి అనేది పట్టింపు లేదు: స్ట్రింగ్ పూల్ లేదా మెమరీ యొక్క ప్రత్యేక ప్రాంతంలో అయినా. పోలిక యొక్క ఫలితం నిజం అవుతుంది. మార్గం ద్వారా, జావా కేస్-ఇన్సెన్సిటివ్ స్ట్రింగ్ పోలికలను నిర్వహించడానికి మిమ్మల్ని అనుమతిస్తుంది. సాధారణంగా, స్ట్రింగ్‌లలో ఒకదానికి అన్ని పెద్ద అక్షరాలు ఉంటే, అప్పుడు పోలిక యొక్క ఫలితం తప్పుగా ఉంటుంది:

public class Main {

   public static void main(String[] args) {

       String s1 = "CodeGym is the best website for learning Java!";
       String s2 = new String("CODEGYM IS THE BEST WEBSITE FOR LEARNING JAVA!");
       System.out.println(s1.equals(s2));
   }
}

కన్సోల్ అవుట్‌పుట్: తప్పు కేస్-ఇన్‌సెన్సిటివ్ పోలికలకు, స్ట్రింగ్ క్లాస్ ఈక్వల్‌ఇగ్నోర్‌కేస్() పద్ధతిని కలిగి ఉంటుంది. మీరు అక్షరం కేసు కంటే నిర్దిష్ట అక్షరాల క్రమాన్ని సరిపోల్చడం గురించి మాత్రమే శ్రద్ధ వహిస్తే మీరు దాన్ని ఉపయోగించవచ్చు. ఉదాహరణకు, రెండు చిరునామాలను పోల్చినప్పుడు ఇది సహాయకరంగా ఉంటుంది:

public class Main {

   public static void main(String[] args) {

       String address1 = "2311 Broadway Street, San Francisco";
       String address2 = new String("2311 BROADWAY STREET, SAN FRANCISCO");
       System.out.println(address1.equalsIgnoreCase(address2));
   }
}

ఈ సందర్భంలో, మేము స్పష్టంగా అదే చిరునామా గురించి మాట్లాడుతున్నాము, కాబట్టి ఈక్వల్‌ఇగ్నోర్‌కేస్() పద్ధతిని ఉపయోగించడం అర్ధమే .

String.intern() పద్ధతి

స్ట్రింగ్ క్లాస్ మరొక గమ్మత్తైన పద్ధతిని కలిగి ఉంది: ఇంటర్న్( ) ; ఇంటర్న్ () పద్ధతి స్ట్రింగ్ పూల్‌తో నేరుగా పని చేస్తుంది. మీరు కొన్ని స్ట్రింగ్‌లో ఇంటర్న్() పద్ధతిని కాల్ చేస్తే :

• ఇది స్ట్రింగ్ పూల్‌లో మ్యాచింగ్ స్ట్రింగ్ ఉందో లేదో తనిఖీ చేస్తుంది
• ఉంటే, అది పూల్‌లోని స్ట్రింగ్‌కు సూచనను అందిస్తుంది
• కాకపోతే, అది స్ట్రింగ్ పూల్‌కి స్ట్రింగ్‌ని జోడిస్తుంది మరియు దానికి రిఫరెన్స్‌ని అందిస్తుంది.

కొత్తని ఉపయోగించి పొందిన స్ట్రింగ్ రిఫరెన్స్‌పై ఇంటర్న్() పద్ధతిని ఉపయోగించిన తర్వాత , స్ట్రింగ్ పూల్ నుండి స్ట్రింగ్ రిఫరెన్స్‌తో పోల్చడానికి మనం == ఆపరేటర్‌ని ఉపయోగించవచ్చు .

public class Main {

   public static void main(String[] args) {

       String s1 = "CodeGym is the best website for learning Java!";
       String s2 = new String("CodeGym is the best website for learning Java!");
       System.out.println(s1 == s2.intern());
   }
}

కన్సోల్ అవుట్‌పుట్: నిజమే మేము ఈ స్ట్రింగ్‌లను ఇంటర్న్() లేకుండా పోల్చినప్పుడు , ఫలితం తప్పు. ఇప్పుడు ఇంటర్న్() పద్ధతి "కోడ్‌జిమ్ జావా నేర్చుకోవడానికి ఉత్తమమైన సైట్!" అనే స్ట్రింగ్‌ని తనిఖీ చేస్తుంది. స్ట్రింగ్ పూల్‌లో ఉంది. వాస్తవానికి, ఇది: మేము దీన్ని సృష్టించాము

String s1 = "CodeGym is the best website for learning Java!";

s2.intern() ద్వారా అందించబడిన s1 మరియు రిఫరెన్స్‌లు ఒకే మెమరీ ప్రాంతాన్ని సూచిస్తాయో లేదో మేము తనిఖీ చేస్తాము . మరియు వాస్తవానికి, వారు చేస్తారు :) సారాంశంలో, గుర్తుంచుకోండి మరియు ఈ ముఖ్యమైన నియమాన్ని వర్తింపజేయండి: తీగలను సరిపోల్చడానికి ఎల్లప్పుడూ సమాన () పద్ధతిని ఉపయోగించండి! స్ట్రింగ్‌లను పోల్చినప్పుడు, మేము దాదాపు ఎల్లప్పుడూ రిఫరెన్స్‌లు, మెమరీ ప్రాంతాలు లేదా మరేదైనా కాకుండా వాటి అక్షరాలను సరిపోల్చాలని సూచిస్తాము. ఈక్వల్స్ () పద్ధతి మీకు అవసరమైన దాన్ని ఖచ్చితంగా చేస్తుంది. మీరు నేర్చుకున్న వాటిని బలోపేతం చేయడానికి, మా జావా కోర్సు నుండి వీడియో పాఠాన్ని చూడమని మేము మీకు సూచిస్తున్నాము