డేటా ఇన్‌పుట్ కోసం స్ట్రీమ్‌లు

1. డేటా స్ట్రీమ్‌లు

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

మేము ఈ ప్రవర్తనలన్నింటినీ ఒకే పదంలో సూచించవచ్చు: ప్రోగ్రామ్ మరియు బయటి ప్రపంచం మధ్య డేటా మార్పిడి . ఆగండి, అది ఒక్క మాట కాదు.

వాస్తవానికి, డేటా మార్పిడిని రెండు భాగాలుగా విభజించవచ్చు: డేటాను స్వీకరించడం మరియు డేటాను పంపడం. ఉదాహరణకు, మీరు Scannerఆబ్జెక్ట్‌ని ఉపయోగించి కీబోర్డ్ నుండి డేటాను చదువుతారు - ఇది డేటాను స్వీకరిస్తుంది. మరియు మీరు ఆదేశాన్ని ఉపయోగించి స్క్రీన్‌పై డేటాను ప్రదర్శిస్తారు System.out.println()- ఇది డేటాను పంపుతోంది.

ప్రోగ్రామింగ్‌లో, డేటా మార్పిడిని వివరించడానికి "స్ట్రీమ్" అనే పదాన్ని ఉపయోగిస్తారు. ఆ పదం ఎక్కడ నుండి వచ్చింది?

నిజ జీవితంలో, మీరు నీటి ప్రవాహం లేదా స్పృహ ప్రవాహం కలిగి ఉండవచ్చు. ప్రోగ్రామింగ్‌లో, మాకు డేటా స్ట్రీమ్‌లు ఉన్నాయి .

స్ట్రీమ్‌లు బహుముఖ సాధనం. అవి ప్రోగ్రామ్‌ను ఎక్కడి నుండైనా (ఇన్‌పుట్ స్ట్రీమ్‌లు) స్వీకరించడానికి మరియు డేటాను ఎక్కడికైనా పంపడానికి (అవుట్‌పుట్ స్ట్రీమ్‌లు) అనుమతిస్తాయి. అందువలన, రెండు రకాలు ఉన్నాయి:

• ఇన్‌పుట్ స్ట్రీమ్ అనేది డేటాను స్వీకరించడం కోసం
• అవుట్‌పుట్ స్ట్రీమ్ అనేది డేటాను పంపడం కోసం

స్ట్రీమ్‌లను 'స్పష్టంగా' చేయడానికి, జావా సృష్టికర్తలు రెండు తరగతులను వ్రాశారు: InputStreamమరియు OutputStream.

తరగతి దాని నుండి డేటాను చదవడానికి మిమ్మల్ని అనుమతించే పద్ధతిని InputStreamకలిగి ఉంది . read()మరియు తరగతికి డేటాను వ్రాయడానికి మిమ్మల్ని అనుమతించే పద్ధతి OutputStreamఉంది . write()వారు ఇతర పద్ధతులను కూడా కలిగి ఉన్నారు, కానీ దాని గురించి మరింత తర్వాత.

బైట్ స్ట్రీమ్‌లు

మేము ఎలాంటి డేటా గురించి మాట్లాడుతున్నాము? ఇది ఏ ఆకృతిని తీసుకుంటుంది? మరో మాటలో చెప్పాలంటే, ఈ తరగతులు ఏ డేటా రకాలకు మద్దతు ఇస్తాయి?

ఇవి సాధారణ తరగతులు, కాబట్టి అవి అత్యంత సాధారణ డేటా రకానికి మద్దతు ఇస్తాయి - ది byte. ఒక OutputStreamబైట్‌లను (మరియు బైట్ శ్రేణులు) వ్రాయగలదు మరియు ఒక InputStreamవస్తువు బైట్‌లను (లేదా బైట్ శ్రేణులు) చదవగలదు. అంతే — అవి ఏ ఇతర డేటా రకాలకు మద్దతు ఇవ్వవు.

ఫలితంగా, ఈ స్ట్రీమ్‌లను బైట్ స్ట్రీమ్‌లు అని కూడా పిలుస్తారు .

