బంధించిన ప్రవాహాలు

1. InputStreamReaderతరగతి

స్ట్రీమ్‌ల యొక్క మరొక ఆసక్తికరమైన లక్షణం ఏమిటంటే, మీరు బహుళ స్ట్రీమ్‌లను కలిపి గొలుసులుగా మార్చవచ్చు . ఒక స్ట్రీమ్ దాని అంతర్గత డేటా మూలం నుండి మాత్రమే కాకుండా మరొక స్ట్రీమ్ నుండి కూడా డేటాను చదవగలదు .

ఇది జావాలో చాలా శక్తివంతమైన మెకానిజం, ఇది ఒక స్ట్రీమ్‌ను మరొక స్ట్రీమ్‌కు కనెక్ట్ చేయడం ద్వారా సంక్లిష్ట డేటా రీడింగ్ దృశ్యాలను సృష్టించడం సాధ్యం చేస్తుంది. అటువంటి పథకం ఇలా కనిపిస్తుంది:

ప్రోగ్రామ్ డేటా స్ట్రీమ్ నుండి డేటాను చదివినప్పుడు, డేటా స్ట్రీమ్ దాని డేటా మూలం నుండి డేటాను రీడ్ చేస్తుంది, ఉదాహరణకు మరొక డేటా స్ట్రీమ్ లేదా ఫైల్.

ఇంకా ఏమిటంటే, ప్రతి డేటా స్ట్రీమ్ డేటాను చదవడం మరియు ఇవ్వడం మాత్రమే కాకుండా, దానిని మార్చగలదు లేదా దానిపై వివిధ కార్యకలాపాలను కూడా చేయగలదు. అటువంటి "ఇంటర్మీడియట్ స్ట్రీమ్"కి మంచి ఉదాహరణ తరగతి InputStreamReader.

మాకు ఇప్పటికే ఒక క్లాస్ అనే క్లాస్ తెలుసు FileReader— ఇది Readerఫైల్ నుండి డేటాను రీడ్ చేసేది. మరియు InputStreamReaderదాని డేటా ఎక్కడ నుండి వస్తుంది? అది నిజం — నుండి InputStream.

మీరు ఒక వస్తువును సృష్టించినప్పుడు , మీరు ఒక వస్తువు లేదా దాని సంతతి తరగతుల్లో ఒకదానిలో InputStreamReaderఉత్తీర్ణత సాధించాలి . InputStreamఉదాహరణ:

String src = "c:\\projects\\log.txt";
FileInputStream input = new FileInputStream(src);
InputStreamReader reader = new InputStreamReader(input);

తరగతి తరగతికి ఉన్న InputStreamReaderఅన్ని పద్ధతులను కలిగి ఉంది Readerమరియు అవి సరిగ్గా అదే విధంగా పని చేస్తాయి.

InputStreamReaderతరగతికి మరియు చెప్పడానికి మధ్య ప్రధాన వ్యత్యాసం FileReaderఏమిటంటే వారు డేటాను ఎక్కడ నుండి చదివారు. FileReaderఫైల్ నుండి డేటాను చదువుతుంది (duh — అందుకే దీనిని అంటారు FileReader), కానీ InputStreamReaderఒక నుండి డేటాను చదువుతుంది InputStream.

FileReaderమీరు పద్ధతిని ఉపయోగించి ఆబ్జెక్ట్ నుండి అక్షరాన్ని చదివినప్పుడు read(), అది డిస్క్‌లోని ఫైల్ నుండి రెండు బైట్‌లను రీడ్ చేస్తుంది మరియు వాటిని chars.

మీరు పద్ధతిని ఉపయోగించి ఒక InputStreamReaderవస్తువు నుండి అక్షరాన్ని చదివినప్పుడు, అది దానికి పంపబడిన వస్తువు read()నుండి రెండు బైట్‌లను చదువుతుంది , ఇది ఫైల్ నుండి డేటాను చదువుతుంది. FileInputStreamఫలితం పద్ధతులకు కాల్‌ల గొలుసుread() .

2. BufferedReaderతరగతి

మీరు ఎక్కువగా ఉపయోగించగల మరొక ఆసక్తికరమైన తరగతి BufferedReader. ఇది మరొక స్ట్రీమ్ నుండి డేటాను చదివే "ఇంటర్మీడియట్ స్ట్రీమ్" కూడా.

