ఇన్‌పుట్/అవుట్‌పుట్ స్ట్రీమ్‌లు

"హలో, అమిగో! ఈ రోజు మనం ఇన్‌పుట్/అవుట్‌పుట్ స్ట్రీమ్‌లతో పరిచయం పొందుతాము . మేము ఈ అంశాన్ని రెండు రోజుల క్రితం ఎంచుకున్నాము, కానీ ఈ రోజు మేము దానిని పూర్తిగా అన్వేషిస్తాము. ఇన్‌పుట్/అవుట్‌పుట్ స్ట్రీమ్‌లు 4 వర్గాలుగా విభజించబడ్డాయి:"

1) స్ట్రీమ్‌లు వాటి దిశను బట్టి విభజించబడ్డాయి: ఇన్‌పుట్ స్ట్రీమ్‌లు మరియు అవుట్‌పుట్ స్ట్రీమ్‌లు

2) స్ట్రీమ్‌లు వాటి డేటా రకం ప్రకారం విభజించబడ్డాయి: బైట్‌లతో పని చేసేవి మరియు అక్షరాలతో పని చేసేవి .

ఇక్కడ ఈ విభాగాలు పట్టికలో సూచించబడ్డాయి:

ఒక వస్తువు ఇన్‌పుట్‌స్ట్రీమ్ ఇంటర్‌ఫేస్‌ను అమలు చేస్తే , దాని నుండి బైట్‌లను సీక్వెన్షియల్‌గా రీడ్ చేసే సామర్థ్యానికి అది మద్దతు ఇస్తుంది.

ఒక వస్తువు అవుట్‌పుట్‌స్ట్రీమ్ ఇంటర్‌ఫేస్‌ను అమలు చేస్తే , దానికి బైట్‌లను క్రమానుగతంగా వ్రాయగల సామర్థ్యానికి అది మద్దతు ఇస్తుంది.

ఆబ్జెక్ట్ రీడర్ ఇంటర్‌ఫేస్‌ను అమలు చేస్తే, దాని నుండి అక్షరాలు (అక్షరాలు) క్రమానుగతంగా చదివే సామర్థ్యానికి అది మద్దతు ఇస్తుంది.

ఆబ్జెక్ట్ రైటర్ ఇంటర్‌ఫేస్‌ను అమలు చేస్తే, దానికి వరుసగా అక్షరాలు (అక్షరాలు) వ్రాయగల సామర్థ్యానికి అది మద్దతు ఇస్తుంది.

అవుట్‌పుట్ స్ట్రీమ్ ప్రింటర్ లాంటిది. మేము ప్రింటర్‌కు పత్రాలను అవుట్‌పుట్ చేయవచ్చు. మేము అవుట్‌పుట్ స్ట్రీమ్‌కి డేటాను అవుట్‌పుట్ చేయవచ్చు.

దాని భాగానికి, ఇన్‌పుట్ స్ట్రీమ్‌ను స్కానర్ లేదా ఎలక్ట్రికల్ అవుట్‌లెట్‌తో పోల్చవచ్చు. స్కానర్‌తో, మన కంప్యూటర్‌లోకి పత్రాలను తీసుకురావచ్చు. లేదా మనం ఎలక్ట్రికల్ అవుట్‌లెట్‌లోకి ప్లగ్ చేసి దాని నుండి విద్యుత్‌ను పొందవచ్చు. మేము ఇన్‌పుట్ స్ట్రీమ్ నుండి డేటాను స్వీకరించగలము.

"అవి ఎక్కడ ఉపయోగించబడ్డాయి?"

"ఈ తరగతులు జావాలో ప్రతిచోటా ఉపయోగించబడుతున్నాయి. మా సుపరిచితమైన స్నేహితుడు System.in అనేది సిస్టమ్ క్లాస్‌లో పేరు పెట్టబడిన స్టాటిక్ ఇన్‌పుట్‌స్ట్రీమ్ వేరియబుల్ . "

