జావా డెవలపర్‌లను ఫైల్‌లతో పని చేయడానికి అనుమతిస్తుంది. అటువంటి సందర్భంలో, ' ఇన్‌పుట్ స్ట్రీమ్ 'తరగతి అమలులోకి వస్తుంది, ఇది కలిగి ఉన్న బైట్‌లను విశ్లేషించడంతో పాటు పేర్కొన్న ఫైల్ కంటెంట్‌లను చదవడంలో సహాయపడుతుంది. ఇది మెమరీ సమస్యలను ఎదుర్కోవడానికి మరియు అవసరానికి అనుగుణంగా ఎంపిక చేసిన ఫైల్ కంటెంట్‌ను సమర్ధవంతంగా తిరిగి అందిస్తుంది.
ఈ వ్రాత జావాలో “ఇన్‌పుట్ స్ట్రీమ్” యొక్క పనిని వివరిస్తుంది.
జావా ఇన్‌పుట్ స్ట్రీమ్ ఎలా పని చేస్తుంది?
'ఇన్‌పుట్‌స్ట్రీమ్' తరగతి java.io ” ప్యాకేజీ నిర్దేశిత ఫైల్‌కు వ్యతిరేకంగా బైట్‌లతో కూడిన ఇన్‌పుట్ స్ట్రీమ్‌ను అందించే వియుక్త సూపర్‌క్లాస్‌కు అనుగుణంగా ఉంటుంది.
ఇన్‌పుట్ స్ట్రీమ్ యొక్క ఉపవర్గాలు
“ఇన్‌పుట్‌స్ట్రీమ్” ఫంక్షనాలిటీలను వర్తింపజేయడానికి, దాని క్రింది ఉపవర్గాలను ఉపయోగించవచ్చు:
-
- FileInputStream
- ObjectInputStream
- ByteArrayInputStream
ఈ సబ్‌క్లాస్‌లు “ఇన్‌పుట్‌స్ట్రీమ్” క్లాస్‌ను విస్తరించేలా ఉన్నాయి.
ఇన్‌పుట్ స్ట్రీమ్ పద్ధతులు
'ఇన్‌పుట్‌స్ట్రీమ్' క్లాస్ దాని సబ్‌క్లాస్‌ల ద్వారా వర్తించే విభిన్న పద్ధతులను కలిగి ఉంది. అత్యంత సాధారణంగా ఉపయోగించే కొన్ని పద్ధతులు క్రిందివి:
| పద్ధతులు | కార్యాచరణ |
| చదవండి() | ఇది ఇన్‌పుట్ స్ట్రీమ్ నుండి బైట్ డేటాను రీడ్ చేస్తుంది.
|
| రీడ్(బైట్[] అర్రే) | ఇది స్ట్రీమ్ నుండి బైట్‌లను కూడా చదువుతుంది మరియు వాటిని లక్ష్య శ్రేణిలో నిల్వ చేస్తుంది.
|
| దాటవేయి() | ఈ పద్ధతి ఇన్‌పుట్ స్ట్రీమ్ నుండి నిర్దిష్ట సంఖ్యలో బైట్‌లను దాటవేస్తుంది/విస్మరిస్తుంది.
|
| అందుబాటులో () | ఇది ఇన్‌పుట్ స్ట్రీమ్‌లో ఉన్న బైట్‌లను ఇస్తుంది. |
| రీసెట్ () | ఇది మార్క్ సెట్ చేయబడిన స్ట్రీమ్ పాయింట్‌కి యాక్సెస్ ఇస్తుంది.
|
| గుర్తు() | ఈ పద్ధతి స్ట్రీమ్‌లో డేటా రీడ్ అయ్యే వరకు స్థానాన్ని సూచిస్తుంది.
|
| మార్క్ సపోర్టెడ్() | స్ట్రీమ్‌లో “మార్క్()” మరియు “రీసెట్()” పద్ధతులు మద్దతిస్తున్నాయో/అనుకూలంగా ఉన్నాయో లేదో ఇది విశ్లేషిస్తుంది.
|
ఉదాహరణకి వెళ్లే ముందు, “ఇన్‌పుట్‌స్ట్రీమ్” మరియు దాని సబ్‌క్లాస్‌తో పని చేయడానికి క్రింది ప్యాకేజీలను దిగుమతి చేయండి:
java.io.InputStreamని దిగుమతి చేయండి;
ఉదాహరణ: జావాలో ఇన్‌పుట్ స్ట్రీమ్ పని చేయడం
ఈ ఉదాహరణ 'InputStream' పద్ధతుల ద్వారా ఫైల్ కంటెంట్‌ను చదవడం ద్వారా 'InputStream' పనిని వివరిస్తుంది:
పబ్లిక్ క్లాస్ ఇన్‌పుట్ స్ట్రీమ్ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ ఆర్గ్స్ [ ] ) {
బైట్ [ ] givenarray = కొత్త బైట్ [ యాభై ] ;
ప్రయత్నించండి {
InputStream readData = కొత్త FileInputStream ( 'readfile.txt' ) ;
System.out.println ( 'ఫైల్‌లోని బైట్లు -> ' + readData.అందుబాటులో ఉంది ( ) ) ;
readData.read ( ఇచ్చిన విధానం ) ;
System.out.println ( 'ఫైల్ డేటాను చదవండి:' ) ;
String containdata = కొత్త స్ట్రింగ్ ( ఇచ్చిన విధానం ) ;
System.out.println ( కలిగి ఉన్న డేటా ) ;
readData.close ( ) ;
}
క్యాచ్ ( మినహాయింపు తప్ప ) {
తప్ప.getStackTrace ( ) ;
}
} }
పై కోడ్ లైన్‌ల ప్రకారం, దిగువ పేర్కొన్న దశలను చేయండి:
-
- ముందుగా, గరిష్టంగా 'బైట్' శ్రేణిని సృష్టించండి యాభై ” రీడ్ ఫైల్‌లో బైట్ విలువలు.
- తదుపరి దశలో, 'ని సృష్టించండి ఇన్‌పుట్ స్ట్రీమ్ ” ఫైల్‌ఇన్‌పుట్‌స్ట్రీమ్‌ని ఉపయోగించి మరియు పేర్కొన్న ఫైల్‌లో అందుబాటులో ఉన్న బైట్‌లను అనుబంధిత “ ద్వారా తిరిగి ఇవ్వండి అందుబాటులో () ” పద్ధతి.
- ఆ తర్వాత, “ని ఉపయోగించి ఇన్‌పుట్ స్ట్రీమ్ నుండి బైట్‌లను చదవండి చదవండి() ” పద్ధతి.
- ఇప్పుడు, బైట్ శ్రేణిని స్ట్రింగ్‌గా మార్చండి మరియు ఫైల్ కంటెంట్‌లను ప్రదర్శించండి.
- చివరగా, అనుబంధిత “ని ఉపయోగించి రీడ్ ఫైల్‌ను మూసివేయండి దగ్గరగా() ” పద్ధతి.
అవుట్‌పుట్
ఈ ఫలితంలో, ఫైల్‌లోని బైట్‌ల సంఖ్య అంటే, కంటెంట్ ద్వారా సేకరించబడిన స్థలం బైట్ శ్రేణిలోని గరిష్ట పరిధికి అనుగుణంగా తిరిగి ఇవ్వబడుతుంది అంటే, “50” అని సూచించవచ్చు. అలాగే, ఫైల్ కంటెంట్ తగిన విధంగా తిరిగి ఇవ్వబడుతుంది.
ఫైల్ కంటెంట్
యొక్క అవలోకనాన్ని పొందడానికి ' దాటవేయి() 'మరియు' రీసెట్ () ” పద్ధతులు, కింది ప్రదర్శనను పరిగణించండి:
ఈ దృష్టాంతంలో, “స్కిప్()” పద్ధతి నిర్దేశిత బైట్‌ల సంఖ్యను దాటవేస్తుంది అంటే, “ 5 -> జావా ” ప్రారంభం నుండి ఫైల్ కంటెంట్ నుండి. “రీసెట్()” పద్ధతి అయితే స్ట్రీమ్‌ని రీసెట్ చేస్తుంది.
ముగింపు
ది ' ఇన్‌పుట్ స్ట్రీమ్ 'తరగతి' java.io ” ప్యాకేజీ అనేది ఫైల్ డేటాను చదవడానికి ఉపయోగించే బైట్‌ల ఇన్‌పుట్ స్ట్రీమ్‌కు అనుగుణంగా ఉండే ఒక వియుక్త సూపర్ క్లాస్. ఈ తరగతి అవసరానికి అనుగుణంగా ఫైల్ యొక్క రీడింగ్ మెథడాలజీలలో ప్రభావవంతంగా సహాయపడే వివిధ పద్ధతులను కలిగి ఉంటుంది. ఈ బ్లాగ్ జావాలో “ఇన్‌పుట్ స్ట్రీమ్” యొక్క ప్రయోజనం మరియు పనిని ప్రదర్శించింది.