BuffreredReader మరియు InputStreamReader తరగతులతో పని చేయడం ప్రాక్టీస్ చేయండి

హాయ్! ఈ రోజు పాఠం సౌలభ్యం కోసం రెండు భాగాలుగా విభజించబడుతుంది. మేము గతంలో టచ్ చేసిన కొన్ని పాత అంశాలను పునరావృతం చేస్తాము మరియు కొన్ని కొత్త ఫీచర్లను పరిశీలిస్తాము :) మొదటిదానితో ప్రారంభిద్దాం. మీరు ఇప్పటికే చాలా సార్లు తరగతిని కలిగి ఉన్నారు BufferedReader. ఈ ప్రకటనను మరచిపోవడానికి మీకు సమయం లేదని నేను ఆశిస్తున్నాను:

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

System.inమరింత చదవడానికి ముందు, ప్రతి భాగం — , InputStreamReader, BufferedReader— దేనికి బాధ్యత వహిస్తుందో మరియు అది ఎందుకు అవసరమో గుర్తుంచుకోవడానికి ప్రయత్నించండి . నీకు గుర్తుందా? కాకపోతే చింతించకండి. :) మీరు ఏదైనా మరచిపోయినట్లయితే, ఈ పాఠాన్ని మళ్లీ చదవండి , ఇది రీడర్ తరగతులకు అంకితం చేయబడింది. వాటిలో ప్రతి ఒక్కరు ఏమి చేయగలరో మేము క్లుప్తంగా గుర్తు చేస్తాము. System.in— ఇది కీబోర్డ్ నుండి డేటాను స్వీకరించడానికి ఒక స్ట్రీమ్.  సూత్రప్రాయంగా, వచనాన్ని చదవడానికి అవసరమైన తర్కాన్ని అమలు చేయడానికి ఇది మాత్రమే సరిపోతుంది. కానీ, మీరు గుర్తుచేసుకున్నట్లుగా, System.inబైట్‌లను మాత్రమే చదవగలరు, అక్షరాలు కాదు:

public class Main {

   public static void main(String[] args) throws IOException { 

       while (true) { 
           int x = System.in.read(); 
           System.out.println(x); 
       } 
   } 
} 

మేము ఈ కోడ్‌ని అమలు చేసి, సిరిలిక్ అక్షరం "Й"ని నమోదు చేస్తే, అవుట్‌పుట్ ఇలా ఉంటుంది:

Й
208
153
10 

సిరిలిక్ అక్షరాలు మెమరీలో 2 బైట్‌లను ఆక్రమిస్తాయి మరియు అవి తెరపై ప్రదర్శించబడతాయి. సంఖ్య 10 అనేది లైన్ ఫీడ్ అక్షరం యొక్క దశాంశ ప్రాతినిధ్యం, అనగా ఎంటర్ నొక్కడం నుండి. బైట్‌లను చదవడం చాలా ఆనందంగా ఉంది, కాబట్టి ఉపయోగించడం System.inచాలా సౌకర్యవంతంగా లేదు. సిరిలిక్ (మరియు ఇతర) అక్షరాలను సరిగ్గా చదవడానికి, మేము InputStreamReaderరేపర్‌గా ఉపయోగిస్తాము:

public class Main { 

   public static void main(String[] args) throws IOException { 

       InputStreamReader reader = new InputStreamReader(System.in); 
       while (true) { 
           int x = reader.read(); 
           System.out.println(x); 
       } 
   } 
} 

మేము "Й" అనే అదే అక్షరాన్ని నమోదు చేస్తాము, కానీ ఈసారి ఫలితం భిన్నంగా ఉంటుంది:

Й 
1049 
10

InputStreamReaderరెండు బైట్‌లను (208 మరియు 153) ఒకే సంఖ్య 1049కి మార్చింది. అక్షరాలను చదవడం అంటే ఇదే. 1049 సిరిలిక్ అక్షరం "Й" కు అనుగుణంగా ఉంటుంది. ఇది నిజమని మనం సులభంగా ఒప్పించగలము:

public class Main { 

   public static void main(String[] args) throws IOException { 
       char x = 1049; 
       System.out.println(x); 
   } 
} 

కన్సోల్ అవుట్‌పుట్:

Й