స్ట్రీమ్‌ల యొక్క ఒక లక్షణం ఏమిటంటే, వాటి డేటాను వరుసగా మాత్రమే చదవగలరు (లేదా వ్రాయగలరు). మీరు స్ట్రీమ్ మధ్యలో ఉన్న డేటాను దాని ముందు వచ్చే మొత్తం డేటాను చదవకుండా చదవలేరు.

ఈ విధంగా కీబోర్డ్ నుండి డేటాను చదవడం తరగతి ద్వారా పని చేస్తుంది Scanner: మీరు కీబోర్డ్ నుండి డేటాను వరుసగా లైన్ వారీగా చదువుతారు. మేము ఒక పంక్తిని చదువుతాము, తరువాతి పంక్తి, తరువాతి పంక్తి, మరియు మొదలైనవి. సముచితంగా, పంక్తులను చదివే పద్ధతిని అంటారు nextLine().

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

అక్షర ప్రవాహాలు

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

ఈ వాస్తవం కోసం, జావా ప్రోగ్రామర్లు మరో రెండు తరగతులను రాశారు: Readerమరియు Writer. తరగతి Readerతరగతికి సారూప్యంగా ఉంటుంది InputStream, కానీ దాని read()పద్ధతి బైట్‌లు కాదు, అక్షరాలు ( char). తరగతి Writerతరగతికి అనుగుణంగా ఉంటుంది OutputStream. మరియు తరగతి వలె Reader, ఇది అక్షరాలతో పనిచేస్తుంది ( char), బైట్‌లతో కాదు.

మేము ఈ నాలుగు తరగతులను పోల్చినట్లయితే, మేము ఈ క్రింది చిత్రాన్ని పొందుతాము:

InputStream

Reader

OutputStream

Writer

ప్రాక్టికల్ అప్లికేషన్

, , మరియు తరగతులు ఎవరికీ నేరుగా ఉపయోగించబడవు, ఎందుకంటే అవి డేటాను చదవగలిగే (లేదా డేటాను వ్రాయగల) నిర్దిష్ట వస్తువులతో అనుబంధించబడవు InputStream. కానీ ఈ నాలుగు తరగతులు చాలా చేయగలిగిన సంతతి తరగతులు పుష్కలంగా ఉన్నాయి.OutputStreamReaderWriter

2. InputStreamతరగతి

InputStreamవందలాది సంతతి తరగతులకు మాతృ తరగతి అయినందున తరగతి ఆసక్తికరంగా ఉంది . దీనికి దాని స్వంత డేటా ఏదీ లేదు, కానీ దాని ఉత్పన్నమైన తరగతులన్నీ వారసత్వంగా పొందే పద్ధతులను కలిగి ఉంది.

సాధారణంగా, స్ట్రీమ్ ఆబ్జెక్ట్‌లు డేటాను అంతర్గతంగా నిల్వ చేయడం చాలా అరుదు. స్ట్రీమ్ అనేది డేటాను చదవడానికి/వ్రాయడానికి ఒక సాధనం, కానీ నిల్వ కాదు. మినహాయింపులు ఉన్నాయని పేర్కొంది.

తరగతి యొక్క పద్ధతులు InputStreamమరియు దాని అన్ని వారసుల తరగతులు:

int read()

int read(byte[] buffer)

byte[] readAllBytes()

long skip(long n)

int available()

void close()

ఈ పద్ధతుల ద్వారా క్లుప్తంగా వెళ్దాం:

read()పద్ధతి

మెథడ్ స్ట్రీమ్ నుండి ఒక బైట్read() చదివి దాన్ని తిరిగి అందిస్తుంది. మీరు తిరిగి వచ్చే రకం ద్వారా గందరగోళానికి గురవుతారు . ప్రామాణిక పూర్ణాంకం రకం కాబట్టి ఈ రకం ఎంచుకోబడింది . యొక్క మొదటి మూడు బైట్‌లు సున్నాగా ఉంటాయి.intintint

read(byte[] buffer)పద్ధతి

