ఉదాహరణలతో జావాలో కంపారిటర్ ఇంటర్‌ఫేస్ అంటే ఏమిటి?
కంపారిటర్ ఇంటర్‌ఫేస్‌లో కంపేర్() మరియు ఈక్వల్స్() పద్ధతులు ఉన్నాయి. పూర్ణాంక విలువను తిరిగి ఇవ్వడం ద్వారా రెండు వస్తువులను గణించడానికి మొదటి పద్ధతి ఉపయోగించబడుతుంది. సమానత్వం కోసం రెండు కంపారిటర్ వస్తువులను కంప్యూటింగ్ చేయడానికి ఇతర పద్ధతి ఉపయోగించబడుతుంది.
జావాలో కంపారిటర్ ఇంటర్‌ఫేస్‌ను ఎలా ఉపయోగించాలో ఇక్కడ విభిన్న ఉదాహరణలు ఉన్నాయి:
ఉదాహరణ 1: పొడవు ఆధారంగా జాబితాను క్రమబద్ధీకరించండి
ఈ ఉదాహరణలో, స్ట్రింగ్‌ల జాబితా పరిగణించబడుతుంది మరియు అక్షర క్రమంలో కాకుండా వాటి పొడవు ఆధారంగా వాటిని క్రమబద్ధీకరించండి:
దిగుమతి java.util.ArrayList ;
దిగుమతి java.util.Collections ;
దిగుమతి java.util.Comparator ;
దిగుమతి java.util.List ;
ప్రజా తరగతి ప్రధాన {
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
జాబితా < స్ట్రింగ్ > జాబితా = కొత్త అర్రేలిస్ట్ <> ( ) ;
జాబితా. జోడించు ( 'జాన్' ) ;
జాబితా. జోడించు ( 'బాబ్' ) ;
జాబితా. జోడించు ( 'ఆలిస్' ) ;
సేకరణలు . క్రమబద్ధీకరించు ( జాబితా ) ;
వ్యవస్థ . బయటకు . println ( జాబితా ) ;
సేకరణలు . క్రమబద్ధీకరించు ( జాబితా, కొత్త స్ట్రింగ్ లెంగ్త్ కంపారేటర్ ( ) ) ;
వ్యవస్థ . బయటకు . println ( జాబితా ) ;
}
} // ఒక తరగతి నిర్వచించబడింది
తరగతి స్ట్రింగ్ లెంగ్త్ కంపారేటర్ అమలు చేస్తుంది కంపారిటర్ < స్ట్రింగ్ > {
ప్రజా int సరిపోల్చండి ( స్ట్రింగ్ s1, స్ట్రింగ్ s2 ) {
తిరిగి పూర్ణ సంఖ్య . సరిపోల్చండి ( s1. పొడవు ( ) , s2. పొడవు ( ) ) ;
}
}
పై కోడ్ యొక్క వివరణ క్రింద ఇవ్వబడింది:
- ముందుగా, Comparator
ఇంటర్‌ఫేస్‌ను అమలు చేసే StringLengthComparator అనే కస్టమ్ కంపారేటర్ క్లాస్‌ను సృష్టించండి. - ఇది రెండు స్ట్రింగ్‌ల పొడవును పోల్చడానికి కంపేర్() పద్ధతిని భర్తీ చేస్తుంది.
- చివరగా, మా అనుకూల కంపారేటర్‌ని ఉపయోగించి జాబితాను క్రమబద్ధీకరించడానికి the.sort() పద్ధతికి ఒక ఉదాహరణను పంపండి.
అవుట్‌పుట్
మొదటి అవుట్‌పుట్ అనేది సహజ క్రమాన్ని ఉపయోగించి జాబితాను క్రమబద్ధీకరించడం వల్ల వచ్చే ఫలితం, రెండవ అవుట్‌పుట్ ప్రతి స్ట్రింగ్ యొక్క పొడవు ఆధారంగా మా అనుకూల కంపారిటర్‌ని ఉపయోగించి జాబితాను క్రమబద్ధీకరించడం వల్ల వస్తుంది.
ఉదాహరణ 2: నిర్దిష్ట ఫీల్డ్ ఆధారంగా వస్తువులను క్రమబద్ధీకరించడం
ఒక నిర్దిష్ట ఫీల్డ్ ఆధారంగా వస్తువులను క్రమబద్ధీకరించడానికి మరొక ఉదాహరణ నిర్వహించబడుతుంది. దీన్ని సాధించడానికి కంపారిటర్ ఇంటర్‌ఫేస్ ఉపయోగించబడుతుంది:
దిగుమతి java.util.ArrayList ;దిగుమతి java.util.Collections ;
దిగుమతి java.util.Comparator ;
దిగుమతి java.util.List ;
ప్రజా తరగతి ప్రధాన {
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
జాబితా < వ్యక్తి > వ్యక్తులు = కొత్త అర్రేలిస్ట్ <> ( ) ; // పేరు, వయస్సు మరియు జీతాలను కేటాయించండి
వ్యక్తులు. జోడించు ( కొత్త వ్యక్తి ( 'ఆలిస్' , 25 , 50000 ) ) ;
వ్యక్తులు. జోడించు ( కొత్త వ్యక్తి ( 'బాబ్' , 30 , 75000 ) ) ;
వ్యక్తులు. జోడించు ( కొత్త వ్యక్తి ( 'చార్లీ' , ఇరవై , 40000 ) ) ;
కంపారిటర్ < వ్యక్తి > జీతం కంపారేటర్ = కొత్త కంపారిటర్ < వ్యక్తి > ( ) {
// జీతం ఆధారంగా వ్యక్తులను క్రమబద్ధీకరించండి
ప్రజా int సరిపోల్చండి ( వ్యక్తి p1, వ్యక్తి p2 ) {
తిరిగి పూర్ణ సంఖ్య . సరిపోల్చండి ( p2. జీతం పొందండి ( ) , p1. జీతం పొందండి ( ) ) ;
}
} ;
సేకరణలు . క్రమబద్ధీకరించు ( వ్యక్తులు, జీతం కంపారేటర్ ) ; తిరిగి క్రమబద్ధీకరణ విలువలు
// క్రమబద్ధీకరించబడిన వ్యక్తుల జాబితాను ముద్రించండి
కోసం ( వ్యక్తి వ్యక్తి : వ్యక్తులు ) {
వ్యవస్థ . బయటకు . println ( వ్యక్తి ) ;
}
}
}
తరగతి వ్యక్తి { // పేరు, వయస్సు మరియు జీతం నిర్వచించండి
ప్రైవేట్ స్ట్రింగ్ పేరు ; // తరగతిలో పరిధి
ప్రైవేట్ int వయస్సు ;
ప్రైవేట్ int జీతం ;
ప్రజా వ్యక్తి ( స్ట్రింగ్ పేరు, int వయస్సు, int జీతం ) {
ఇది . పేరు = పేరు ;
ఇది . వయస్సు = వయస్సు ;
ఇది . జీతం = జీతం ;
}
ప్రజా స్ట్రింగ్ పేరు పొందండి ( ) {
తిరిగి పేరు ;
}
ప్రజా int వయస్సు ( ) {
తిరిగి వయస్సు ;
}
ప్రజా int జీతం పొందండి ( ) {
తిరిగి జీతం ;
}
ప్రజా స్ట్రింగ్ స్ట్రింగ్ ( ) {
తిరిగి పేరు + '(వయస్సు' + వయస్సు + ', జీతం $' + జీతం + ')' ;
}
}
కోడ్ యొక్క వివరణ క్రింద ఇవ్వబడింది:
- 'అని ఒక తరగతి వ్యక్తి 'మూడు ఫీల్డ్‌లతో:' పేరు ',' వయస్సు ', మరియు' జీతం ” అని భావిస్తారు.
- ఆ తర్వాత, వారి జీతం ఆధారంగా వ్యక్తి వస్తువుల సేకరణను అవరోహణ క్రమంలో క్రమబద్ధీకరించండి.
అవుట్‌పుట్
అవరోహణ క్రమం ప్రకారం జీతాలు క్రమబద్ధీకరించబడినట్లు అవుట్‌పుట్ చూపిస్తుంది.
ముగింపు
జావాలో, కంపారిటర్ ఇంటర్‌ఫేస్ అనేది వినియోగదారులను అనుకూల ప్రమాణాల ఆధారంగా వస్తువులను క్రమబద్ధీకరించడానికి అనుమతించే శక్తివంతమైన సాధనం. ఇది కంపేర్() పద్ధతిని ఓవర్‌రైడ్ చేస్తుంది, వినియోగదారులు వారి స్వంత పోలిక ఫంక్షన్‌ను నిర్వచించవచ్చు మరియు వివిధ మార్గాల్లో వస్తువుల సేకరణలను క్రమబద్ధీకరించడానికి దాన్ని ఉపయోగించవచ్చు. ఈ వ్యాసం జావాలోని ఆచరణాత్మక ఉదాహరణలతో పాటు కంపారిటర్ ఇంటర్‌ఫేస్‌ను వివరించింది.