మరియు forBufferedReader(మరియు సాధారణంగా, BufferedAnythingYouWant), పనితీరును ఆప్టిమైజ్ చేయడానికి బఫర్డ్ తరగతులు ఉపయోగించబడతాయి. పనితీరు పరంగా డేటా మూలాన్ని (ఫైల్, కన్సోల్, వెబ్ వనరు) యాక్సెస్ చేయడం చాలా ఖరీదైనది. అందువల్ల, యాక్సెస్‌ల సంఖ్యను తగ్గించడానికి, BufferedReaderప్రత్యేక బఫర్‌లో డేటాను చదవడం మరియు సంచితం చేయడం మరియు మేము దానిని అక్కడ నుండి పొందుతాము. తత్ఫలితంగా, డేటా సోర్స్‌ని యాక్సెస్ చేసే సంఖ్యలు తగ్గించబడతాయి - బహుశా అనేక ఆర్డర్‌ల పరిమాణంలో ఉండవచ్చు! ఫీచర్లలో మరొకటి BufferedReaderమరియు సాధారణం కంటే దాని ప్రయోజనం InputStreamReader, ఇది చాలా ఉపయోగకరమైన readLine()పద్ధతి, ఇది వ్యక్తిగత సంఖ్యలను కాకుండా మొత్తం డేటా లైన్లను చదువుతుంది. పెద్ద గ్రంథాలతో వ్యవహరించేటప్పుడు ఇది చాలా సౌకర్యవంతంగా ఉంటుంది. పఠన పంక్తులు ఎలా ఉంటాయో ఇక్కడ ఉంది:

public class Main { 

   public static void main(String[] args) throws IOException { 

       BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); 
       String s = reader.readLine(); 
       System.out.println ("The user entered the following text:"); 
       System.out.println(s); 
       reader.close(); 
   } 
}

BufferedReader+InputStreamReader is faster than InputStreamReader alone 
The user entered the following text: 
BufferedReader+InputStreamReader is faster than InputStreamReader alone

వాస్తవానికి, BufferedReaderచాలా సరళమైనది. మీరు కీబోర్డ్‌తో పని చేయడానికి మాత్రమే పరిమితం కాలేదు. ఉదాహరణకు, మీరు అవసరమైన URLని రీడర్‌కు పంపడం ద్వారా వెబ్ నుండి నేరుగా డేటాను చదవవచ్చు:

public class URLReader { 

   public static void main(String[] args) throws Exception { 

       URL oracle = new URL("https://www.oracle.com/index.html"); 
       BufferedReader in = new BufferedReader( 
               new InputStreamReader(oracle.openStream())); 

       String inputLine; 
       while ((inputLine = in.readLine()) != null) 
           System.out.println(inputLine); 
       in.close(); 
   } 
}

మీరు ఫైల్ పాత్‌ను పాస్ చేయడం ద్వారా ఫైల్ నుండి డేటాను చదవవచ్చు:

public class Main { 

   public static void main(String[] args) throws Exception { 

       FileInputStream fileInputStream = new FileInputStream("testFile.txt"); 
       BufferedReader reader = new BufferedReader(new InputStreamReader(fileInputStream)); 

       String str; 

       while ((str = reader.readLine()) != null)   { 
           System.out.println (str); 
       } 

       reader.close(); 
   } 
}

System.outని భర్తీ చేస్తోంది

ఇప్పుడు మనం ఇంతకు ముందు టచ్ చేయని ఆసక్తికరమైన సామర్థ్యాన్ని పరిశీలిద్దాం. మీరు ఖచ్చితంగా గుర్తుంచుకున్నట్లుగా, Systemతరగతికి రెండు స్టాటిక్ ఫీల్డ్‌లు ఉన్నాయి - System.inమరియు  System.out. ఈ కవల సోదరులు స్ట్రీమ్ వస్తువులు. System.inఒక InputStream. మరియు System.out ఒక PrintStream. ప్రస్తుతం, మేము గురించి మాట్లాడుతాము  System.out. మేము తరగతి యొక్క సోర్స్ కోడ్‌లోకి వెళితే System, మనకు ఇది కనిపిస్తుంది:

public final class System { 
……………... 
public final static PrintStream out = null; 
 ………… 
} 