"గంభీరంగా?! కాబట్టి నేను ఇన్‌పుట్‌స్ట్రీమ్‌ని ఉపయోగిస్తున్నాను మరియు దానిని కూడా గుర్తించలేదు. System.out కూడా స్ట్రీమ్‌గా ఉందా?"

"అవును, System.out అనేది సిస్టమ్ క్లాస్‌లో స్టాటిక్ ప్రింట్‌స్ట్రీమ్ ( అవుట్‌పుట్‌స్ట్రీమ్ యొక్క వారసుడు ) వేరియబుల్."

"నేను ఎప్పుడూ స్ట్రీమ్‌లను ఉపయోగిస్తున్నానని మరియు అది కూడా తెలియదని నాకు చెప్పాలా?"

"అవును, ఈ స్ట్రీమ్‌లు ఎంత సౌకర్యవంతంగా ఉన్నాయో అది మాకు తెలియజేస్తుంది. మీరు ఒకదాన్ని పట్టుకుని దాన్ని ఉపయోగించండి."

"కానీ మీరు System.in గురించి చెప్పలేరు. మేము దానికి నిరంతరం బఫర్డ్ రీడర్ లేదా ఇన్‌పుట్‌స్ట్రీమ్‌రీడర్‌ని జోడించాల్సి ఉంటుంది."

"అది నిజమే. కానీ దానికి కారణాలు కూడా ఉన్నాయి."

డేటా రకాలు చాలా ఉన్నాయి మరియు వాటితో పని చేయడానికి అనేక మార్గాలు ఉన్నాయి. కాబట్టి ప్రామాణిక I/O తరగతుల సంఖ్య చాలా త్వరగా పెరిగింది, అయినప్పటికీ అవి దాదాపు ఒకే విధంగా ఉన్నాయి. ఈ సంక్లిష్టతను నివారించడానికి, జావా డెవలపర్లు సంగ్రహణ సూత్రాన్ని ఉపయోగించారు మరియు తరగతులను అనేక చిన్న భాగాలుగా విభజించారు.

కానీ మీరు ఈ భాగాలను పొందికైన మార్గంలో కనెక్ట్ చేయవచ్చు మరియు మీకు అవసరమైతే చాలా క్లిష్టమైన కార్యాచరణను పొందవచ్చు. ఈ ఉదాహరణ చూడండి:

System.out.println("Hello");

PrintStream console = System.out;
console.println("Hello");

ByteArrayOutputStream stream = new ByteArrayOutputStream();
PrintStream console = new PrintStream(stream);
console.println("Hello");

"నిజాయితీగా చెప్పాలంటే, ఇది లెగో సెట్ లాంటిది. ఈ కోడ్‌లో ఏదైనా ఏమి చేస్తుందో నాకు స్పష్టంగా తెలియదు."

"ప్రస్తుతానికి దాని గురించి చింతించకండి. ప్రతిదీ దాని స్వంత సమయానికి."

ఇది మీరు గుర్తుంచుకోవాలని నేను కోరుకుంటున్నాను: ఒక తరగతి OutputStream ఇంటర్‌ఫేస్‌ను అమలు చేస్తే, మీరు దానికి బైట్‌లను వ్రాయవచ్చు. దాదాపు మీరు కన్సోల్‌కి డేటాను అవుట్‌పుట్ చేసినట్లే. దానితో చేసేది దాని వ్యాపారం. మా "లెగో కిట్"తో, మేము ఒక్కొక్క భాగం యొక్క ప్రయోజనం గురించి పట్టించుకోము. భాగాల యొక్క పెద్ద ఎంపిక అటువంటి అద్భుతమైన వస్తువులను నిర్మించడానికి మాకు వీలు కల్పిస్తుందని మేము శ్రద్ధ వహిస్తాము.

"సరే. అప్పుడు మనం ఎక్కడ ప్రారంభించాలి?"