క్రమబద్ధీకరించడం ఏదైనా ప్రోగ్రామింగ్ భాషలో ముఖ్యమైన భాగం. జావా, ఎటువంటి సందేహం లేదు ఉత్తమ ప్రోగ్రామింగ్ భాషలలో. ఇది సులభతరం చేసే వివిధ లక్షణాలను కలిగి ఉంది! క్రమబద్ధీకరించడం గురించి ప్రతిదీ విప్పుటకు ఈ వ్యాసం మీకు సహాయం చేస్తుంది ముఖ్యంగా, శ్రేణి, శ్రేణి జాబితా, స్ట్రింగ్, జాబితా, మ్యాప్ మరియు జావాలో సెట్ చేయండి.
ఈ సార్టింగ్ వ్యాసంలో క్రింద విషయాలు ఉన్నాయి:
- జావాలో శ్రేణిని క్రమబద్ధీకరించండి
- అర్రే vs అర్రేలిస్ట్
- శ్రేణి శ్రేణిని క్రమబద్ధీకరించండి
- క్రమబద్ధీకరించు స్ట్రింగ్
- జాబితాను క్రమబద్ధీకరించండి
- మ్యాప్‌ను క్రమబద్ధీకరించండి
- జావాలో ఒక సెట్‌ను క్రమబద్ధీకరించండి
ప్రారంభిద్దాం. :-)
జావాలో శ్రేణిని క్రమబద్ధీకరించండి
జావాలో శ్రేణులు నిర్దిష్ట డేటా రకం యొక్క ఒకటి లేదా అంతకంటే ఎక్కువ విలువలను నిల్వ చేయండి మరియు ఒకే వేరియబుల్‌లో నిల్వ చేయడానికి సూచిక ప్రాప్యతను అందిస్తుంది. ఆరోహణ క్రమంలో జావాలో శ్రేణిని క్రమబద్ధీకరించడానికి క్రింది ప్రోగ్రామ్‌ను చూద్దాం. అయితే, మీరు కలిగి ఉన్నారని నిర్ధారించుకోండి జావా ఇన్‌స్టాల్ చేయబడింది .
జావాలో శ్రేణిని క్రమబద్ధీకరించండి - ఆరోహణ క్రమం
ప్యాకేజీ ఎడురేకా దిగుమతి java.util.Arrays పబ్లిక్ క్లాస్ SortArray {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {int [] arr = {52,12,2,72,4} // 5 మూలకాల శ్రేణి Arrays.sort (arr ) System.out.printf ('క్రమబద్ధీకరించిన arr [] =% s', శ్రేణులు.టో స్ట్రింగ్ (arr))}}అవుట్పుట్ - క్రమబద్ధీకరించిన అర్ [] = [2, 4, 12, 52, 72]
జావాలో శ్రేణిని క్రమబద్ధీకరించండి - అవరోహణ క్రమం
ప్యాకేజీ ఎడురేకా దిగుమతి java.util.Arrays దిగుమతి java.util.Collections public class SortArray {public static void main (string [] args) {Integer [] arr = {52,12,2,72,4} // ఉపయోగించిన పూర్ణాంకం [ ] పూర్ణాంకాలకు బదులుగా Arrays.sort (arr, Collections.reverseOrder ()) // అవరోహణ ఆర్డర్ కోసం System.out.printf ('Sorted arr [] =% s', Arrays.toString (arr))} }అవుట్పుట్: క్రమబద్ధీకరించిన arr [] = [72, 52, 12, 4, 2]
గమనిక: పై కోడ్‌లో, నేను పూర్ణాంకానికి బదులుగా పూర్ణాంక [] శ్రేణిని ఉపయోగించాను . దీనికి కారణం రివర్స్ఆర్డర్ () ఆదిమ రకాలను సమర్థించదు.
జావాలో శ్రేణులు మరియు శ్రేణి జాబితా అనే భావనతో చాలా మంది గందరగోళం చెందుతారు. పట్టిక క్రింద మీ సందేహాలన్నీ తొలగిపోవచ్చు.
| అమరిక | శ్రేణి జాబితా |
ఇది స్థిర పొడవు | ఇది వేరియబుల్-పొడవు (పరిమాణంలో డైనమిక్) |
ఆదిమ డేటా-రకాన్ని మాత్రమే మద్దతిస్తుంది | జాబితాలో విభిన్న వస్తువు మరియు డేటాను జోడించవచ్చు చురుకైన మరియు డెవోప్‌ల మధ్య వ్యత్యాసం |
నకిలీ చేరికకు మద్దతు ఇవ్వదు | నకిలీ మూలకాల చేరికను అనుమతిస్తుంది |
ముందుకు వెళ్ళే దిశలో మాత్రమే ప్రయాణించవచ్చు | ముందుకు మరియు వెనుకబడిన దిశలో ప్రయాణించవచ్చు |
పరిమాణాన్ని డైనమిక్‌గా సవరించడం సాధ్యం కాదు | పరిమాణాన్ని డైనమిక్‌గా సవరించవచ్చు ప్రారంభకులకు ఇన్ఫర్మేటికా ట్యుటోరియల్ పిడిఎఫ్ ఉచిత డౌన్లోడ్ |
మీరు వ్యత్యాసంతో క్లియర్ అయ్యారని నేను ఆశిస్తున్నాను, ముందుకు సాగండి మరియు ఎలా క్రమబద్ధీకరించాలో చూద్దాం .
జావా (స్ట్రింగ్) లో శ్రేణి జాబితాను క్రమబద్ధీకరించండి
జావాలో అర్రేలిస్ట్‌ను క్రమబద్ధీకరించడం సరళమైనదాన్ని ఉపయోగించడం ద్వారా సులభంగా చేయవచ్చు క్రమబద్ధీకరించు () పద్ధతి . జావాలో అర్రేలిస్ట్‌ను క్రమబద్ధీకరించడానికి క్రింది కోడ్‌ను చూడండి.
ప్యాకేజీ ఎడురేకా దిగుమతి java.util.Arrays దిగుమతి java.util.Collections దిగుమతి java.util. * పబ్లిక్ క్లాస్ సార్టింగ్అరేలిస్ట్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {అర్రేలిస్ట్ జాబితా = కొత్త అర్రేలిస్ట్ () // శ్రేణి జాబితా జాబితా. ('సార్టింగ్') list.add ('జావా') list.add ('శ్రేణి జాబితా') list.add ('in') System.out.println ('క్రమబద్ధీకరించని శ్రేణి జాబితా:' + జాబితా) // ముద్రించిన క్రమబద్ధీకరించని శ్రేణి జాబితా సేకరణలు. క్రమబద్ధీకరించు (జాబితా) // ఆరోహణ క్రమం కోసం క్రమబద్ధీకరించే పద్ధతి System.out.println (ఆరోహణ క్రమంలో 'క్రమబద్ధీకరించిన శ్రేణి జాబితా' + ':' + జాబితా) // ప్రింట్ క్రమబద్ధీకరించిన శ్రేణి జాబితా}}అవుట్పుట్ -
క్రమబద్ధీకరించని శ్రేణి జాబితా: [సార్టింగ్, జావా, శ్రేణి జాబితా, లో]
ఆరోహణ క్రమంలో క్రమబద్ధీకరించిన శ్రేణి జాబితా: [శ్రేణి జాబితా, లో, జావా, సార్టింగ్]
జావా వ్యాసంలో సార్టింగ్‌తో ముందుకు సాగడం, మీరు పూర్ణాంకాలను ఎలా క్రమబద్ధీకరించవచ్చో చూద్దాం. వేరే పద్ధతిని ఉపయోగించి సార్టింగ్‌ను అమలు చేయడానికి ప్రయత్నిద్దాం, అంటే కలెక్షన్స్.సోర్ట్ () పద్ధతిని ఉపయోగించడం.
సేకరణలు (పూర్ణాంకాలు) ఉపయోగించి జావాలో శ్రేణి జాబితాను క్రమబద్ధీకరించండి
Collections.sort () పద్ధతిని ఉపయోగించి మీరు పూర్ణాంక శ్రేణి జాబితాను క్రమబద్ధీకరించవచ్చు.
ప్యాకేజీ ఎడురేకా దిగుమతి java.util.Arrays దిగుమతి java.util. సేకరణలు దిగుమతి java.util. (2) arraylist.add (19) arraylist.add (22) System.out.println ('క్రమబద్ధీకరించడానికి ముందు:') // (int counter: arraylist) for System.out.println (counter) for సేకరణల కోసం క్రమబద్ధీకరించడానికి ముందు. .సోర్ట్ (అర్రేలిస్ట్) // ఆరోహణ క్రమంలో క్రమబద్ధీకరించడానికి ఫంక్షన్ System.out.println ('క్రమబద్ధీకరించిన తరువాత:') // (int కౌంటర్: శ్రేణి జాబితా) for System.out.println (కౌంటర్) for} for అవుట్పుట్ -
క్రమబద్ధీకరించడానికి ముందు:
48
2
19
22
క్రమబద్ధీకరించిన తరువాత:
2
19
22
48
జావాలో స్ట్రింగ్‌ను క్రమబద్ధీకరించండి
జావాలో స్ట్రింగ్ మార్పులేనిది. క్రమబద్ధీకరించడానికి ప్రత్యక్ష పద్ధతి లేదు . చార్ అర్రే () అనే పద్దతిని కలిగి ఉన్న అర్రేలను మీరు ఉపయోగించవచ్చు, అది చార్ ఇన్పుట్ స్ట్రింగ్‌ను సృష్టిస్తుంది మరియు మరొక పద్ధతిని (అర్రేస్.సోర్ట్ (చార్ సి []) ఉపయోగించి, మేము సులభంగా క్రమబద్ధీకరించవచ్చు.
ప్యాకేజీ ఎడురేకా దిగుమతి java.util.Arrays దిగుమతి java.util.Collections దిగుమతి java.util. * పబ్లిక్ క్లాస్ సార్టింగ్ స్ట్రింగ్ {పబ్లిక్ స్టాటిక్ స్ట్రింగ్ సార్ట్‌స్ట్రింగ్ (స్ట్రింగ్ ఇన్పుట్ స్ట్రింగ్) {చార్ అర్రే 1 [] = ఇన్పుట్ స్ట్రింగ్ శ్రేణి అర్రేస్.సోర్ట్ (అర్రే 1) కొత్త స్ట్రింగ్ (అర్రే 1) // రిటర్న్ సార్టెడ్ స్ట్రింగ్} పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {స్ట్రింగ్ ఇన్పుట్ స్ట్రింగ్ = 'ఎడురేకా' స్ట్రింగ్ అవుట్పుట్ స్ట్రింగ్ = సార్ట్ స్ట్రింగ్ (ఇన్పుట్ స్ట్రింగ్) ఇన్పుట్ స్ట్రింగ్: '+ ఇన్పుట్ స్ట్రింగ్) System.out.println (' అవుట్పుట్ స్ట్రింగ్: '+ అవుట్పుట్ స్ట్రింగ్)}} అవుట్పుట్ -
ఇన్పుట్ స్ట్రింగ్: ఎడురేకా
అవుట్పుట్ స్ట్రింగ్: ఈడెక్రు
జావాలో జాబితాను క్రమబద్ధీకరించండి
లో జాబితాను క్రమబద్ధీకరించడానికి , మీరు Collections.sort () పద్ధతిని ఉపయోగించవచ్చు. మరింత అవగాహన కోసం క్రింది కోడ్‌ను చూడండి:
ప్యాకేజీ ఎడురేకా దిగుమతి java.util.Arrays దిగుమతి java.util. సేకరణలు దిగుమతి java.util. , 27,22,4,88,65,36} జాబితా అంకెలు జాబితా = శ్రేణులు. జాబితా (అంకెలు) కలెక్షన్స్.సార్ట్ (అంకెలు జాబితా) // క్రమబద్ధీకరించిన జాబితా System.out.println ('క్రమబద్ధీకరించిన స్ట్రింగ్:' + అంకెల జాబితా)}}def __init__ పైథాన్
అవుట్పుట్ : క్రమబద్ధీకరించిన స్ట్రింగ్: [4, 12, 22, 27, 36, 56, 65, 88, 89]
జావాలో మ్యాప్‌ను క్రమబద్ధీకరించండి
జావాలోని మ్యాప్ చెందినది ఇది కీ-విలువ జతని కలిగి ఉంటుంది. అందువల్ల, మ్యాప్‌ను రెండు రకాలుగా క్రమబద్ధీకరించవచ్చు:
- కీ ద్వారా క్రమబద్ధీకరించు
- విలువ ప్రకారం క్రమబద్ధీకరించండి
కీ ద్వారా క్రమబద్ధీకరించు:
ప్యాకేజీ ఎడురేకా దిగుమతి java.util.Arrays దిగుమతి java.util. సేకరణలు దిగుమతి java.util. * పబ్లిక్ క్లాస్ సార్టింగ్ మ్యాప్ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {హాష్ మ్యాప్ మ్యాప్ = కొత్త హాష్ మ్యాప్ () మ్యాప్.పుట్ (14, 'ఆయుషి ') map.put (2,' Rachit ') map.put (30,' Amit ') map.put (5,' Anamika ') TreeMap treeMap = new TreeMap (map) System.out.println (treeMap)}}అవుట్పుట్: {2 = రచిత్, 5 = అనామిక, 14 = ఆయుషి, 30 = అమిత్}
విలువ ప్రకారం క్రమబద్ధీకరించండి:
ప్యాకేజీ ఎడురేకా దిగుమతి java.util.Arrays దిగుమతి java.util. సేకరణలు దిగుమతి java.util. * పబ్లిక్ క్లాస్ సార్టింగ్ మ్యాప్ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {హాష్ మ్యాప్ అన్సోర్టెడ్ మ్యాప్ = కొత్త హాష్ మ్యాప్ () అన్సోర్టెడ్ మ్యాప్.పుట్ (14, 'ఆయుషి ') unSortedMap.put (20,' Rachit ') unSortedMap.put (60,' Amit ') unSortedMap.put (70,' Anamika ') LinkedHashMap sortedMap = new LinkedHashMap () unSortedMap.entrySet () .stream () .సోర్టెడ్. (Map.Entry.comparingByValue ()) .forEachOrded (x -> sortedMap.put (x.getKey (), x.getValue ())) System.out.println (sortedMap)}}అవుట్పుట్: {14 = ఆయుషి, 60 = అమిత్, 70 = అనామిక, 20 = రచిత్}
జావాలో సార్టింగ్‌తో ముందుకు సాగడం, చివరి అంశాన్ని ఎంచుకుందాం, అంటే సెట్ ఇన్ సార్ట్ చేయండి .
జావాలో క్రమబద్ధీకరించు సెట్
జావాలో సెట్ అనేది సేకరణలను విస్తరించే ఇంటర్ఫేస్. ఇది క్రమం లేని వస్తువుల సేకరణ, ఇది నకిలీ విలువలను నిల్వ చేయదు. జావాలో సెట్‌ను క్రమబద్ధీకరించడానికి ఇప్పుడు ప్రత్యక్ష పద్ధతి లేదు. ఇప్పుడు సమితిని క్రమబద్ధీకరించడానికి, మీరు సమితిని జాబితాకు మార్చాలి, ఆపై collection.sort () API ని ఉపయోగించాలి మరియు జాబితాను తిరిగి సమితిగా మార్చాలి. మరింత అవగాహన కోసం క్రింది కోడ్‌ను చూడండి:
ప్యాకేజీ ఎడురేకా దిగుమతి java.util.Arrays దిగుమతి java.util. సేకరణలు దిగుమతి java.util. , 56,89,27,22,4,88,65,36)) జాబితా సంఖ్యల జాబితా = క్రొత్త శ్రేణి జాబితా (నంబర్‌సెట్) // జాబితాకు సెట్ చేయండి // జాబితాను క్రమబద్ధీకరించు కలెక్షన్స్.సార్ట్ (నంబర్‌లిస్ట్) నంబర్‌సెట్ = కొత్త లింక్డ్ హాష్‌సెట్ (నంబర్‌లిస్ట్) // జాబితాను సెట్‌గా మార్చండి // System.out.println (numbersSet) ను నిర్ధారించడానికి ప్రింట్ సెట్}}
అవుట్పుట్ : [4, 12, 22, 27, 36, 56, 65, 88, 89]
జావాలో క్రమబద్ధీకరించడంపై ఇది మా బ్లాగ్ చివరికి తీసుకువస్తుంది, ఇక్కడ మీరు జావాలో అర్రే, అర్రేలిస్ట్, స్ట్రింగ్, మ్యాప్ మరియు సెట్ ఎలా క్రమబద్ధీకరించాలో నేర్చుకున్నారు. మీరు ఈ బ్లాగును సమాచారపూర్వకంగా మరియు మీ జ్ఞానానికి అదనపు విలువను కనుగొన్నారని నేను ఆశిస్తున్నాను.
మీరు వీలైనంత వరకు ప్రాక్టీస్ చేశారని నిర్ధారించుకోండి మరియు మీ అనుభవాన్ని తిరిగి పొందండి.
చూడండి ప్రపంచవ్యాప్తంగా 250,000 కంటే ఎక్కువ సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించబడింది. ఈ కోర్సు మీకు జావా ప్రోగ్రామింగ్‌లోకి రావడానికి మరియు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌లతో పాటు కోర్ మరియు అడ్వాన్స్‌డ్ జావా కాన్సెప్ట్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.
మాకు ప్రశ్న ఉందా? దయచేసి ఈ ‘జావాలో సార్టింగ్: అర్రే, అర్రేలిస్ట్, స్ట్రింగ్, మ్యాప్ మరియు జావాలో సెట్’ యొక్క వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.