వేర్వేరు డొమైన్లలో స్ట్రింగ్ మానిప్యులేషన్ ఎంతో సహాయపడుతుంది. ఇది సహాయపడవచ్చు టెక్స్ట్ అనలిటిక్స్ , డేటా మ్యాచింగ్, డేటా మైనింగ్ మొదలైనవి. ఈ వ్యాసంలో మేము జావాలోని రెండు తీగలను పోల్చడంపై దృష్టి పెడతాము, ఇది స్ట్రింగ్ మానిప్యులేషన్ కోసం విభిన్న ప్రయోజనాల కోసం. ఇక్కడ చర్చించబడే పాయింటర్లు క్రిందివి
- స్ట్రింగ్ ఈక్వల్స్ మెథడ్
- స్ట్రింగ్ సమానం కేసును విస్మరించండి
- ఆబ్జెక్ట్ ఈక్వల్స్ మెథడ్
- స్ట్రింగ్ పద్ధతితో పోల్చండి
- ఆపరేటర్‌కు డబుల్ ఈక్వల్ ఉపయోగించడం
కాబట్టి అప్పుడు ప్రారంభిద్దాం,
జావాలో రెండు తీగలను పోల్చడం
అక్షరాల క్రమాన్ని స్ట్రింగ్‌గా నిర్వచించవచ్చు. అవి మార్పులేనివి, అనగా అవి సృష్టించబడిన తర్వాత సవరించబడవు. జావాలో రెండు తీగలను పోల్చడానికి వివిధ పద్ధతులు ఉన్నాయి, క్రింద చూడవచ్చు.
స్ట్రింగ్ ఈక్వల్స్ మెథడ్
స్ట్రింగ్‌లో ఉన్న విలువల ఆధారంగా తీగలను పోల్చారు. విలువలు సరిపోలకపోతే రెండు తీగల విలువలు ఒకేలా ఉంటే మరియు తప్పుగా ఉంటే పద్ధతి నిజం అవుతుంది.
పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ శూన్య మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {స్ట్రింగ్ str1 = కొత్త స్ట్రింగ్ ('రాక్') స్ట్రింగ్ str2 = కొత్త స్ట్రింగ్ ('రోల్') స్ట్రింగ్ str3 = కొత్త స్ట్రింగ్ ('రాక్') స్ట్రింగ్ str4 = కొత్త స్ట్రింగ్ ('రాక్') స్ట్రింగ్ str5 = కొత్త స్ట్రింగ్ ('రోల్') // తీగలను పోల్చడం System.out.println ('పోల్చడం' + str1 + 'మరియు' + str2 + ':' + str1.equals (str2)) సిస్టమ్ .out.println ('పోల్చడం' + str3 + 'మరియు' + str4 + ':' + str3.equals (str4)) System.out.println ('పోల్చడం' + str4 + 'మరియు' + str5 + ':' + str4.equals (str5)) System.out.println ('పోల్చడం' + str1 + 'మరియు' + str4 + ':' + str1.equals (str4))}}అవుట్పుట్:
రాక్ అండ్ రోల్ పోల్చడం: తప్పుడు
రాక్ మరియు రాక్ పోల్చడం: తప్పుడు
రాక్ అండ్ రోల్ పోల్చడం: తప్పుడు
రాక్ అండ్ రాక్ పోల్చడం: నిజం
ఈ వ్యాసం యొక్క రెండవ బిట్‌తో కొనసాగిద్దాం,
స్ట్రింగ్ సమానం కేసును విస్మరించండి
ఈ పద్ధతి రెండు తీగలను పోల్చి చూస్తుంది మరియు స్ట్రింగ్ (తక్కువ లేదా ఎగువ) విషయంలో పరిగణనలోకి తీసుకోదు. విలువలు సమానంగా ఉంటే మరియు శూన్యంగా లేకుంటే నిజం అవుతుంది.
పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ శూన్య మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {స్ట్రింగ్ str1 = కొత్త స్ట్రింగ్ ('రాక్') స్ట్రింగ్ str2 = కొత్త స్ట్రింగ్ ('రోల్') స్ట్రింగ్ str3 = కొత్త స్ట్రింగ్ ('రాక్') స్ట్రింగ్ str4 = కొత్త స్ట్రింగ్ . out.println ('పోల్చడం' + str3 + 'మరియు' + str4 + ':' + str3.equalsIgnoreCase (str4)) System.out.println ('పోల్చడం' + str4 + 'మరియు' + str5 + ':' + str4 .equalsIgnoreCase (str5)) System.out.println ('పోల్చడం' + str1 + 'మరియు' + str4 + ':' + str1.equalsIgnoreCase (str4))}}అవుట్పుట్:
రాక్ అండ్ రోల్ పోల్చడం: తప్పుడు
రాక్ మరియు రాక్ పోల్చడం: నిజం
రాక్ అండ్ రోల్ పోల్చడం: తప్పుడు
రాక్ అండ్ రాక్ పోల్చడం: నిజం
జావా వ్యాసంలోని రెండు తీగలను పోల్చిన తదుపరి బిట్‌తో మరింత ముందుకు వెళ్దాం,
ఆబ్జెక్ట్ ఈక్వల్స్ మెథడ్
వాదనలు ఒకదానికొకటి సమానంగా ఉంటే, పద్ధతి నిజం అవుతుంది, లేకపోతే, అది తప్పుగా వస్తుంది. ప్రస్తుతం ఉన్న రెండు వాదనలు శూన్యమైతే, తిరిగి వచ్చిన అవుట్పుట్ నిజం. ఒకే వాదన శూన్య విలువ కలిగి ఉంటే, తిరిగి వచ్చిన అవుట్పుట్ తప్పు.
దిగుమతి java.util. * పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ శూన్య మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {స్ట్రింగ్ str1 = కొత్త స్ట్రింగ్ ('రాక్') స్ట్రింగ్ str2 = కొత్త స్ట్రింగ్ ('రోల్') స్ట్రింగ్ str3 = కొత్త స్ట్రింగ్ ('రోల్' ) స్ట్రింగ్ str4 = శూన్య స్ట్రింగ్ str5 = శూన్యమైన సిస్టమ్. str2 + 'మరియు' + str3 + ':' + Objects.equals (str2, str3)) System.out.println ('పోల్చడం' + str1 + 'మరియు' + str4 + ':' + Objects.equals (str1, str4 )) System.out.println ('పోల్చడం' + str4 + 'మరియు' + str5 + ':' + Objects.equals (str4, str5))}}అవుట్పుట్:
జావాలో మార్పులేని వస్తువు ఏమిటి
రాక్ అండ్ రోల్ పోల్చడం: తప్పుడు
రోల్ మరియు రోల్ పోల్చడం: నిజం
రాక్ మరియు శూన్యతను పోల్చడం: తప్పుడు
శూన్య మరియు శూన్యతను పోల్చడం: నిజం
ఇప్పుడు మరింత ముందుకు వెళ్దాం
స్ట్రింగ్ పద్ధతితో పోల్చండి
ఈ పద్ధతిలో, ఇన్పుట్ తీగలను ఒకదానితో ఒకటి పోల్చారు. పోలిక తర్వాత తిరిగి వచ్చిన విలువ ఈ క్రింది విధంగా ఉంటుంది:
- (str1> str2) ఉంటే, సానుకూల విలువ తిరిగి ఇవ్వబడుతుంది.
- (Str1 == str2) ఉంటే, 0 తిరిగి ఇవ్వబడుతుంది.
- ఉంటే (str1
కోడ్
దిగుమతి java.util. * పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ శూన్య మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {స్ట్రింగ్ str1 = కొత్త స్ట్రింగ్ ('రాక్') స్ట్రింగ్ str2 = కొత్త స్ట్రింగ్ ('పాప్') స్ట్రింగ్ str3 = కొత్త స్ట్రింగ్ ('రోల్' ) స్ట్రింగ్ str4 = క్రొత్త స్ట్రింగ్ ('రోల్') System.out.println ('పోల్చడం' + str1 + 'మరియు' + str2 + ':' + str1.compareTo (str2)) // పోలిక స్ట్రింగ్ 3 = స్ట్రింగ్ 4 సిస్టమ్. out.println ('పోల్చడం' + str3 + 'మరియు' + str4 + ':' + str3.compareTo (str4)) System.out.println ('పోల్చడం' + str2 + 'మరియు' + str4 + ':' + str2 .compareTo (str4))}}అవుట్పుట్:
రాక్ మరియు పాప్ పోల్చడం: 2
రోల్ మరియు రోల్ పోల్చడం: 0
పాప్ మరియు రోల్ పోల్చడం: -2
ఇది జావా వ్యాసంలోని రెండు తీగలను పోల్చిన చివరి బిట్‌కు మనలను తీసుకువస్తుంది,
ఆపరేటర్‌కు డబుల్ ఈక్వల్ ఉపయోగించడం
రెండు స్ట్రింగ్ విలువలను పోల్చినప్పుడు ఈ పద్ధతి తప్పించాలి. సమానం () మరియు == ఆపరేటర్ మధ్య ప్రధాన తేడాలు క్రింద ఇవ్వబడ్డాయి:
సమానం () ఒక పద్ధతి అయితే, == ఒక ఆపరేటర్.
== ఆపరేటర్ రిఫరెన్స్ పోలిక కోసం ఉపయోగించబడుతుంది, మరోవైపు, కంటెంట్ పోలిక కోసం సమానం () పద్ధతి ఉపయోగించబడుతుంది.
== ఆపరేటర్ నివారించబడుతుంది, ఎందుకంటే ఇది రిఫరెన్స్ సమానత్వం కోసం తనిఖీ చేస్తుంది, అనగా తీగలను ఒకే వస్తువుకు సూచిస్తే లేదా.
కోడ్
దిగుమతి java.util. * పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {స్ట్రింగ్ str1 = కొత్త స్ట్రింగ్ ('రాక్') స్ట్రింగ్ str2 = కొత్త స్ట్రింగ్ ('రాక్') System.out.println (str1 == str2) System.out.println (str1.equals (str2))}}అవుట్పుట్:
తప్పుడు
నిజం
వ్యాసంలో పేర్కొన్న పద్ధతులు జావా యొక్క ప్రోగ్రామింగ్ భాషలో రెండు తీగలను పోల్చడానికి ఒక ఖచ్చితమైన మార్గాన్ని అందిస్తాయి.
ఈ విధంగా ‘జావాలోని వస్తువుల శ్రేణి’ పై ఈ వ్యాసం ముగిసింది. మీరు మరింత తెలుసుకోవాలనుకుంటే, చూడండి విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు కోర్ మరియు అధునాతన జావా భావనలతో పాటు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.
mysql వర్క్‌బెంచ్‌ను ఎలా ఉపయోగించాలి
మాకు ప్రశ్న ఉందా? దయచేసి ఈ వ్యాసం యొక్క వ్యాఖ్యల విభాగంలో దీనిని ప్రస్తావించండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.