అందువలన,  తరగతి System.out  యొక్క సాధారణ స్టాటిక్ వేరియబుల్System . ఇందులో మ్యాజిక్ ఏమీ లేదు :) outవేరియబుల్ ఒక PrintStreamసూచన. ఇక్కడ ఒక ఆసక్తికరమైన ప్రశ్న ఉంది: ఎప్పుడు System.out.println()అమలు చేయబడుతుంది, అవుట్‌పుట్ ఖచ్చితంగా కన్సోల్‌కి ఎందుకు వెళుతుంది మరియు మరెక్కడా కాదు? మరి దీన్ని ఎలాగైనా మార్చవచ్చా? ఉదాహరణకు, మనం కన్సోల్ నుండి డేటాను చదవాలనుకుంటున్నాము మరియు దానిని టెక్స్ట్ ఫైల్‌కు వ్రాయాలనుకుంటున్నాము. System.outఅదనపు రీడర్ మరియు రైటర్ క్లాస్‌లను ఉపయోగించకుండా దీన్ని ఎలాగైనా అమలు చేయడం సాధ్యమేనా  ? System.outనిజానికి, ఇది :) మరియు వేరియబుల్ మాడిఫైయర్‌తో గుర్తించబడినప్పటికీ మనం దీన్ని చేయగలము final!  కాబట్టి ఇది జరిగేలా మనం ఏమి చేయాలి? అన్నింటిలో మొదటిది, PrintStreamప్రస్తుత వస్తువును భర్తీ చేయడానికి మనకు కొత్త వస్తువు అవసరం. ప్రస్తుత వస్తువు, లో సెట్ చేయబడిందిSystemక్లాస్ డిఫాల్ట్‌గా, మా ప్రయోజనాలను అందించదు: ఇది కన్సోల్‌ను సూచిస్తుంది. మీరు టెక్స్ట్ ఫైల్‌ని సూచించే కొత్తదాన్ని సృష్టించాలి — మా డేటా కోసం "గమ్యం". రెండవది, వేరియబుల్‌కు కొత్త విలువను ఎలా కేటాయించాలో మనం అర్థం చేసుకోవాలి System.out. వేరియబుల్ గుర్తు పెట్టబడినందున మీరు సాధారణ అసైన్‌మెంట్ ఆపరేటర్‌ని ఉపయోగించలేరు final. చివరి నుండి వెనుకకు పని చేద్దాం. ఇది జరిగినప్పుడు, Systemతరగతి మనకు అవసరమైన పద్ధతిని కలిగి ఉంది: setOut(). ఇది ఒక వస్తువును తీసుకుంటుంది PrintStreamమరియు దానిని అవుట్‌పుట్ కోసం గమ్యస్థానంగా సెట్ చేస్తుంది. మనకు కావలసింది అదే! ఒక వస్తువును సృష్టించడం మాత్రమే మిగిలి ఉంది PrintStream. ఇది కూడా సులభం:

PrintStream filePrintStream = new PrintStream(new File("C:\\Users\\Username\\Desktop\\test.txt"));

పూర్తి కోడ్ ఇలా కనిపిస్తుంది:

public class SystemRedirectService { 

   public static void main(String arr[]) throws FileNotFoundException 
   { 
       PrintStream filePrintStream = new PrintStream(new File("C:\\Users\\Username\\Desktop\\test.txt"));
       /* Save the current value of System.out in a separate variable so that later 
       we can switch back to console output */ 

       PrintStream console = System.out; 
       // Assign a new value to System.out 
       System.setOut(filePrintStream); 
       System.out.println("This line will be written to the text file"); 

       // Restore the old value of System.out 
       System.setOut(console); 
       System.out.println("But this line will be output to the console!"); 
   } 
}

ఫలితంగా, మొదటి స్ట్రింగ్ టెక్స్ట్ ఫైల్‌కి వ్రాయబడుతుంది మరియు రెండవది కన్సోల్‌లో ప్రదర్శించబడుతుంది :) మీరు ఈ కోడ్‌ను మీ IDEలోకి కాపీ చేసి, దాన్ని అమలు చేయవచ్చు. టెక్స్ట్ ఫైల్‌ని తెరవండి మరియు అక్కడ స్ట్రింగ్ విజయవంతంగా వ్రాయబడిందని మీరు చూస్తారు :) దీనితో, మా పాఠం ముగింపుకు వచ్చింది. ఈ రోజు మనం స్ట్రీమ్‌లు మరియు రీడర్‌లతో ఎలా పని చేయాలో గుర్తుచేసుకున్నాము. అవి ఒకదానికొకటి ఎలా భిన్నంగా ఉన్నాయో మేము గుర్తుచేసుకున్నాము మరియు System.outమేము దాదాపు ప్రతి పాఠంలోనూ ఉపయోగించిన కొన్ని కొత్త సామర్థ్యాల గురించి తెలుసుకున్నాము :) తదుపరి పాఠాల వరకు!