ఇది read()పద్ధతి యొక్క రెండవ రూపాంతరం. InputStreamఇది ఒకేసారి బైట్ శ్రేణిని చదవడానికి మిమ్మల్ని అనుమతిస్తుంది . బైట్‌లను నిల్వ చేసే శ్రేణిని తప్పనిసరిగా ఆర్గ్యుమెంట్‌గా పాస్ చేయాలి. పద్ధతి ఒక సంఖ్యను అందిస్తుంది — వాస్తవానికి చదివిన బైట్‌ల సంఖ్య.

మీరు 10 కిలోబైట్ బఫర్‌ని కలిగి ఉన్నారని మరియు మీరు తరగతిని ఉపయోగించి ఫైల్ నుండి డేటాను చదువుతున్నారని అనుకుందాం FileInputStream. ఫైల్ 2 కిలోబైట్‌లను మాత్రమే కలిగి ఉంటే, మొత్తం డేటా బఫర్ శ్రేణిలోకి లోడ్ చేయబడుతుంది మరియు పద్ధతి 2048 (2 కిలోబైట్‌లు) సంఖ్యను అందిస్తుంది.

readAllBytes()పద్ధతి

చాలా మంచి పద్ధతి. ఇది అయిపోయే వరకు మొత్తం డేటాను చదివి InputStreamఒకే బైట్ శ్రేణిగా తిరిగి ఇస్తుంది. చిన్న ఫైళ్లను చదవడానికి ఇది చాలా సులభం. పెద్ద ఫైల్‌లు మెమొరీలో భౌతికంగా సరిపోకపోవచ్చు మరియు ఈ పద్ధతి మినహాయింపును ఇస్తుంది.

skip(long n)పద్ధతి

ఈ పద్ధతి ఆబ్జెక్ట్ నుండి మొదటి n బైట్‌లను దాటవేయడానికి మిమ్మల్ని అనుమతిస్తుంది InputStream. డేటా ఖచ్చితంగా సీక్వెన్షియల్‌గా చదవబడినందున, ఈ పద్ధతి కేవలం స్ట్రీమ్ నుండి మొదటి n బైట్‌లను చదివి వాటిని విస్మరిస్తుంది.

వాస్తవానికి దాటవేయబడిన బైట్‌ల సంఖ్యను చూపుతుంది (ఒకవేళ nబైట్‌లను దాటవేయడానికి ముందు స్ట్రీమ్ ముగిసిపోయినట్లయితే).

int available()పద్ధతి

ఈ పద్ధతి ఇప్పటికీ స్ట్రీమ్‌లో మిగిలి ఉన్న బైట్‌ల సంఖ్యను అందిస్తుంది

void close()పద్ధతి

పద్ధతి close()డేటా స్ట్రీమ్‌ను మూసివేస్తుంది మరియు దానితో అనుబంధించబడిన బాహ్య వనరులను విడుదల చేస్తుంది. ఒక స్ట్రీమ్ మూసివేయబడిన తర్వాత, దాని నుండి ఎక్కువ డేటా చదవబడదు.

చాలా పెద్ద ఫైల్‌ను కాపీ చేసే ఉదాహరణ ప్రోగ్రామ్‌ను వ్రాద్దాం. readAllBytes()మొత్తం ఫైల్‌ను మెమరీలోకి చదవడానికి మేము పద్ధతిని ఉపయోగించలేము . ఉదాహరణ:

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

try(FileInputStream input = new FileInputStream(src);
FileOutputStream output = new FileOutputStream(dest))
{
   byte[] buffer = new byte[65536]; // 64Kb
   while (input.available() > 0)
   {
      int real = input.read(buffer);
      output.write(buffer, 0, real);
   }
}

ఈ ఉదాహరణలో, మేము రెండు తరగతులను ఉపయోగించాము: FileInputStreamఇది InputStreamఫైల్ నుండి డేటాను చదవడానికి మరియు ఫైల్‌కి డేటాను వ్రాయడానికి FileOutputStreamసంబంధించిన వారసుల నుండి వచ్చినది . OutputStreamమేము రెండవ తరగతి గురించి కొంచెం తరువాత మాట్లాడుతాము.

