కీబోర్డ్ నుండి చదవడం: "పాఠకులు"

హాయ్! లెవెల్ 3లోని పాఠాలు మరియు టాస్క్‌లు కన్సోల్‌లో అంశాలను ఎలా ప్రదర్శించాలో మరియు ఇతర దిశలో కదలడం, కీబోర్డ్ నుండి డేటాను ఎలా చదవాలో నేర్పించాయి. మీరు దీన్ని సాధించడానికి క్రింది సంక్లిష్ట నిర్మాణాన్ని ఉపయోగించడం నేర్చుకున్నారు:

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

కానీ మేము ఇంకా సమాధానం ఇవ్వని ప్రశ్న ఒకటి ఉంది.

ప్రపంచంలో ఇది ఎలా పని చేస్తుంది?

వాస్తవానికి, కార్యక్రమాలు చాలా అరుదుగా పూర్తిగా స్వతంత్రంగా ఉంటాయి. వారు ఇతర ప్రోగ్రామ్‌లు, సిస్టమ్‌లు, ఇంటర్నెట్ మొదలైన వాటితో కమ్యూనికేట్ చేస్తారు. "కమ్యూనికేట్" అంటే, మేము ప్రధానంగా "డేటా మార్పిడి" అని అర్థం. అంటే, వారు కొంత బాహ్య డేటాను స్వీకరిస్తారు మరియు అంతర్గత ప్రోగ్రామ్ డేటాను ఎక్కడో పంపుతారు. రోజువారీ జీవితంలో డేటాను మార్పిడి చేసే ప్రోగ్రామ్‌ల ఉదాహరణలు పుష్కలంగా ఉన్నాయి. ఉదాహరణకు, అనేక వెబ్‌సైట్‌లు నమోదు చేసుకోవడానికి బదులుగా మీ Facebook లేదా Twitter ఖాతాను ఉపయోగించి సైన్ ఇన్ చేయడానికి మిమ్మల్ని అనుమతిస్తాయి. ఈ పరిస్థితిలో, రెండు ప్రోగ్రామ్‌లు (ఉదా. Twitter మరియు మీరు సైన్ ఇన్ చేస్తున్న వెబ్‌సైట్) అవసరమైన డేటాను మార్పిడి చేసుకుంటాయి. అంతిమ ఫలితం ఏమిటంటే మీరు విజయవంతంగా సైన్ ఇన్ చేసారు. "స్ట్రీమ్" అనే పదండేటా మార్పిడి ప్రక్రియను వివరించడానికి ఉపయోగించబడుతుంది. ఈ పేరు ఎక్కడ నుండి వచ్చింది? మీ అనుభవంలో, "స్ట్రీమ్" అనేది నదులతో మరియు ప్రోగ్రామింగ్‌తో కాకుండా ఎక్కువగా అనుబంధించబడి ఉండవచ్చు. అది ప్రమాదమేమీ కాదు :) స్ట్రీమ్ అనేది సారాంశంలో, కదిలే డేటా. మరో మాటలో చెప్పాలంటే, ప్రోగ్రామింగ్‌లో, ప్రవహించేది నీరు కాదు - బైట్‌లు మరియు అక్షరాల రూపంలో డేటా. మేము డేటా స్ట్రీమ్ నుండి డేటా బిట్‌లను స్వీకరించి, ఆపై వాటిని ఉపయోగించవచ్చు. మళ్ళీ, మేము నీరు/ప్రవాహ సారూప్యతను ఉపయోగిస్తాము: మీరు సూప్ చేయడానికి, మంటలను ఆర్పడానికి లేదా మీ పువ్వులకు నీరు పెట్టడానికి నది నుండి నీటిని తీయవచ్చు. స్ట్రీమ్‌లు ఏదైనా డేటా సోర్స్‌తో పని చేయడానికి మిమ్మల్ని అనుమతిస్తాయి: ఇంటర్నెట్, మీ కంప్యూటర్ యొక్క ఫైల్ సిస్టమ్ లేదా మరేదైనా - దీనికి ఎటువంటి తేడా లేదు. స్ట్రీమ్‌లు సార్వత్రిక సాధనం. వారు ప్రోగ్రామ్‌ను ఎక్కడి నుండైనా (ఇన్‌పుట్ స్ట్రీమ్‌లు) స్వీకరించడానికి మరియు ఎక్కడికైనా పంపడానికి (అవుట్‌పుట్ స్ట్రీమ్‌లు) అనుమతిస్తారు. వారి పని ఒకటే: ఒక ప్రదేశం నుండి డేటాను తీసుకొని మరొక ప్రదేశానికి పంపడం. రెండు రకాల ప్రవాహాలు ఉన్నాయి:

