ఈ గైడ్ జావాలోని మరొక స్ట్రింగ్‌తో సమానంగా లేకుంటే గణించడానికి వివిధ పద్ధతులను వివరిస్తుంది.
- “!=” ఆపరేటర్‌ని ఉపయోగించడం
- సమాన () పద్ధతిని ఉపయోగించడం
- compareTo() పద్ధతిని ఉపయోగించడం
- compareToIgnoreCase() పద్ధతిని ఉపయోగించడం
- !equals() పద్ధతిని ఉపయోగించడం
“!=” ఆపరేటర్‌ని ఉపయోగించడం
రెండు వస్తువుల విలువలను పోల్చడానికి “!=” ఆపరేటర్ ఉపయోగించబడుతుంది. జావాలో, స్ట్రింగ్‌లు వస్తువులు, మరియు రెండు స్ట్రింగ్‌లు సమానంగా లేకుంటే గణించడానికి “!=” ఆపరేటర్‌ని ఉపయోగించవచ్చు. ఇక్కడ ఒక ఉదాహరణ:
తరగతి హలో వరల్డ్ {
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
స్ట్రింగ్ str1 = 'హలో' ;
స్ట్రింగ్ str2 = 'ప్రపంచం' ;
ఉంటే ( str1 != str2 ) {
వ్యవస్థ. బయటకు . println ( 'రెండు తీగలు సమానంగా లేవు' ) ;
}
}
}
అవుట్‌పుట్
పై కోడ్ యొక్క ఫలితం టెర్మినల్‌లో 'హలో' మరియు 'వరల్డ్' అనే రెండు స్ట్రింగ్‌లు సమానంగా లేవని నిరూపిస్తుంది.
సమాన () పద్ధతిని ఉపయోగించడం
ఈ పద్ధతి రెండు వస్తువుల విలువలను గణించడానికి ఉపయోగించబడుతుంది. రెండు స్ట్రింగ్‌ల విలువలను గణించడం కోసం స్ట్రింగ్ క్లాస్ ఈక్వల్స్()ని ఓవర్‌రైడ్ చేస్తుంది. ఇక్కడ ఒక ఉదాహరణ:
స్ట్రింగ్ str1 = 'హలో' ;
స్ట్రింగ్ str2 = 'ప్రపంచం' ;
ఉంటే ( ! str1. సమానం ( str2 ) ) {
వ్యవస్థ. బయటకు . println ( 'రెండు తీగలు సమానంగా లేవు' ) ;
}
అవుట్‌పుట్
పై కోడ్ యొక్క ఫలితం 'హలో' మరియు 'వరల్డ్' అనే రెండు స్ట్రింగ్‌లు సమానంగా లేవని నిర్ధారిస్తుంది.
compareTo() పద్ధతిని ఉపయోగించడం
ది పోల్చడానికి () పద్ధతి రెండు తీగల లెక్సికోగ్రాఫికల్ క్రమాన్ని పోల్చడానికి ఉపయోగించబడుతుంది. ఈ స్ట్రింగ్‌లు సమానంగా లేనప్పుడు, అది సున్నా కాకుండా వేరే విలువను అందిస్తుంది. ఇక్కడ ఒక ఉదాహరణ:
తరగతి హలో వరల్డ్ {ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
స్ట్రింగ్ str1 = 'హలో' ;
స్ట్రింగ్ str2 = 'ప్రపంచం' ;
ఉంటే ( str1. పోల్చడానికి ( str2 ) != 0 ) {
వ్యవస్థ. బయటకు . println ( 'రెండు తీగలు సమానంగా లేవు' ) ;
}
} }
అవుట్‌పుట్
రెండు స్ట్రింగ్‌లు సమానంగా లేవని అవుట్‌పుట్ చూపిస్తుంది.
compareToIgnoreCase() పద్ధతిని ఉపయోగించడం
compareToIgnoreCase() పద్ధతి compareTo() పద్ధతి వలె ఉంటుంది, కానీ ఇది స్ట్రింగ్‌ల కేసును విస్మరిస్తుంది. ఇక్కడ ఒక కోడ్ ఉంది:
తరగతి హలో వరల్డ్ {ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
స్ట్రింగ్ str1 = 'హలో' ;
స్ట్రింగ్ str2 = 'ప్రపంచం' ;
ఉంటే ( str1. సరిపోల్చండి ( str2 ) != 0 ) {
వ్యవస్థ. బయటకు . println ( 'రెండు తీగలు సమానంగా లేవు' ) ;
} }
}
అవుట్‌పుట్
స్ట్రింగ్‌లు సమానంగా లేవని అవుట్‌పుట్ చూపిస్తుంది.
!equals() పద్ధతిని ఉపయోగించడం
!equals() పద్ధతి రెండు స్ట్రింగ్‌లు సమానంగా ఉన్నాయా లేదా అని గణించడానికి ఉపయోగించబడుతుంది. ఇక్కడ ఒక ఉదాహరణ:
తరగతి హలో వరల్డ్ {ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
స్ట్రింగ్ str1 = 'హలో' ;
స్ట్రింగ్ str2 = 'ప్రపంచం' ;
ఉంటే ( ! str1. సమానం ( str2 ) ) {
వ్యవస్థ. బయటకు . println ( 'రెండు తీగలు సమానంగా లేవు' ) ;
} }
}
అవుట్‌పుట్
స్ట్రింగ్‌లు సమానంగా లేవని అవుట్‌పుట్ నిర్ధారిస్తుంది.
ముగింపు
జావాలో, ఒక స్ట్రింగ్ మరొక స్ట్రింగ్‌తో సమానంగా లేకుంటే తనిఖీ చేయండి, “!=” ఆపరేటర్, ఈక్వెల్స్() పద్ధతి, compareTo() పద్ధతి లేదా !equals() పద్ధతిని ఉపయోగించండి. ఈ పద్ధతులన్నీ జావాలో ఒక స్ట్రింగ్ మరొక స్ట్రింగ్‌తో సమానంగా ఉందో లేదో గణించడానికి ఉపయోగించబడతాయి. పద్ధతి యొక్క ఎంపిక ప్రోగ్రామ్ యొక్క నిర్దిష్ట అవసరాలు మరియు స్ట్రింగ్ పోలిక యొక్క కావలసిన స్థాయిపై ఆధారపడి ఉంటుంది.