జావాలో బల్క్ డేటాతో వ్యవహరిస్తున్నప్పుడు, డెవలపర్ కలిగి ఉన్న లేదా రూపొందించిన డేటాను క్రమబద్ధీకరించాల్సిన సందర్భాలు ఉండవచ్చు. ఉదాహరణకు, యాదృచ్ఛికంగా రూపొందించబడిన డేటాను క్రమబద్ధీకరించడం లేదా స్ట్రింగ్ డేటాను సాపేక్షంగా చేయడానికి అనుబంధించడం. అటువంటి పరిస్థితులలో, ' Arrays.sort() ” ప్రోగ్రామర్‌ను చాలా వరకు సులభతరం చేయడంలో జావాలోని పద్ధతి గొప్పగా సహాయపడుతుంది.
ఈ వ్యాసం ఉపయోగం మరియు అమలు గురించి వివరిస్తుంది Arrays.sort() ” జావాలో పద్ధతి.
జావాలో “Arrays.sort()” పద్ధతిని ఎలా ఉపయోగించాలి?
ది ' Arrays.sort() ” ప్రారంభ మరియు ముగింపు సూచికలను పేర్కొనడం ద్వారా శ్రేణిని పూర్తిగా లేదా దానిలో కొంత భాగాన్ని క్రమబద్ధీకరించడానికి పద్ధతిని ఉపయోగించవచ్చు.
వాక్యనిర్మాణం
శ్రేణులు.sort ( శ్రేణి, ప్రారంభం, ముగింపు ) ;
పై వాక్యనిర్మాణంలో:
- ' అమరిక ” క్రమబద్ధీకరించవలసిన శ్రేణిని సూచిస్తుంది.
- ' ప్రారంభించండి ” అనేది క్రమబద్ధీకరణను ప్రారంభించే ప్రారంభ సూచిక.
- ' ముగింపు ”సార్టింగ్ ముగించాల్సిన ఇండెక్స్‌కు అనుగుణంగా ఉంటుంది.
ఉదాహరణ 1: జావాలో అర్రేని క్రమబద్ధీకరించడానికి “Arrays.sort()” పద్ధతిని ఉపయోగించడం
ది ' కోసం మూలకాలతో పాటు పునరావృతం చేయడానికి లూప్ వర్తించబడుతుంది. ఈ విధానంతో కలిపి వర్తించవచ్చు ' Arrays.sort() ” అందించిన శ్రేణిలోని అన్ని మూలకాలను క్రమబద్ధీకరించే పద్ధతి:
int [ ] givenArray = కొత్త int [ ] { 2 , 3 , 1 , 9 , 13 , 7 } ;System.out.println ( 'అసలు శ్రేణి మూలకాలు:' ) ;
కోసం ( int మూలకం: ఇచ్చిన అర్రే ) {
System.out.println ( +మూలకం ) ;
}
శ్రేణులు.sort ( ఇచ్చిన శ్రేణి ) ;
System.out.println ( ' \n క్రమబద్ధీకరించబడిన శ్రేణి మూలకాలు: ' ) ;
కోసం ( int i = 0 ;i < ఇచ్చినArray.length;i++ ) {
System.out.println ( ఇచ్చిన శ్రేణి [ i ] ) ;
}
పై కోడ్ లైన్లలో:
- ముందుగా, '' అనే పూర్ణాంక శ్రేణిని ప్రకటించండి ఇచ్చిన శ్రేణి ”.
- ఇప్పుడు, వర్తించు ' కోసం మూలకాల శ్రేణి ద్వారా పునరావృతం చేయడానికి మరియు వాటిని (మూలకాలు) ప్రదర్శించడానికి లూప్.
- ఆ తరువాత, వర్తించు ' క్రమబద్ధీకరించు() శ్రేణిని క్రమబద్ధీకరించడానికి పేర్కొన్న శ్రేణిని దాని(పద్ధతి) పరామితిగా ఉంచడం ద్వారా పద్ధతి.
- అలాగే, మిళిత “ని ఉపయోగించండి కోసం 'లూప్ మరియు' పొడవు క్రమబద్ధీకరించబడిన శ్రేణి మూలకాల ద్వారా పునరావృతం చేయడానికి మరియు వాటిని ఒక్కొక్కటిగా ప్రదర్శించడానికి ఆస్తి.
అవుట్‌పుట్
ఈ అవుట్‌పుట్‌లో, శ్రేణి మూలకాలు తదనుగుణంగా క్రమబద్ధీకరించబడినట్లు గమనించవచ్చు.
ఉదాహరణ 2: జావాలో పేర్కొన్న సూచికల వద్ద అర్రేని క్రమబద్ధీకరించడానికి “Arrays.sort()” పద్ధతిని ఉపయోగించడం
ఈ ప్రత్యేక ఉదాహరణలో, నిర్దిష్ట సూచికలలో శ్రేణి మూలకాలను క్రమబద్ధీకరించడానికి చర్చించబడిన పద్ధతిని ఉపయోగించవచ్చు:
int [ ] ఇచ్చినఅరే = { 2 , 3 , 1 , 9 , 13 , 7 } ;System.out.println ( 'అసలు శ్రేణి మూలకాలు:' ) ;
కోసం ( int మూలకం: ఇచ్చిన అర్రే ) {
System.out.print ( మూలకం + '' ) ;
}
శ్రేణులు.sort ( ఇచ్చిన శ్రేణి, 1 , 3 ) ;
System.out.println ( ' \n సూచిక 1 నుండి 3 వరకు క్రమబద్ధీకరించబడిన శ్రేణి మూలకాలు: ' ) ;
కోసం ( int మూలకం: ఇచ్చిన అర్రే ) {
System.out.print ( మూలకం + '' ) ;
}
పై కోడ్ స్నిప్పెట్‌లో:
- శ్రేణిని ప్రకటించడం, కలిగి ఉన్న మూలకాల ద్వారా పునరావృతం చేయడం మరియు వాటిని ప్రదర్శించడం కోసం చర్చించిన విధానాలను గుర్తుకు తెచ్చుకోండి.
- ఆ తర్వాత, అదేవిధంగా, వర్తించు ' క్రమబద్ధీకరించు() ” పద్ధతి. అందించిన శ్రేణిలోని మూలకాలు రెండవ సూచిక నుండి క్రమబద్ధీకరించబడతాయని పద్ధతి పారామితులు సూచిస్తాయి, అనగా, ' 1 'నాల్గవ సూచికకు, అంటే,' 3 ”, నుండి ఇండెక్స్ ప్రారంభమవుతుంది కాబట్టి 0 ”.
- చివరగా, నవీకరించబడిన శ్రేణి మూలకాలను క్రమబద్ధీకరించి మరియు ప్రదర్శించిన తర్వాత మళ్లీ శ్రేణి మూలకాల ద్వారా మళ్ళించండి.
అవుట్‌పుట్
ఈ అవుట్‌పుట్‌లో, శ్రేణి మూలకాలు పేర్కొన్న సూచికలకు అనుగుణంగా క్రమబద్ధీకరించబడతాయని విశ్లేషించవచ్చు.
ఉదాహరణ 3: జావాను ఉపయోగించి అవరోహణ క్రమంలో స్ట్రింగ్స్ అర్రేని క్రమబద్ధీకరించడానికి “Arrays.sort()” పద్ధతిని ఉపయోగించడం
ది ' రివర్స్ ఆర్డర్() 'పద్ధతి' సేకరణలు వస్తువుల సేకరణపై సహజ క్రమం యొక్క రివర్స్‌ను నిర్దేశించే కంపారిటర్‌ను పొందేందుకు 'తరగతి ఉపయోగించబడుతుంది. ఈ పద్ధతిని కలిపి అమలు చేయవచ్చు ' Arrays.sort() తీగలను అవరోహణ క్రమంలో క్రమబద్ధీకరించే పద్ధతి:
పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {స్ట్రింగ్ [ ] ఇచ్చినఅరే = { 'యాపిల్' , 'ఒకటి' , 'పిల్లి' } ;
System.out.println ( 'అసలు శ్రేణి మూలకాలు:' ) ;
కోసం ( స్ట్రింగ్ ఎలిమెంట్: ఇచ్చిన అర్రే ) {
System.out.print ( మూలకం + '' ) ;
}
శ్రేణులు.sort ( ఇచ్చిన అర్రే, కలెక్షన్స్.రివర్స్ ఆర్డర్ ( ) ) ;
System.out.println ( ' \n అవరోహణ క్రమంలో క్రమబద్ధీకరించబడిన శ్రేణి మూలకాలు: ' ) ;
కోసం ( స్ట్రింగ్ ఎలిమెంట్: ఇచ్చిన అర్రే ) {
System.out.print ( మూలకం + '' ) ;
}
ఈ కోడ్ బ్లాక్‌లో, ఈ క్రింది దశలను వర్తించండి:
- అన్నింటిలో మొదటిది, '' ప్రకటించండి స్ట్రింగ్ ” పేర్కొన్న స్ట్రింగ్ విలువలతో కూడిన శ్రేణి.
- ఆ తర్వాత, '' ద్వారా కలిగి ఉన్న విలువల ద్వారా మళ్ళించండి కోసం ” లూప్ చేసి వాటిని ప్రదర్శించండి.
- ఇప్పుడు, వర్తించు ' క్రమబద్ధీకరించు() ” అందించిన శ్రేణిని క్రమబద్ధీకరించే పద్ధతి.
- పద్ధతి పరామితిలో, మునుపటి పరామితి అందించిన స్ట్రింగ్స్ శ్రేణిని సూచిస్తుంది. తరువాతి పరామితిలో, 'ని అనుబంధించండి రివర్స్ ఆర్డర్() 'తో పద్ధతి' సేకరణలు ”శ్రేణి మూలకాలను అవరోహణ క్రమంలో ప్రదర్శించడానికి తరగతి.
- చివరగా, రివర్స్డ్ అర్రే ద్వారా మళ్ళించండి మరియు తదనుగుణంగా సేకరించబడిన స్ట్రింగ్‌లను ప్రదర్శించండి.
అవుట్‌పుట్
ఈ ఫలితంలో, స్ట్రింగ్ విలువలు తగిన విధంగా అవరోహణ క్రమంలో క్రమబద్ధీకరించబడినట్లు స్పష్టంగా తెలుస్తుంది.
ముగింపు
ది ' Arrays.sort() ”జావాలోని పద్ధతి ప్రారంభ మరియు ముగింపు సూచికలను పేర్కొనడం ద్వారా శ్రేణిని పూర్తిగా లేదా దానిలో కొంత భాగాన్ని క్రమబద్ధీకరించడానికి ఉపయోగించబడుతుంది. అన్ని శ్రేణి మూలకాలు మరియు పేర్కొన్న మూలకాలను క్రమబద్ధీకరించడానికి లేదా అవరోహణ పద్ధతిలో క్రమబద్ధీకరించడానికి ఈ పద్ధతిని అమలు చేయవచ్చు. ఈ బ్లాగ్ 'ని ఉపయోగించడం గురించి చర్చించింది Arrays.sort() ” జావాలో పద్ధతి.