1. డేటాను స్వీకరించడానికి ఇన్‌పుట్ స్ట్రీమ్‌లు ఉపయోగించబడతాయి
2. అవుట్‌పుట్ స్ట్రీమ్‌లు డేటాను పంపడం కోసం.

జావాలో, ఈ స్ట్రీమ్‌లు InputStreamమరియు OutputStreamతరగతుల ద్వారా అమలు చేయబడతాయి. కానీ ప్రవాహాలను మరొక విధంగా వర్గీకరించవచ్చు. ఇన్‌పుట్ మరియు అవుట్‌పుట్ స్ట్రీమ్‌లతో పాటు, మేము బైట్ స్ట్రీమ్‌లు మరియు క్యారెక్టర్ స్ట్రీమ్‌ల గురించి కూడా మాట్లాడతాము . ఇక్కడ అర్థం తగినంత స్పష్టంగా ఉండాలి: బైట్ స్ట్రీమ్ సమాచారాన్ని బైట్‌ల సెట్‌గా పంపుతుంది, అయితే క్యారెక్టర్ స్ట్రీమ్ దానిని అక్షరాల సెట్‌గా పంపుతుంది. ఈ పాఠంలో, మేము ఇన్‌పుట్ స్ట్రీమ్‌లపై నివసిస్తాము. నేను పాఠం చివరలో అవుట్‌పుట్ స్ట్రీమ్‌ల గురించి సమాచారంతో లింక్‌ను ఉంచుతాను. మీరు దీన్ని మీ స్వంతంగా చదవవచ్చు :) ఇప్పుడు ఈ కోడ్‌ను చూడండి:

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

పాఠాలు చదువుతున్నప్పుడు, ఈ లైన్ చాలా భయానకంగా ఉందని మీరు అనుకోలేదా? :) ఇది ఎలా పని చేస్తుందో ఒకసారి మేము అన్వేషించిన తర్వాత అలా జరగదు. విషయాలను సరిగ్గా ఉంచుదాం. మేము చివరిలో ప్రారంభిస్తాము. System.inఅనేది ఒక InputStreamవస్తువు, మేము ముందుగా మాట్లాడిన తరగతికి ఉదాహరణ. ఇది సిస్టమ్ ఇన్‌పుట్ పరికరానికి (కీబోర్డ్) లింక్ చేయబడిన ఇన్‌పుట్ స్ట్రీమ్. మార్గం ద్వారా, మీరు ఈ స్ట్రీమ్‌తో పరోక్షంగా సుపరిచితులు. అన్నింటికంటే, మీరు దాని "సహోద్యోగి"ని తరచుగా ఉపయోగిస్తారు — System.out! System.outసిస్టమ్ అవుట్‌పుట్ స్ట్రీమ్. ఇది మీకు ఇష్టమైన పద్ధతి ద్వారా కన్సోల్‌కు డేటాను అవుట్‌పుట్ చేయడానికి ఉపయోగించబడుతుంది System.out.println(), మీరు నిరంతరం ఉపయోగించే :) System.outఇది కన్సోల్‌కి డేటాను పంపడానికి ఒక స్ట్రీమ్, అయితేSystem.inకీబోర్డ్ నుండి డేటాను పొందడం కోసం. ఇదంతా చాలా సులభం :) అంతేకాదు, ఈ భారీ నిర్మాణం లేకుండానే మనం కీబోర్డ్ నుండి డేటాను చదవవచ్చు. మేము కేవలం వ్రాయవచ్చు: System.in.read();

