పరిచయం:
జావాలో ఇన్‌పుట్ స్ట్రీమ్‌లతో పనిచేయడం అనేది ఒక సాధారణ పని, ప్రత్యేకించి ఫైల్‌లు, నెట్‌వర్క్ కనెక్షన్‌లు లేదా ఇతర ఇన్‌పుట్ ఛానెల్‌ల వంటి బాహ్య మూలాల నుండి డేటాతో వ్యవహరించేటప్పుడు. సమాచారాన్ని లాగింగ్ చేయడానికి, ప్రాసెస్ చేయడానికి లేదా ప్రదర్శించడానికి ఈ డేటాను స్ట్రింగ్ ఆకృతికి మార్చడం చాలా అవసరం.
ఈ కథనంలో, ఇన్‌పుట్‌స్ట్రీమ్‌ను స్ట్రింగ్‌గా మార్చడానికి అత్యంత సరళమైన మరియు సమర్థవంతమైన మార్గాన్ని మేము విశ్లేషిస్తాము. ఈ దశలను అనుసరించడం ద్వారా, మీరు Javaలో మీ డేటా హ్యాండ్లింగ్ ప్రభావవంతంగా మరియు విశ్వసనీయంగా ఉండేలా చూసుకోవచ్చు.
| ఆదేశం | వివరణ |
|---|---|
| BufferedReader | ఇన్‌పుట్‌ను బఫర్ చేసే రీడర్, డేటా యొక్క పెద్ద స్ట్రీమ్‌లను చదివేటప్పుడు సామర్థ్యాన్ని మెరుగుపరుస్తుంది. |
| InputStreamReader | బైట్ స్ట్రీమ్ (ఇన్‌పుట్ స్ట్రీమ్)ని క్యారెక్టర్ స్ట్రీమ్ (రీడర్)గా మారుస్తుంది. |
| Collectors.joining | ఐచ్ఛిక డీలిమిటర్‌తో స్ట్రింగ్‌ల స్ట్రీమ్‌ను ఒకే స్ట్రింగ్‌లో కలుపుతుంది. |
| lines() | బఫర్డ్ రీడర్ నుండి చదివిన పంక్తుల స్ట్రీమ్‌ను అందిస్తుంది, ఇది తదుపరి ప్రాసెసింగ్ కోసం అనుమతిస్తుంది. |
| StandardCharsets.UTF_8 | ఎన్‌కోడింగ్ కోసం UTF-8 అక్షర సమితిని పేర్కొంటుంది, అక్షర డేటా యొక్క సరైన నిర్వహణను నిర్ధారిస్తుంది. |
| StringBuilder | స్ట్రింగ్‌లను సమర్ధవంతంగా సృష్టించడం మరియు సవరించడం కోసం ఉపయోగించే అక్షరాల యొక్క మార్చదగిన క్రమం. |
మార్పిడి ప్రక్రియను అర్థం చేసుకోవడం
అందించిన స్క్రిప్ట్‌లు ఒకని ఎలా సమర్థవంతంగా మార్చాలో ప్రదర్శిస్తాయి a కు జావాలో. మొదటి స్క్రిప్ట్ a ని ఉపయోగిస్తుంది ఒక చుట్టూ చుట్టి InputStreamReader, ఇది నుండి బైట్‌లను చదువుతుంది మరియు వాటిని అక్షరాలుగా మారుస్తుంది. ది యొక్క పద్ధతి పంక్తుల స్ట్రీమ్‌ను తిరిగి అందిస్తుంది, తర్వాత అవి సింగిల్‌గా సేకరించబడతాయి String ఉపయోగించి . ఈ విధానం డేటా యొక్క పెద్ద స్ట్రీమ్‌లను ప్రాసెస్ చేయడానికి సమర్థవంతంగా పనిచేస్తుంది, ఎందుకంటే ఇది పంక్తులను సోమరిగా ప్రాసెస్ చేయడం ద్వారా మెమరీ వినియోగాన్ని తగ్గిస్తుంది.
రెండవ స్క్రిప్ట్ ఇదే విధానాన్ని అనుసరిస్తుంది కానీ aని ఉపయోగిస్తుంది నుండి చదివిన పంక్తులను కూడబెట్టడానికి . ఈ పద్ధతికి అన్ని పంక్తులు జోడించబడిందని నిర్ధారిస్తుంది సరైన లైన్ సెపరేటర్లతో. రెండు స్క్రిప్ట్‌లు a ఉపయోగించి మినహాయింపులను నిర్వహిస్తాయి try-with-resources ప్రకటన, ఇది వనరులు స్వయంచాలకంగా మూసివేయబడిందని నిర్ధారిస్తుంది. దాని యొక్క ఉపయోగం రెండవ స్క్రిప్ట్‌లో ప్లాట్‌ఫారమ్ యొక్క డిఫాల్ట్ అక్షరసమితితో సంబంధం లేకుండా టెక్స్ట్ సరిగ్గా అన్వయించబడిందని హామీ ఇస్తుంది.
జావాలో ఇన్‌పుట్ స్ట్రీమ్‌ను స్ట్రింగ్‌గా సమర్థవంతంగా మారుస్తోంది
InputStream మార్పిడిని నిర్వహించడానికి జావా ప్రోగ్రామింగ్
import java.io.BufferedReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import java.util.stream.Collectors;public class InputStreamConverter {public static String convertStreamToString(InputStream is) {try (BufferedReader reader = new BufferedReader(new InputStreamReader(is))) {return reader.lines().collect(Collectors.joining(System.lineSeparator()));} catch (IOException e) {e.printStackTrace();return null;}}}
ఇన్‌పుట్‌స్ట్రీమ్‌ను స్ట్రింగ్‌గా మార్చడానికి సులభమైన విధానం
ఇన్‌పుట్‌స్ట్రీమ్ మానిప్యులేషన్ కోసం జావా ప్రోగ్రామింగ్
import java.io.BufferedReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import java.nio.charset.StandardCharsets;public class StreamToString {public static String convertStreamToString(InputStream is) {StringBuilder sb = new StringBuilder();try (BufferedReader reader = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8))) {String line;while ((line = reader.readLine()) != null) {sb.append(line).append(System.lineSeparator());}} catch (IOException e) {e.printStackTrace();}return sb.toString();}}
పెద్ద ఇన్‌పుట్ స్ట్రీమ్‌లను సమర్థవంతంగా నిర్వహించడం
పెద్దతో పని చేస్తున్నప్పుడు , మెమరీని సమర్థవంతంగా నిర్వహించడం చాలా ముఖ్యం. ఒక విధానం చదవడం పంక్తి ద్వారా కాకుండా భాగాలుగా, బైట్ బఫర్‌ని ఉపయోగించడం ద్వారా సాధించవచ్చు. బైనరీ డేటా లేదా మెమరీ వినియోగాన్ని తగ్గించాల్సిన పెద్ద టెక్స్ట్ ఫైల్‌లతో వ్యవహరించేటప్పుడు ఈ పద్ధతి ప్రయోజనకరంగా ఉంటుంది. బఫర్‌ను కేటాయించడం మరియు దానిలో డేటాను చదవడం ద్వారా, మీరు అధిక మెమరీని వినియోగించకుండా పెద్ద ఫైల్‌లను ప్రాసెస్ చేయవచ్చు.
మరొక సాంకేతికతను ఉపయోగిస్తున్నారు లైబ్రరీ, ఇది I/O కార్యకలాపాలను నిర్వహించడానికి యుటిలిటీ పద్ధతులను అందిస్తుంది. ది పద్ధతి, ఉదాహరణకు, ఒక యొక్క సూటిగా మార్చడానికి అనుమతిస్తుంది a కు String. ఈ లైబ్రరీ మీ కోడ్‌ను సులభతరం చేయగలదు మరియు ఇది బాహ్య ఆధారపడటాన్ని పరిచయం చేసినప్పటికీ చదవగలిగే సామర్థ్యాన్ని మెరుగుపరుస్తుంది. బలమైన అప్లికేషన్‌ల కోసం, సమర్థవంతమైన మరియు నిర్వహించదగిన కోడ్‌ని నిర్ధారించడానికి ఈ విధానాలను పరిగణించండి.
- ఉపయోగించడం యొక్క ప్రయోజనం ఏమిటి ?
- ది ఇన్‌పుట్‌ను బఫర్ చేయడం ద్వారా మరియు I/O ఆపరేషన్‌ల సంఖ్యను తగ్గించడం ద్వారా సామర్థ్యాన్ని మెరుగుపరుస్తుంది.
- ఎందుకు వాడాలి తో ?
- ది బైట్ స్ట్రీమ్‌ను క్యారెక్టర్ స్ట్రీమ్‌గా మారుస్తుంది, ఇది టెక్స్ట్ డేటాను చదవడానికి అనుమతిస్తుంది.
- దేనిని స్క్రిప్ట్‌లో చేస్తారా?
- ది పద్ధతి స్ట్రీమ్ యొక్క పంక్తులను ఒక సింగిల్‌గా కలుపుతుంది పేర్కొన్న డీలిమిటర్‌తో.
- ఎలా చేస్తుంది పనితీరును పెంచుకోవాలా?
- ది మార్చలేని స్ట్రింగ్‌లను ఉపయోగించడంతో పోలిస్తే మెమరీ ఓవర్‌హెడ్‌ను తగ్గించడం ద్వారా స్ట్రింగ్‌లను సమర్ధవంతంగా జోడించడానికి ఉపయోగించబడుతుంది.
- ప్రయోజనాలు ఏమిటి ?
- ది ప్రకటన వనరులు స్వయంచాలకంగా మూసివేయబడతాయని నిర్ధారిస్తుంది, వనరుల లీక్‌లను నివారిస్తుంది.
- ఎందుకు పేర్కొనండి ?
- పేర్కొనడం విభిన్న ప్లాట్‌ఫారమ్‌లలో స్థిరమైన అక్షర ఎన్‌కోడింగ్‌ని నిర్ధారిస్తుంది.
- చెయ్యవచ్చు మార్పిడి ప్రక్రియను సులభతరం చేయాలా?
- అవును, ఉపయోగించి నుండి పద్ధతి ఒక మార్చడానికి కోడ్‌ను సులభతరం చేయవచ్చు a కు String.
ఇన్‌పుట్‌స్ట్రీమ్ మార్పిడిపై తుది ఆలోచనలు
ఒక మార్చడం a కు జావా ప్రోగ్రామింగ్‌లో ఒక సాధారణ పని, ఇది సరైన పద్ధతులను ఉపయోగించి సమర్థవంతంగా నిర్వహించబడుతుంది. వంటి తరగతులను ఉపయోగించడం మరియు InputStreamReader వంటి పద్ధతులు అయితే టెక్స్ట్ డేటా యొక్క సాఫీగా ప్రాసెస్ చేయడానికి అనుమతిస్తుంది మరియు Apache Commons IO వంటి లైబ్రరీలు కోడ్ సరళత మరియు పనితీరును మరింత మెరుగుపరుస్తాయి. ఈ పద్ధతులను అనుసరించడం ద్వారా, డెవలపర్‌లు తమ అప్లికేషన్‌లు ఇన్‌పుట్ స్ట్రీమ్‌లను సమర్థవంతంగా మరియు విశ్వసనీయంగా హ్యాండిల్ చేస్తున్నాయని నిర్ధారించుకోవచ్చు.