ఫైల్ రీడర్/ఫైల్ రైటర్

"హలో, అమిగో! నిన్న రిషి మీకు FileInputStream మరియు FileOutputStream గురించి చెప్పారు . మరియు ఈరోజు నేను మీకు FileReader మరియు FileWriter తరగతుల గురించి చెబుతాను ."

మీరు బహుశా ఇప్పటికే ఊహించినట్లుగా, ఈ తరగతులన్నీ ఫైల్ ఆబ్జెక్ట్ మరియు ఇన్‌పుట్‌స్ట్రీమ్ , అవుట్‌పుట్‌స్ట్రీమ్ , రీడర్ మరియు రైటర్ "ఇంటర్‌ఫేస్‌లు" మధ్య అడాప్టర్‌లు.

"అవి ఫైల్ మరియు రీడర్/రైటర్ మధ్య అడాప్టర్‌ల మాదిరిగానే ఉంటాయి, కానీ మీరు స్ట్రింగ్ ఆబ్జెక్ట్‌ను కన్స్ట్రక్టర్‌కు మాత్రమే పంపాలి, ఫైల్ కాదు!"

"వాస్తవానికి, వారికి అనేక కన్‌స్ట్రక్టర్‌లు ఉన్నాయి. ఫైల్ మరియు స్ట్రింగ్ ఆబ్జెక్ట్‌లు రెండింటికీ కన్‌స్ట్రక్టర్‌లు ఉన్నాయి. మీరు స్ట్రింగ్ ఆబ్జెక్ట్‌ను కన్స్ట్రక్టర్‌కి పంపితే, కన్స్ట్రక్టర్ పాస్ చేసిన స్ట్రింగ్ ఆబ్జెక్ట్ నుండి తీసిన ఫైల్ పాత్‌ను ఉపయోగించి నిశ్శబ్దంగా ఫైల్ ఆబ్జెక్ట్‌ను సృష్టిస్తారు."

ఇది సౌలభ్యం కోసం. జావా సృష్టికర్తలు ఈ తరగతులకు అత్యంత తరచుగా ఉపయోగించే కేసులను తీసుకున్నారు మరియు వాటన్నింటికీ కన్స్ట్రక్టర్‌లను వ్రాసారు. ఇది చాలా సౌకర్యవంతంగా ఉంటుంది, మీరు అనుకోలేదా?

"ఓహ్, అవును. అనుకూలమైనది. నేను అంగీకరిస్తున్నాను. అయితే నేను ఎందుకు నిరంతరం వ్రాయాలి:"
BufferedReader bufferedReader = కొత్త బఫర్డ్ రీడర్(కొత్త ఇన్‌పుట్‌స్ట్రీమ్ రీడర్(సిస్టమ్.ఇన్));
"వారు ఈ వినియోగ కేసును ఎందుకు జోడించలేదు?"

"ఇక్కడ సమస్య ఏమిటంటే, ఒక   సాధారణ Java ప్రోగ్రామ్ కన్సోల్‌తో పని చేయదు. వాస్తవానికి, మీరు దాని నుండి దాదాపు ఏమీ చదవలేదు. వెబ్ సర్వర్, అప్లికేషన్ సర్వర్ లేదా కొన్ని ఇతర సంక్లిష్టమైన సిస్టమ్‌తో కూడా."

కానీ కన్సోల్‌కు డేటా మరియు టెక్స్ట్ అవుట్‌పుట్ చేయడానికి మాకు ప్రింట్‌స్ట్రీమ్ ఉంది. ఎందుకంటే ఈ «సర్వర్ అప్లికేషన్‌లు» తరచుగా వాటి స్థితి, లోపాలు మరియు అన్ని రకాల ఇతర సమాచారాన్ని ప్రదర్శించడానికి కన్సోల్‌ను ఉపయోగిస్తాయి.

"అర్థమైంది. మీరు ఫైల్‌రీడర్ మరియు ఫైల్‌రైటర్‌ని ఉపయోగించి ఫైల్‌ను కూడా కాపీ చేయవచ్చా?"

"అవును, ఇది టెక్స్ట్ ఫైల్ అయితే (అంటే అది అక్షరాలను కలిగి ఉంటుంది). ఇక్కడ ఒక ఉదాహరణ ఉంది:"

public static void main(String[] args) throws Exception
{
 FileReader reader = new FileReader("c:/data.txt");
 FileWriter writer = new FileWriter("c:/result.txt");

 while (reader.ready()) //as long as there are unread bytes in the input stream
 {
  int data = reader.read(); //Read one character (the char will be widened to an int)
  writer.write(data); //Write one character (the int will be truncated/narrowed to a char)
 }

 //Close the streams after we done using them
 reader.close();
 writer.close();
}

"దాదాపు తేడాలు లేవు."

"అవును, తేడాలు చాలా తక్కువ."