public class Main {

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

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

తరగతి InputStream(గుర్తుంచుకోండి, System.inఒక InputStreamవస్తువు) read()డేటాను చదవడానికి మిమ్మల్ని అనుమతించే పద్ధతిని కలిగి ఉంది. ఒక సమస్య ఉంది: ఇది బైట్‌లను చదువుతుంది, అక్షరాలు కాదు . ఇంగ్లీషు అక్షరాలను మాత్రమే ఉపయోగించడం బోరింగ్‌గా ఉంది కాబట్టి కీబోర్డ్ నుండి చైనీస్ అక్షరం "魚" చదవడానికి ప్రయత్నిద్దాం (ఈ లేఖను ఇక్కడి నుండి కాపీ చేసి, PCలో ctrl + v లేదా Macలో కమాండ్ + v ఉపయోగించి కన్సోల్‌లో అతికించండి ). ఈ పాత్రకు 'ఒక చేప' అని అర్థం. కన్సోల్ అవుట్‌పుట్: 魚 233 173 154 10 ఈ గుర్తు మరియు అనేక ఇతర చైనీస్ కంప్యూటర్ మెమరీలో 3 బైట్‌లను ఆక్రమిస్తాయి (లాటిన్ అక్షరాల వలె కాకుండా, ఇది కేవలం 1 బైట్‌ను మాత్రమే ఆక్రమిస్తుంది). ఈ సందర్భంలో, స్ట్రీమ్ నుండి 4 బైట్‌లు చదవబడతాయి: మొదటి మూడు "魚" అక్షరాన్ని సూచిస్తాయి మరియు ఇతర బైట్ కొత్త లైన్‌ను సూచిస్తుంది (Enter). దీని ప్రకారం, System.inదాని అలంకరించని రూపంలో మాకు ఒక ఎంపిక కాదు. మానవులకు (అరుదైన మినహాయింపులతో!) బైట్‌లను ఎలా చదవాలో తెలియదు. కానీ InputStreamReaderతరగతి రక్షించటానికి వస్తుంది! ఇది ఎలాంటి జంతువు అని చూద్దాం.

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

మేము System.inInputStreamReader ఆబ్జెక్ట్‌కు వెళతాము . తరగతి పేరు చెబుతుంది! మేము ఒక InputStreamReaderఆబ్జెక్ట్‌ని సృష్టించి, దాని నుండి డేటాను చదివే ఇన్‌పుట్ స్ట్రీమ్‌ను పాస్ చేస్తాము. ఈ విషయంలో...

new InputStreamReader(System.in)

...మేము దానికి, "మీరు సిస్టమ్ ఇన్‌పుట్ స్ట్రీమ్ (కీబోర్డ్ నుండి) నుండి డేటాను చదువుతారు" అని చెబుతాము. కానీ ఇది దాని ఏకైక పని కాదు! InputStreamReaderస్ట్రీమ్ నుండి డేటాను మాత్రమే స్వీకరించదు . ఇది బైట్ స్ట్రీమ్‌లను క్యారెక్టర్ స్ట్రీమ్‌లుగా కూడా మారుస్తుంది . మరో మాటలో చెప్పాలంటే, మీరు ఇకపై డేటాను "ఒకటి మరియు సున్నాలు" నుండి "మానవుడు చదవగలిగే భాష"గా మార్చాల్సిన అవసరం లేదు. InputStreamreaderమీ కోసం ప్రతిదీ చేస్తుంది. వాస్తవానికి, InputStreamReaderకన్సోల్ నుండి డేటాను చదవడానికి మాత్రమే పరిమితం కాదు. ఇది ఇతర ప్రదేశాల నుండి కూడా డేటాను చదవగలదు. ఉదాహరణకు, ఫైల్ నుండి:

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

