జావాలో, కొన్నిసార్లు, మీరు వస్తువులు, మూలకాలు మరియు అక్షరాల స్థానాలను మార్పిడి చేయాలి. ఈ ప్రయోజనం కోసం, మీరు స్వాప్ () పద్ధతిని ఉపయోగించవచ్చు. స్వాప్ అంటే మార్పిడి. స్ట్రింగ్ లేదా జాబితాలలోని అక్షరాలు లేదా మూలకాల స్థానాలను మార్పిడి చేయడానికి ఈ పద్ధతి ఉపయోగించబడుతుంది. జావా 'ని అందించడం ద్వారా స్వాప్ కార్యాచరణకు మద్దతు ఇస్తుంది Collections.swap() ” స్టాటిక్ పద్ధతి.
ఈ ట్యుటోరియల్ జావాలో స్వాప్() పద్ధతిని ఉపయోగించడాన్ని ప్రదర్శిస్తుంది.
జావాలో స్వాప్ () పద్ధతిని ఎలా ఉపయోగించాలి?
ది ' మార్పిడి() స్ట్రింగ్‌లోని అక్షరాలను మరియు జాబితాలోని మూలకాలను మార్చుకోవడానికి ” పద్ధతి ఉపయోగించబడుతుంది. మీరు కలెక్షన్స్ క్లాస్ యొక్క ముందే నిర్వచించిన స్వాప్() పద్ధతిని ఉపయోగించవచ్చు లేదా వినియోగదారు నిర్వచించిన పద్ధతిని సృష్టించవచ్చు.
జావాలో ముందే నిర్వచించబడిన మరియు వినియోగదారు నిర్వచించిన స్వాప్() పద్ధతులకు సంబంధించిన కొన్ని ఉదాహరణలను చూద్దాం.
వాక్యనిర్మాణం
ఎలిమెంట్‌లను స్వాప్ చేయడానికి స్వాప్() పద్ధతికి సంబంధించిన సింటాక్స్ క్రింద ఇవ్వబడింది:
మార్పిడి ( a,i,j )
పద్ధతి మూడు పారామితులను తీసుకుంటుంది, ఇక్కడ ' a 'మార్పిడి చేసే స్ట్రింగ్ లేదా జాబితాను సూచిస్తుంది మరియు ' i 'మరియు' జె ” అనేవి మార్చుకోవలసిన మూలకాల సూచికలు.
ముందుగా, వినియోగదారు నిర్వచించిన స్వాప్() పద్ధతిని సృష్టించడం ద్వారా స్వాపింగ్ యొక్క కార్యాచరణను మేము అర్థం చేసుకుంటాము.
ఉదాహరణ 1: అక్షరాలను మార్చుకోవడానికి వినియోగదారు నిర్వచించిన స్వాప్() పద్ధతిని ఉపయోగించండి
ఈ ఉదాహరణలో, మేము వినియోగదారు నిర్వచించిన స్వాప్() పద్ధతిని ఉపయోగించి స్ట్రింగ్ యొక్క అక్షరాలను మార్చుకుంటాము. మొదట, మేము '' అనే పద్ధతిని సృష్టిస్తాము. మార్పిడి() మరియు మూడు ఆర్గ్యుమెంట్‌లను పాస్ చేయండి, స్ట్రింగ్' str ” దీని అక్షరాలు మార్చుకోబడతాయి మరియు మిగిలిన రెండు వేరియబుల్స్ యొక్క సూచికలను సూచించే పూర్ణాంక రకం వేరియబుల్స్.
ఈ పద్ధతి మొదట చార్ రకం శ్రేణిని సృష్టిస్తుంది, అది పాస్ చేసిన స్ట్రింగ్‌ను శ్రేణిగా నిల్వ చేస్తుంది “ toCharArray() ” పద్ధతి. ఆపై, సూచిక నుండి అక్షరాన్ని నిల్వ చేయండి ' a 'చార్ టైప్ వేరియబుల్‌కి' ఉష్ణోగ్రత 'మరియు పాత్రను ' వద్ద ఉంచండి బి 'ఇండెక్స్' వద్ద a ”సూచిక. తరువాత, ' విలువను ఉంచండి ఉష్ణోగ్రత 'ఇండెక్స్ వద్ద' బి ” మరియు చివరకు దానిని పద్ధతికి తిరిగి ఇవ్వండి:
స్టాటిక్ చార్ [ ] మార్పిడి ( స్ట్రింగ్ str, int a, Int b ){
చార్ ch [ ] = str.toCharArray ( ) ;
చార్ టెంప్ = చ [ a ] ;
చ [ a ] = చ [ బి ] ;
చ [ బి ] = ఉష్ణోగ్రత;
తిరిగి చ;
}
ప్రధాన() పద్ధతిలో, మనకు స్ట్రింగ్ ఉంది “ లు ”. తరువాత, అసలు స్ట్రింగ్‌ను ప్రింట్ చేయండి మరియు సృష్టించిన స్ట్రింగ్ మరియు అక్షరాల సూచికలను ఆర్గ్యుమెంట్‌లుగా పాస్ చేయడం ద్వారా స్వాప్() పద్ధతిని కాల్ చేయండి. ఉదాహరణకు, మేము ఆరవ సూచిక అక్షరాన్ని మార్చుకోవాలనుకుంటున్నాము ' n 'తో' i 'అది రెండవ సూచికలో ఉంది:
స్ట్రింగ్ s = 'LiiuxHnnt' ;System.out.println ( 'ది స్ట్రింగ్:' + సె ) ;
System.out.print ( 'మార్పిడి తర్వాత:' ) ;
System.out.println ( మార్పిడి ( లు, 6 , రెండు ) ) ;
ఇచ్చిన అవుట్‌పుట్ మేము పేర్కొన్న అక్షరాల అక్షరాలను విజయవంతంగా మార్చుకున్నామని సూచిస్తుంది:
మీరు జాబితాలోని ఎలిమెంట్‌లను మార్చుకోవాలా? ఒక వేళ సరే అనుకుంటే! ఆపై ఇచ్చిన విభాగాన్ని అనుసరించండి.
ఉదాహరణ 2: అర్రేలిస్ట్ ఎలిమెంట్‌లను స్వాప్ చేయడానికి ముందే నిర్వచించిన స్వాప్() పద్ధతిని ఉపయోగించడం
అర్రేలిస్ట్ ఎలిమెంట్‌లను మార్చుకోవడానికి, ముందే నిర్వచించిన “ని ఉపయోగించండి మార్పిడి() ” సేకరణల తరగతి పద్ధతి. అలా చేయడానికి, ముందుగా, మేము '' యొక్క శ్రేణి జాబితాను సృష్టిస్తాము. పండ్లు ”:
అర్రేలిస్ట్ < స్ట్రింగ్ > fruits = కొత్త అర్రేలిస్ట్ < స్ట్రింగ్ > ( ) ;
ఆపై, 'ని ఉపయోగించి సృష్టించిన అర్రేలిస్ట్‌లోని మూలకాలను జోడించండి జోడించు() 'పద్ధతి:
పండ్లు.జోడించు ( 'యాపిల్' ) ;పండ్లు.జోడించు ( 'అరటి' ) ;
పండ్లు.జోడించు ( 'నేరేడు పండు' ) ;
పండ్లు.జోడించు ( 'పీచు' ) ;
'ని ఉపయోగించి మూలకాల యొక్క అసలు క్రమాన్ని ముద్రించండి System.out.println() 'పద్ధతి:
System.out.println ( 'పండ్ల జాబితా:' + పండు ) ;
అప్పుడు, కాల్ చేయండి ' Collections.swap() 'విధానం' జాబితాను పాస్ చేయడం ద్వారా పండ్లు ” మరియు మార్పిడి చేయవలసిన మూలకాల సూచికలు. ఇక్కడ, మేము అర్రేలిస్ట్‌లోని మొదటి మరియు చివరి ఎలిమెంట్‌లను మార్చుకుంటాము:
సేకరణలు.స్వాప్ ( పండ్లు, 0 , 3 ) ;
చివరగా, మేము కన్సోల్‌లో మార్పిడి చేసిన తర్వాత అన్ని మూలకాలను ప్రింట్ చేస్తాము:
System.out.println ( 'జాబితాలో మారిన పండ్లు:' + పండు ) ;
మీరు చూడగలిగినట్లుగా, అర్రేలిస్ట్ యొక్క మూలకాలు విజయవంతంగా మార్పిడి చేయబడ్డాయి:
ఇప్పుడు, శ్రేణిలో లేని సూచికను మనం పాస్ చేస్తే ఏమి జరుగుతుందో చూద్దాం.
ఉదాహరణ 3: ఉనికిలో లేని మూలకాన్ని మార్చుకోవడం
ఇక్కడ, మేము '' యొక్క సూచిక వద్ద మూలకాన్ని మార్చుకుంటాము. 1 'ఇండెక్స్ వద్ద ఉన్న మూలకంతో' 4 ”. మునుపు సృష్టించిన అర్రేలిస్ట్ పరిమాణం మూడు కాబట్టి, పేర్కొన్న ఆపరేషన్ లోపాన్ని విసురుతుంది:
సేకరణలు.స్వాప్ ( పండ్లు, 1 , 4 ) ;
నాల్గవ సూచిక మా అర్రేలిస్ట్‌లో లేనందున అవుట్‌పుట్ పరిమితికి మించిన సూచికను చూపుతుంది:
మేము జావాలో swap() పద్ధతి యొక్క ఉపయోగానికి సంబంధించిన అన్ని ముఖ్యమైన సమాచారాన్ని అందించాము.
ముగింపు
swap() పద్ధతి స్ట్రింగ్ మరియు జాబితా యొక్క అక్షరాలు లేదా మూలకాలను మార్చుకోవడానికి ఉపయోగించబడుతుంది. ఇది స్ట్రింగ్ లేదా లిస్ట్ మరియు మార్చుకోవాల్సిన మూలకాల సూచికలను తీసుకుంటుంది. జావాలో, జాబితాలు, అర్రేలిస్ట్ మొదలైన వాటి మూలకాలను స్వాప్ చేయడానికి ముందే నిర్వచించిన స్వాప్() పద్ధతి ఉపయోగించబడుతుంది. ఇది కలెక్షన్స్ తరగతికి చెందినది. మీరు అదే ఫంక్షనాలిటీని జోడించడం ద్వారా ముందే నిర్వచించిన స్వాప్() పద్ధతిని కూడా ఉపయోగించుకోవచ్చు. ఈ ట్యుటోరియల్ వివరణాత్మక ఉదాహరణలతో జావాలో స్వాప్() పద్ధతిని ఉపయోగించడాన్ని ప్రదర్శించింది.