ఇక్కడ మరొక ఆసక్తికరమైన అంశం వేరియబుల్ real. ఫైల్ నుండి డేటా యొక్క చివరి బ్లాక్ రీడ్ అయినప్పుడు, అది సులభంగా 64KB కంటే తక్కువ డేటాను కలిగి ఉంటుంది. దీని ప్రకారం, మేము మొత్తం బఫర్‌ను కాకుండా, దానిలో కొంత భాగాన్ని మాత్రమే అవుట్‌పుట్ చేయాలి - మొదటి realబైట్‌లు. పద్ధతిలో సరిగ్గా ఇదే జరుగుతుంది write().

3. Readerతరగతి

తరగతి Readerతరగతి యొక్క పూర్తి అనలాగ్ InputStream. ఒకే ఒక్క తేడా ఏమిటంటే ఇది charబైట్‌లతో కాకుండా అక్షరాలతో ( ) పనిచేస్తుంది. తరగతి వలె InputStream, Readerతరగతి కూడా దాని స్వంతంగా ఎక్కడా ఉపయోగించబడదు: ఇది వందలాది సంతతి తరగతులకు మాతృ తరగతి మరియు వాటన్నింటికీ సాధారణ పద్ధతులను నిర్వచిస్తుంది.

తరగతి యొక్క పద్ధతులు Reader(మరియు దాని అన్ని వారసుల తరగతులు):

int read()

int read(char[] buffer)

long skip(long n)

boolean ready()

void close()

పద్ధతులు తరగతికి చాలా పోలి ఉంటాయి InputStream, అయితే స్వల్ప తేడాలు ఉన్నాయి.

int read()పద్ధతి

ఈ పద్ధతి charస్ట్రీమ్ నుండి ఒకదాన్ని చదివి, దాన్ని తిరిగి ఇస్తుంది. రకం charఒక కు విస్తరిస్తుంది int, కానీ ఫలితం యొక్క మొదటి రెండు బైట్‌లు ఎల్లప్పుడూ సున్నాగా ఉంటాయి.

int read(char[] buffer)పద్ధతి

ఇది read()పద్ధతి యొక్క రెండవ రూపాంతరం. Readerఇది ఒకేసారి చార్ శ్రేణిని చదవడానికి మిమ్మల్ని అనుమతిస్తుంది . అక్షరాలను నిల్వ చేసే శ్రేణిని తప్పనిసరిగా ఆర్గ్యుమెంట్‌గా పాస్ చేయాలి. పద్ధతి ఒక సంఖ్యను అందిస్తుంది — వాస్తవానికి చదివిన అక్షరాల సంఖ్య.

skip(long n)పద్ధతి

ఈ పద్ధతి ఆబ్జెక్ట్ నుండి మొదటి n అక్షరాలను దాటవేయడానికి మిమ్మల్ని అనుమతిస్తుంది Reader. ఇది క్లాస్ యొక్క సారూప్య పద్ధతి వలె సరిగ్గా పని చేస్తుంది InputStream. వాస్తవంగా దాటవేయబడిన అక్షరాల సంఖ్యను అందిస్తుంది.

boolean ready()పద్ధతి

trueస్ట్రీమ్‌లో చదవని బైట్‌లు ఉంటే తిరిగి వస్తుంది .

void close()పద్ధతి

పద్ధతి close()డేటా స్ట్రీమ్‌ను మూసివేస్తుంది మరియు దానితో అనుబంధించబడిన బాహ్య వనరులను విడుదల చేస్తుంది. ఒక స్ట్రీమ్ మూసివేయబడిన తర్వాత, దాని నుండి ఎక్కువ డేటా చదవబడదు.

పోలిక కోసం, టెక్స్ట్ ఫైల్‌ను కాపీ చేసే ప్రోగ్రామ్‌ను వ్రాద్దాం:

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

try(FileReader reader = new FileReader(src);
FileWriter writer = new FileWriter(dest))
{
   char[] buffer = new char[65536]; // 128Kb
   while (reader.ready())
   {
      int real = reader.read(buffer);
      writer.write(buffer, 0, real);
   }
}