   public static void main(String[] args) throws IOException {
       InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("C:\\Users\\username\\Desktop\\testFile.txt"));
   }
}

FileInputStreamఇక్కడ మనం ఒక (ఒక ఫ్లేవర్‌ని ) సృష్టిస్తాము InputStream, ఫైల్ పాత్‌లో పాస్ చేస్తాము మరియు స్ట్రీమ్‌ను దానికి పాస్ చేస్తాము InputStreamReader. ఇప్పుడు అది ఫైల్ నుండి డేటాను చదవగలదు (ఒక ఫైల్ వాస్తవానికి మార్గంలో ఉన్నట్లయితే, వాస్తవానికి). మేము డేటాను చదవడానికి InputStreamReaderతరగతి పద్ధతిని కూడా ఉపయోగిస్తాము (డేటా యొక్క మూలం పట్టింపు లేదు: కన్సోల్, ఫైల్ లేదా మరెక్కడైనా). మరియు read()మధ్య తేడా ఏమిటి ?\ "魚" అక్షరాన్ని ఒక తో చదవడానికి మళ్లీ ప్రయత్నిద్దాం . నేను నిజంగా చదివిన వాటిని మీకు గుర్తు చేస్తున్నాను : 魚 233 173 154 10 మరియు అదే పని ఎలా చేస్తుంది? System.in.read()InputStreamReader.read()InputStreamReaderSystem.in.read()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);
       }
   }
}

కన్సోల్ అవుట్‌పుట్: 魚 39770 10 తేడా వెంటనే స్పష్టంగా కనిపిస్తుంది. చివరి బైట్ (కొత్త పంక్తికి ప్రాతినిధ్యం వహిస్తుంది) మారదు (సంఖ్య 10), కానీ "魚" అక్షరం "39770" ఒకే కోడ్‌గా మార్చబడింది. అక్షరాలు చదవడం అంటే ఇదే! 39770 "魚" అనే అక్షరాన్ని సూచిస్తుందని మీరు నమ్మకపోతే, మిమ్మల్ని మీరు ఒప్పించడం సులభం :)

import java.io.IOException;

public class Main {

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

       char x = 39770;
       System.out.println(x);
   }
}

