ఫైల్ ఇన్‌పుట్ స్ట్రీమ్ క్లాస్‌లో ఇంకా అనేక పద్ధతులు ఉన్నాయి, ఇవి ఫైల్ నుండి డేటాను పొందడంలో చాలా సహాయకారిగా ఉంటాయి; వాటిలో కొన్ని int read(byte[] b), ఈ ఫంక్షన్ ఇన్‌పుట్ స్ట్రీమ్ నుండి b.length బైట్‌ల పొడవు వరకు డేటాను రీడ్ చేస్తుంది. ఫైల్ ఛానెల్ ఛానెల్‌ని పొందుతుంది(): ఫైల్ ఇన్‌పుట్ స్ట్రీమ్‌కు కనెక్ట్ చేయబడిన నిర్దిష్ట ఫైల్ ఛానెల్ ఆబ్జెక్ట్ దాన్ని ఉపయోగించి తిరిగి ఇవ్వబడుతుంది. ఫైల్ ఇన్‌పుట్ స్ట్రీమ్‌కు ఇకపై రిఫరెన్స్ లేనప్పుడు క్లోజ్() ఫంక్షన్ అమలు చేయబడిందని నిర్ధారించడానికి ఫైనల్() ఉపయోగించబడుతుంది.
ఉదాహరణ 01: ఇన్‌పుట్ స్ట్రీమ్ క్లాస్ యొక్క రీడ్() మరియు క్లోజ్() పద్ధతులను ఉపయోగించి టెక్స్ట్ ఫైల్ నుండి ఒకే బైట్ చదవడం
ఈ ఉదాహరణ ఒకే అక్షరాన్ని చదవడానికి మరియు కంటెంట్‌ను ప్రింట్ చేయడానికి ఫైల్ ఇన్‌పుట్ స్ట్రీమ్‌ని ఉపయోగిస్తుంది. క్రింద చూపిన కంటెంట్‌తో “file.txt” అనే ఫైల్ మన వద్ద ఉందని అనుకుందాం:
పైన చూపిన కంటెంట్‌తో మనకు “file.txt” అనే ఫైల్ ఉందని అనుకుందాం. ఇప్పుడు ఫైల్ యొక్క మొదటి అక్షరాన్ని చదవడానికి మరియు ముద్రించడానికి ప్రయత్నిద్దాం.
మనం ముందుగా java.ioని దిగుమతి చేసుకోవాలి. ఫైల్ ఇన్‌పుట్ స్ట్రీమ్‌ను నిర్మించడానికి ఫైల్ ఇన్‌పుట్ స్ట్రీమ్ ప్యాకేజీ. అప్పుడు మేము ఫైల్ ఇన్‌పుట్ స్ట్రీమ్ యొక్క కొత్త ఆబ్జెక్ట్‌ను సృష్టిస్తాము, అది వేరియబుల్ “f”లో పేర్కొన్న ఫైల్‌కి (file.txt) లింక్ చేయబడుతుంది.
ఈ ఉదాహరణలో, మేము జావా ఫైల్ ఇన్‌పుట్ స్ట్రీమ్ క్లాస్ యొక్క “int read()” పద్ధతిని ఉపయోగిస్తాము, ఇది ఫైల్ నుండి ఒక బైట్‌ను చదవడానికి మరియు దానిని వేరియబుల్ “I”లో సేవ్ చేయడానికి ఉపయోగించబడుతుంది. తర్వాత, “System.out.print(char(i))” ఆ బైట్‌కి సంబంధించిన అక్షరాన్ని ప్రదర్శిస్తుంది.
f.close() పద్ధతి ఫైల్ మరియు స్ట్రీమ్‌ను మూసివేస్తుంది. పైన పేర్కొన్న స్క్రిప్ట్‌ను నిర్మించి మరియు అమలు చేసిన తర్వాత మేము క్రింది అవుట్‌పుట్‌ను పొందుతాము, ఎందుకంటే 'L' అనే టెక్స్ట్ యొక్క ప్రారంభ అక్షరం మాత్రమే ముద్రించబడి ఉంటుంది.
ఉదాహరణ 02: ఇన్‌పుట్ స్ట్రీమ్ క్లాస్ యొక్క రీడ్() మరియు క్లోజ్() పద్ధతులను ఉపయోగించి టెక్స్ట్ ఫైల్ యొక్క మొత్తం కంటెంట్‌ను చదవడం
ఈ ఉదాహరణలో, మేము టెక్స్ట్ ఫైల్‌లోని అన్ని విషయాలను చదవడం మరియు ప్రదర్శిస్తాము; క్రింద చూపిన విధంగా:
మరోసారి, మేము java.ioని దిగుమతి చేస్తాము. ఫైల్ ఇన్‌పుట్ స్ట్రీమ్‌ను నిర్మించడానికి ఫైల్ ఇన్‌పుట్ స్ట్రీమ్ ప్యాకేజీ.
మొదట, మేము ఫైల్ యొక్క మొదటి బైట్‌ను చదివి, అయితే లూప్ లోపల సంబంధిత అక్షరాన్ని ప్రదర్శిస్తాము. అయితే లూప్ బైట్‌లు మిగిలి లేనంత వరకు, అంటే ఫైల్‌లోని టెక్స్ట్ ముగింపు వరకు రన్ అవుతుంది. లైన్ 12 తదుపరి బైట్‌ను చదువుతుంది మరియు ఫైల్ యొక్క చివరి బైట్ వరకు లూప్ కొనసాగుతుంది.
పై కోడ్‌ను కంపైల్ చేసి అమలు చేసిన తర్వాత, మేము ఈ క్రింది ఫలితాలను పొందుతాము. మేము చూడగలిగినట్లుగా, 'Lorep Ipsum' ఫైల్ యొక్క మొత్తం టెక్స్ట్ టెర్మినల్‌లో ప్రదర్శించబడుతుంది.
ఉదాహరణ 03: అందుబాటులో ఉన్న() ఇన్‌పుట్ స్ట్రీమ్ క్లాస్ పద్ధతిని ఉపయోగించడం ద్వారా టెక్స్ట్ ఫైల్‌లో అందుబాటులో ఉన్న బైట్‌ల సంఖ్యను నిర్ణయించడం
ఈ ఉదాహరణలో, ఫైల్ ఇన్‌పుట్ స్ట్రీమ్‌లో ఇప్పటికే ఉన్న బైట్‌ల సంఖ్యను గుర్తించడానికి మేము ఫైల్ ఇన్‌పుట్ స్ట్రీమ్ యొక్క “అందుబాటులో()” ఫంక్షన్‌ని ఉపయోగిస్తాము.
ముందుగా, మేము కింది కోడ్‌తో “a” పేరుతో ఫైల్ ఇన్‌పుట్ స్ట్రీమ్ క్లాస్ యొక్క వస్తువును రూపొందించాము. లైన్ 5లో, ఫైల్‌లో అందుబాటులో ఉన్న మొత్తం బైట్‌లను గుర్తించడానికి మరియు ప్రదర్శించడానికి మేము “అందుబాటులో()” పద్ధతిని ఉపయోగించాము. అప్పుడు లైన్ 6 నుండి లైన్ 8 వరకు, మేము “రీడ్()” ఫంక్షన్‌ను మూడుసార్లు ఉపయోగించాము. ఇప్పుడు లైన్ 9లో, మిగిలిన బైట్‌లను తనిఖీ చేయడానికి మరియు ప్రదర్శించడానికి మేము “అందుబాటులో()” పద్ధతిని మళ్లీ ఉపయోగించాము.
కోడ్‌ను కంపైల్ చేసి అమలు చేసిన తర్వాత, అవుట్‌పుట్ యొక్క మొదటి పంక్తి ఫైల్‌లో అందుబాటులో ఉన్న మొత్తం బైట్‌ల సంఖ్యను చూపడాన్ని మనం చూడవచ్చు. తదుపరి లైన్ కోడ్ చివరిలో అందుబాటులో ఉన్న బైట్‌ల సంఖ్యను చూపుతుంది, ఇది ప్రారంభంలో అందుబాటులో ఉన్న బైట్‌ల కంటే 3 తక్కువ. ఎందుకంటే మేము మా కోడ్‌లో రీడ్ పద్ధతిని మూడుసార్లు ఉపయోగించాము.
ఉదాహరణ 04: ఇన్‌పుట్ స్ట్రీమ్ క్లాస్ యొక్క స్కిప్() పద్ధతిని ఉపయోగించి ఒక నిర్దిష్ట పాయింట్ నుండి డేటాను చదవడానికి టెక్స్ట్ ఫైల్ బైట్‌లను దాటవేయడం
ఈ ఉదాహరణలో, మేము ఫైల్ ఇన్‌పుట్ స్ట్రీమ్ యొక్క “స్కిప్(x)” పద్ధతిని ఉపయోగిస్తాము, ఇది ఇన్‌పుట్ స్ట్రీమ్ నుండి డేటా బైట్‌ల సంఖ్యను విస్మరించడానికి మరియు విస్మరించడానికి ఉపయోగించబడుతుంది.
దిగువ కోడ్‌లో, ముందుగా, మేము ఫైల్ ఇన్‌పుట్ స్ట్రీమ్‌ను సృష్టించాము మరియు దానిని “a” వేరియబుల్‌లో నిల్వ చేసాము. తరువాత, మేము 'a.skip(5)' పద్ధతిని ఉపయోగించాము, ఇది ఫైల్ యొక్క మొదటి 5 బైట్‌లను దాటవేస్తుంది. తరువాత, కాసేపట్లో లూప్ లోపల “రీడ్()” పద్ధతిని ఉపయోగించి ఫైల్ యొక్క మిగిలిన అక్షరాలను మేము ముద్రించాము. చివరగా, మేము ఫైల్ ఇన్‌పుట్ స్ట్రీమ్‌ను “close()” పద్ధతి ద్వారా మూసివేసాము.
కోడ్‌ను కంపైల్ చేసి రన్ చేసిన తర్వాత టెర్మినల్ యొక్క స్క్రీన్‌షాట్ క్రింద ఉంది. మనం చూడగలిగినట్లుగా, 'స్కిప్()' పద్ధతిని ఉపయోగించి మనం మొదటి 5 బైట్‌లను దాటేసినందున 'ఇప్సమ్' మాత్రమే ప్రదర్శించబడుతుంది.
ముగింపు
ఈ వ్యాసంలో, మేము ఫైల్ ఇన్‌పుట్ స్ట్రీమ్ క్లాస్ మరియు దాని విభిన్న పద్ధతుల ఉపయోగాలు గురించి చర్చించాము; చదవండి(), అందుబాటులో(), దాటవేయి(), మరియు క్లోజ్(). రీడ్() మరియు క్లోజ్() పద్ధతులను ఉపయోగించి ఫైల్ యొక్క మొదటి మూలకాన్ని చదవడానికి మేము ఈ పద్ధతులను ఉపయోగించాము. అప్పుడు మేము పునరుక్తి విధానం ద్వారా మొత్తం ఫైల్‌ను చదువుతాము మరియు అదే పద్ధతులను ఉపయోగిస్తాము. ఫైల్ ప్రారంభం మరియు పూర్తి సమయంలో ఉన్న బైట్‌ల సంఖ్యను నిర్ణయించడానికి మేము అందుబాటులో ఉన్న () పద్ధతిని ఉపయోగించాము. ఆ తర్వాత, ఫైల్‌ను చదవడానికి ముందు అనేక బైట్‌లను దాటవేయడానికి మేము skip() పద్ధతిని ఉపయోగించాము, ఇది మనకు అవసరమైన నిర్దిష్ట డేటాను పొందడానికి మాకు వీలు కల్పించింది.