"హలో, అమిగో! మీరు చాలా కాలంగా బఫర్డ్ రీడర్ మరియు ఇన్‌పుట్‌స్ట్రీమ్ రీడర్ తరగతులను ఉపయోగిస్తున్నారు . ఇప్పుడు అవి వాస్తవానికి ఏమి చేస్తున్నాయో అన్వేషిద్దాం."
InputStreamReader క్లాస్ అనేది InputStream ఇంటర్‌ఫేస్ నుండి రీడర్ ఇంటర్‌ఫేస్‌కి ఒక క్లాసిక్ అడాప్టర్ . ఇక్కడ కూడా జోడించడానికి ఏమీ లేదు.
కానీ సంక్షిప్తంగా, ఇది జరుగుతుంది. మీరు ఇన్‌పుట్‌స్ట్రీమ్‌రీడర్ ఆబ్జెక్ట్ నుండి తదుపరి అక్షరాన్ని అభ్యర్థించినప్పుడు (చదవండి) , ఇది ఇన్‌పుట్‌స్ట్రీమ్ నుండి కొన్ని బైట్‌లను కన్స్ట్రక్టర్‌కు పంపి, వాటిని ఒక అక్షరంగా తిరిగి ఇస్తుంది.
కానీ రీడర్ పని చేయడానికి అత్యంత అనుకూలమైన వస్తువు కాదు. తరచుగా మనకు కావలసింది వినియోగదారు నమోదు చేసిన అన్ని అక్షరాలను ఒకేసారి చదవడం కాదు, కానీ ఈ అక్షరాలను పంక్తులుగా విభజించడం.
"అయితే రీడర్ క్లాస్‌లో రీడ్ (చార్‌బఫర్‌లు) పద్ధతి ఉంది. మనం దానిని ఉపయోగించలేమా?"
"ఈ పద్ధతి బఫర్ పరిమాణంలోని డేటాను భాగాలుగా చదివి చార్బఫర్ వస్తువులో ఉంచుతుంది."
వచనం సాధారణంగా పంక్తులుగా విభజించబడింది. కాబట్టి రీడ్ (చార్‌బఫర్‌లు) పద్ధతి అనేక పంక్తులను ఒకేసారి చదవవచ్చు. మనం ఒక పంక్తి చివరి వరకు (అంటే ఒక కొత్త లైన్ అక్షరం వరకు అన్ని అక్షరాలు) వచనాన్ని సరిగ్గా చదవాల్సిన అవసరం ఉన్నట్లయితే, వేరొకదాని కోసం వెతకడం మంచిది. మరియు ప్రత్యామ్నాయ పద్ధతి ఉంది. బఫర్డ్ రీడర్ తరగతిలో .
రీడర్ పైన అనుకూలమైన నిర్మాణం అయిన బఫర్డ్ రీడర్ క్లాస్ చాలా అనుకూలమైన పద్ధతిని కలిగి ఉంది: readLine ( ) . ఈ పద్ధతి రీడర్ నుండి టెక్స్ట్ యొక్క మొత్తం పంక్తులను ఒకేసారి చదవడానికి అనుమతిస్తుంది. మీరు మీ కోడ్‌లో రీడ్‌లైన్‌కి కాల్ చేసినప్పుడు, అది రీడర్ ఆబ్జెక్ట్ నుండి కొత్త లైన్ అక్షరాన్ని ఎదుర్కొనే వరకు అక్షరాలను చదువుతుంది. కొత్త లైన్ అక్షరం ఎదురైన తర్వాత, పద్ధతి ఈ అక్షరాలను ఒకే స్ట్రింగ్‌లో అతికించి దానిని తిరిగి అందిస్తుంది.
"నేను దీన్ని రెగ్యులర్‌గా ఉపయోగించాను, కానీ ఇది ఎలా పనిచేస్తుందో నాకు తెలియదు. ఇప్పుడు నాకు తెలుసు. ధన్యవాదాలు, కిమ్."
GO TO FULL VERSION