కన్సోల్ అవుట్‌పుట్: 魚 అయితే InputStreamReaderచాలా గొప్పగా ఉంటే, మనకు కూడా ఎందుకు అవసరం BufferedReader? InputStreamReaderడేటాను చదవడం మరియు బైట్‌లను అక్షరాలుగా మార్చడం ఎలాగో తెలుసు. ఇంతకంటే మనం ఏమి అడగగలం? మరొక రీడర్ ఎందుకు? :/ సమాధానం చాలా సులభం: ఎక్కువ పనితీరు మరియు సౌలభ్యం కోసం . పనితీరుతో ప్రారంభిద్దాం. డేటాను చదివినప్పుడు BufferedReader, ఇది బఫర్ అని పిలువబడే ప్రత్యేక ప్రాంతాన్ని ఉపయోగిస్తుంది, ఇక్కడ అది చదివిన అక్షరాలను "నిల్వ చేస్తుంది". అంతిమంగా, ప్రోగ్రామ్‌లో ఈ అక్షరాలు అవసరమైనప్పుడు, అవి నేరుగా డేటా సోర్స్ (కీబోర్డ్, ఫైల్ మొదలైనవి) నుండి కాకుండా బఫర్ నుండి తీసుకోబడతాయి. ఇది చాలా వనరులను ఆదా చేస్తుంది. ఇది ఎలా పని చేస్తుందో అర్థం చేసుకోవడానికి, ఒక పెద్ద కంపెనీలో కొరియర్ను ఊహించుకోండి. కొరియర్ ఒక కార్యాలయంలో కూర్చుని, ఎవరైనా డెలివరీ కోసం ప్యాకేజీలను తీసుకురావడానికి వేచి ఉన్నారు. అతను కొత్త ప్యాకేజీని అందుకున్న ప్రతిసారీ, అతను వెంటనే రోడ్డుపైకి వస్తాడు. కానీ రోజులో చాలా ప్యాకేజీలు ఉండవచ్చు. అతను ఆఫీసు మరియు డెలివరీ చిరునామాల మధ్య చాలా పర్యటనలు చేయాల్సి ఉంటుంది. బదులుగా, కొరియర్ తన కార్యాలయంలో ఒక పెట్టెను ఉంచాడు. ప్రతి ఒక్కరూ తమ ప్యాకేజీలను పెట్టెలో ఉంచుతారు. ఇప్పుడు కొరియర్ ప్రశాంతంగా పెట్టెను తీసుకొని చిరునామా నుండి చిరునామాకు తరలించవచ్చు. ఇది చాలా సమయాన్ని ఆదా చేస్తుంది, ఎందుకంటే అతను ప్రతిసారీ కార్యాలయానికి తిరిగి వెళ్లవలసిన అవసరం లేదు. ఈ ఉదాహరణలో, పెట్టె కేవలం బఫర్, మరియు ఆఫీస్ అనేది డేటా సోర్స్. ప్రతిసారీ కార్యాలయానికి తిరిగి వెళ్లడం కంటే డెలివరీలు చేసేటప్పుడు ఒకే పెట్టె నుండి ప్యాకేజీలను తీసుకోవడం కొరియర్‌కు చాలా సులభం. అతను గ్యాసోలిన్ కూడా ఆదా చేస్తాడు. అదేవిధంగా, ఒక ప్రోగ్రామ్‌లో ప్రతిసారీ డేటా సోర్స్‌ని సూచించడం కంటే బఫర్ నుండి డేటాను తీసుకోవడం చాలా తక్కువ వనరు-ఇంటెన్సివ్. ఫలితంగా,BufferedReader+ ఒంటరిగా InputStreamReaderకంటే వేగంగా ఉంటుందిInputStreamReader . మేము పనితీరును పరిగణించాము. సౌలభ్యం గురించి ఏమిటి? ప్రధాన ప్రయోజనం ఏమిటంటే, Bufferedreaderడేటాను ఒకేసారి ఒక అక్షరం మాత్రమే కాకుండా (ఇది దాని పద్ధతితో దీన్ని చేయగలదు read()), కానీ ఒకేసారి మొత్తం పంక్తులను కూడా చదవగలదు! ఇది పద్ధతిని ఉపయోగించి చేయబడుతుంది 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("We read this line from the keyboard:");
       System.out.println(s);
   }
}

కన్సోల్ అవుట్‌పుట్: జావా నేర్చుకోవడానికి కోడ్‌జిమ్ ఉత్తమ వెబ్‌సైట్! మేము కీబోర్డ్ నుండి ఈ పంక్తిని చదువుతాము: జావా నేర్చుకోవడానికి కోడ్‌జిమ్ ఉత్తమ వెబ్‌సైట్! పెద్ద మొత్తంలో డేటాను చదివేటప్పుడు ఇది ప్రత్యేకంగా ఉపయోగపడుతుంది. అక్షరం వారీగా వచన అక్షరం యొక్క ఒకటి లేదా రెండు పంక్తులను చదవడం ఇప్పటికీ సాధ్యమే. కానీ "వార్ అండ్ పీస్"లో ఒక అక్షరం చదవడం కొంత సమస్యాత్మకంగా ఉంటుంది :)