దాని పేరు సూచించినట్లుగా, BufferedReaderతరగతి ఉపవర్గం Readerమరియు మీరు అక్షరాలను చదవడానికి అనుమతిస్తుంది . కానీ చాలా ఆసక్తికరమైన విషయం ఏమిటంటే, మీరు అక్షరాలు చదవగలిగే స్ట్రీమ్ రూపంలో డేటా మూలాన్ని కూడా పాస్ చేయాలి , అంటే తరగతిని వారసత్వంగా పొందే స్ట్రీమ్ Reader.

విషయం ఏంటి? కాకుండా InputStreamReader, BufferedReaderతరగతి బైట్‌లను అక్షరాలుగా మార్చదు: ఇది దేనినీ మార్చదు. బదులుగా, ఇది డేటాను బఫర్ చేస్తుంది .

ప్రోగ్రామ్ ఒక వస్తువు నుండి ఒకే అక్షరాన్ని చదివినప్పుడు BufferedReader, ఆ వస్తువు దాని మూలం స్ట్రీమ్ నుండి ఒకేసారి పెద్ద సంఖ్యలో అక్షరాలను చదువుతుంది. మరియు వాటిని అంతర్గతంగా నిల్వ చేస్తుంది.

ఆబ్జెక్ట్ నుండి తదుపరి అక్షరం చదవబడినప్పుడు BufferedReader, అది దాని అంతర్గత బఫర్ శ్రేణి నుండి తదుపరి అక్షరాన్ని పట్టుకుని డేటా మూలాన్ని యాక్సెస్ చేయకుండా దాన్ని తిరిగి ఇస్తుంది. బఫర్‌లోని అన్ని అక్షరాలు ఉపయోగించబడినప్పుడు మాత్రమే అది మరొక పెద్ద శ్రేణి అక్షరాలలో చదవబడుతుంది.

తరగతి BufferedReaderచాలా ఉపయోగకరమైన పద్ధతిని కూడా కలిగి ఉంది — String readLine(), ఇది సోర్స్ స్ట్రీమ్ నుండి డేటా యొక్క మొత్తం స్ట్రింగ్‌లను ఒకేసారి చదవడానికి మిమ్మల్ని అనుమతిస్తుంది. మీరు ఫైల్‌ను చదవడానికి మరియు దాని కంటెంట్‌లను లైన్ ద్వారా స్క్రీన్‌పై ప్రదర్శించడానికి ఈ పద్ధతిని ఉపయోగించవచ్చు. ఉదాహరణ:

ఇది ఎంత సౌకర్యవంతంగా ఉంటుందో వివరించడానికి మేము ప్రత్యేకంగా కొన్ని కాంపాక్ట్ కోడ్‌ని వ్రాసాము. ఈ కోడ్‌ను కొంచెం వివరంగా కూడా వ్రాయవచ్చు.

String src = "c:\\projects\\log.txt";

try(FileReader in = new FileReader(src);
BufferedReader reader = new BufferedReader(in))
{
   while (reader.ready())
   {
      String line = reader.readLine();
      System.out.println(line);
   }
}

3. కన్సోల్ నుండి చదవడం

మరియు మరొక ఆసక్తికరమైన విషయం: Scannerతరగతి అనేది డేటా స్ట్రీమ్ అయిన నుండి డేటాను చదివే ఇంటర్మీడియట్ ఇన్‌పుట్ స్ట్రీమ్ తప్ప మరేమీ కాదు System.in.

కన్సోల్ నుండి పంక్తిని చదవడానికి ఇక్కడ రెండు మార్గాలు ఉన్నాయి:

InputStream stream = System.in;
Scanner console = new Scanner(stream);
String line = console.nextLine();

InputStream stream = System.in;
InputStreamReader reader = new InputStreamReader(stream);
BufferedReader buff = new BufferedReader(reader);
String line = buff.readLine();

మా స్నేహితుడు తరగతి యొక్క స్టాటిక్ వేరియబుల్ తప్ప మరేమీ కాదు . ఇది దీని పేరు .System.ininSystemInputStreamin

కాబట్టి కోడ్‌జిమ్‌పై మీ జావా అధ్యయనాల ప్రారంభం నుండి, మీరు డేటా స్ట్రీమ్‌లతో పని చేస్తున్నారు మరియు వాటి నుండి గొలుసులను నిర్మించారు. కానీ ఇప్పుడు మీరు దీన్ని మరింత స్పృహతో చేస్తారు.