ఈ పోస్ట్ అర్రేలిస్ట్ నుండి స్ట్రింగ్‌కు జావా మార్పిడి విధానాన్ని నిర్వచిస్తుంది.
జావాలో అర్రేలిస్ట్‌ని స్ట్రింగ్‌గా మార్చడం ఎలా?
అర్రేలిస్ట్‌ను స్ట్రింగ్‌గా మార్చడానికి, మీరు వీటిని ఉపయోగించవచ్చు:
- + ఆపరేటర్
- append() పద్ధతి
- toString() పద్ధతి
- join() పద్ధతి
అర్రేలిస్ట్‌ను స్ట్రింగ్‌గా మార్చడానికి ఈ పద్ధతుల పనిని చూద్దాం.
విధానం 1: + ఆపరేటర్ ఉపయోగించి అర్రేలిస్ట్‌ను స్ట్రింగ్‌గా మార్చండి
'ని ఉపయోగించి శ్రేణి జాబితాను స్ట్రింగ్‌గా మార్చడం + ” ఆపరేటర్ అనేది సులభమైన మరియు సులభమైన పద్ధతి. మీరు ఈ అనుసంధాన ఆపరేషన్ సహాయంతో ArrayList యొక్క మూలకాలను స్ట్రింగ్‌గా సంగ్రహించవచ్చు.
వాక్యనిర్మాణం
అర్రేలిస్ట్‌ను స్ట్రింగ్‌గా మార్చడానికి, కింది వాక్యనిర్మాణాన్ని అనుసరించండి “ + 'ఆపరేటర్:
str += f + ',' ;
ఇక్కడ, ' str ” అనేది శ్రేణిలోని మూలకాలను స్ట్రింగ్‌గా నిల్వ చేయడానికి సృష్టించబడిన స్ట్రింగ్ టైప్ వేరియబుల్, “ += 'అరేలిస్ట్ యొక్క మూలకాలను స్ట్రింగ్‌గా కేటాయించడానికి మరియు కలపడానికి ఆపరేటర్ ఉపయోగించబడుతుంది,' f ” అనేది మూలకాలను యాక్సెస్ చేయడానికి ఫర్ లూప్‌లో ఉపయోగించే వేరియబుల్ మరియు “ , ” కామా వేరుతో స్ట్రింగ్ ఎలిమెంట్స్‌తో సంగ్రహించబడింది.
ఉదాహరణ
ఈ ఉదాహరణలో, ముందుగా, '' పేరుతో ఖాళీ స్ట్రింగ్ టైప్ అర్రేలిస్ట్‌ని సృష్టిస్తాము. పువ్వులు ”:
జాబితా < స్ట్రింగ్ > పువ్వులు = కొత్త అర్రేలిస్ట్ <> ( ) ;
ఆపై, “ని ఉపయోగించి జాబితాలోని మూలకాలను జోడించండి జోడించు() 'పద్ధతి:
పువ్వులు. జోడించు ( 'గులాబీ' ) ;పువ్వులు. జోడించు ( 'జాస్మిన్' ) ;
పువ్వులు. జోడించు ( 'లిల్లీ' ) ;
జాబితాను ప్రింట్ చేయండి ' పువ్వులు ”:
వ్యవస్థ. బయటకు . println ( 'పువ్వుల జాబితా:' + పువ్వులు ) ;'' సహాయంతో జాబితా మూలకాలను స్ట్రింగ్‌గా మార్చండి + 'లో ఆపరేటర్' కోసం ”లూప్:
స్ట్రింగ్ str = '' ;కోసం ( స్ట్రింగ్ f : పువ్వులు ) {
str += f + ',' ;
}
చివరగా, '' ముద్రించండి str ” అర్రేలిస్ట్ యొక్క మూలకాలను స్ట్రింగ్‌గా చూపించడానికి:
వ్యవస్థ. బయటకు . ముద్రణ ( 'స్ట్రింగ్‌కి శ్రేణి జాబితా:' + str ) ; 
అర్రేలిస్ట్ విజయవంతంగా కామాతో వేరు చేయబడిన స్ట్రింగ్‌గా మార్చబడిందని అవుట్‌పుట్ సూచిస్తుంది:
ArrayListని స్ట్రింగ్‌గా మార్చడానికి తదుపరి పద్ధతిని చూద్దాం.
విధానం 2: అనుబంధం() పద్ధతిని ఉపయోగించి అర్రేలిస్ట్‌ను స్ట్రింగ్‌గా మార్చండి
అర్రేలిస్ట్‌ను స్ట్రింగ్‌గా మార్చడానికి, మేము ఇప్పుడు “ని ఉపయోగిస్తాము అనుబంధం() ” స్ట్రింగ్‌బిల్డర్ తరగతికి చెందిన పద్ధతి. ఇది ' + ” ఆపరేటర్ ఇది స్ట్రింగ్స్‌తో మూలకాలను సంగ్రహిస్తుంది.
వాక్యనిర్మాణం
కొరకు ' అనుబంధం() ” పద్ధతి, మీరు క్రింద ఇచ్చిన వాక్యనిర్మాణాన్ని ఉపయోగించవచ్చు:
ఇక్కడ, ' str ” అనేది స్ట్రింగ్‌బిల్డర్ క్లాస్ యొక్క ఆబ్జెక్ట్ అని పిలుస్తుంది అనుబంధం() ” జాబితాను పాస్ చేయడం ద్వారా పద్ధతి, మరియు “f” ఫర్ లూప్ ఉపయోగించి యాక్సెస్ చేయబడిన అర్రేలిస్ట్ మూలకాలను సూచిస్తుంది.
ఉదాహరణ
ఈ ఉదాహరణలో, మేము append() పద్ధతిని ఉపయోగించి మునుపు సృష్టించిన ArrayListని స్ట్రింగ్‌గా మారుస్తాము. అలా చేయడానికి, ముందుగా మనం ఒక వస్తువును సృష్టిస్తాము ' str ” స్ట్రింగ్‌బిల్డర్ క్లాస్:
అప్పుడు, “లో append() పద్ధతి సహాయంతో ArrayListని స్ట్రింగ్స్‌గా మార్చండి కోసం ”లూప్:
కోసం ( స్ట్రింగ్ f : పువ్వులు ) {str. జోడించు ( f ) ;
str. జోడించు ( ',' ) ;
}
చివరగా, ప్రింట్ ' str ” ఇది అర్రేలిస్ట్ యొక్క మూలకాలను కామాతో వేరు చేయబడిన స్ట్రింగ్‌గా నిల్వ చేస్తుంది:
వ్యవస్థ. బయటకు . ముద్రణ ( 'స్ట్రింగ్‌కి శ్రేణి జాబితా:' + str ) ; 
అవుట్‌పుట్
ArrayListని స్ట్రింగ్‌గా మార్చడానికి మరొక పద్ధతికి వెళ్దాం.
విధానం 3: స్ట్రింగ్() పద్ధతిని ఉపయోగించి అర్రేలిస్ట్‌ను స్ట్రింగ్‌గా మార్చండి
ఈ విభాగంలో, మేము 'ని ఉపయోగిస్తాము toString() ”అరేలిస్ట్‌ని స్ట్రింగ్‌గా మార్చడానికి స్ట్రింగ్ క్లాస్ పద్ధతి. ఇది స్ట్రింగ్ ఫార్మాట్ విలువను అవుట్‌పుట్ చేసే జావాలో ముందే నిర్వచించబడిన పద్ధతి. నిర్దిష్ట అక్షరాలను భర్తీ చేయడానికి toString() పద్ధతితో భర్తీ() పద్ధతి ఉపయోగించబడుతుంది.
వాక్యనిర్మాణం
ToString() పద్ధతితో ArrayListని స్ట్రింగ్‌గా మార్చడానికి ఇచ్చిన వాక్యనిర్మాణాన్ని అనుసరించండి:
ది ' శ్రేణి జాబితా 'ని ఉపయోగించి స్ట్రింగ్‌గా మార్చబడుతుంది' toString( )” పద్ధతి.
ఉదాహరణ
మొదట, మేము స్ట్రింగ్ టైప్ వేరియబుల్‌ను సృష్టిస్తాము ' లు ” ఇది toString() పద్ధతితో మార్పిడిని చేసిన తర్వాత ArrayList మూలకాలను స్ట్రింగ్‌గా నిల్వ చేస్తుంది:
ఓపెనింగ్‌ను భర్తీ చేయడానికి రీప్లేస్() పద్ధతిని ఉపయోగించండి ' [ 'మరియు మూసివేయడం' ] కామాతో వేరు చేయబడిన స్ట్రింగ్ విలువలను పొందడానికి ఖాళీ స్ట్రింగ్‌లతో మూలకాల మధ్య బ్రాకెట్‌లు మరియు ఖాళీలు:
లు = లు. భర్తీ చేయండి ( '[' , '' ). భర్తీ చేయండి ( ']' , '' )
. భర్తీ చేయండి ( '' , '' ) ;
చివరగా, కన్సోల్ విండోలో ఫలిత స్ట్రింగ్‌ను ప్రింట్ చేయండి:
వ్యవస్థ. బయటకు . ముద్రణ ( 'స్ట్రింగ్‌కి శ్రేణి జాబితా:' + లు ) ; 
అవుట్‌పుట్
విధానం 4: జాయిన్() పద్ధతిని ఉపయోగించి అర్రేలిస్ట్‌ను స్ట్రింగ్‌గా మార్చండి
' చేరండి() ” అనేది స్ట్రింగ్ క్లాస్ యొక్క స్టాటిక్ మెథడ్, ఇది స్ట్రింగ్ టైప్ వేరియబుల్‌లో స్ట్రింగ్‌గా అర్రేలిస్ట్ మూలకాలను కలిపేస్తుంది.
వాక్యనిర్మాణం
కింది వాక్యనిర్మాణం join() పద్ధతి కోసం ఉపయోగించబడుతుంది:
ఇక్కడ, join() పద్ధతి రెండు ఆర్గ్యుమెంట్‌లను తీసుకుంటుంది, ఒకటి “ శ్రేణి జాబితా ' ఇంకా ' , ” కామాతో వేరు చేయబడిన విలువలతో స్ట్రింగ్స్‌లో చేరుతుంది.
ఉదాహరణ
ఈ ఉదాహరణలో, మేము స్ట్రింగ్ క్లాస్‌తో జాయిన్() పద్ధతిని పాస్ చేయడం ద్వారా కాల్ చేస్తాము పువ్వులు 'అరేలిస్ట్ మరియు కామా' , 'విలువలను వేరు చేయడానికి మరియు దానిని స్ట్రింగ్ టైప్ వేరియబుల్‌లో నిల్వ చేయడానికి' లు ”:
'ని ఉపయోగించడం ద్వారా కన్సోల్‌లో ఫలిత స్ట్రింగ్‌ను ప్రింట్ చేయండి System.out.println() 'పద్ధతి:
వ్యవస్థ. బయటకు . ముద్రణ ( 'స్ట్రింగ్‌కి శ్రేణి జాబితా:' + లు ) ; 
అవుట్‌పుట్
మేము జావాలో అర్రేలిస్ట్‌ను స్ట్రింగ్‌గా మార్చడానికి సులభమైన మార్గాలను సంకలనం చేసాము.
ముగింపు
అర్రేలిస్ట్‌ను స్ట్రింగ్‌గా మార్చడానికి, '' వంటి వివిధ పద్ధతులు ఉన్నాయి + ” ఆపరేటర్, append() method, toString() method, and join() method. ఈ పద్ధతులు అర్రేలిస్ట్ యొక్క మూలకాలను కామాతో వేరు చేసిన స్ట్రింగ్ విలువలకు మారుస్తాయి. అయితే, + ఆపరేటర్‌ని ఉపయోగించడం అనేది పేర్కొన్న మార్పిడిని నిర్వహించడానికి సులభమైన విధానం. ఈ బ్లాగ్‌లో, మేము వివరణాత్మక ఉదాహరణలతో జావాలోని శ్రేణి జాబితాను స్ట్రింగ్‌గా మార్చే మార్గాలను వివరించాము.