అవుట్‌పుట్ స్ట్రీమ్‌లు

1. OutputStreamతరగతి

మేము ఇటీవల ఇన్‌పుట్ స్ట్రీమ్‌లను అన్వేషించాము. అవుట్‌పుట్ స్ట్రీమ్‌ల గురించి మాట్లాడాల్సిన సమయం ఇది.

బైట్ అవుట్‌పుట్‌కు మద్దతు ఇచ్చే అన్ని తరగతులకు తరగతి OutputStreamమాతృ తరగతి. ఇది స్వంతంగా ఏమీ చేయని ఒక వియుక్త తరగతి, కానీ ప్రతి సందర్భంలోనూ ఇది సంతతి తరగతులను కలిగి ఉంటుంది.

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

కానీ తిరిగి తరగతికి OutputStream. ఈ తరగతికి దాని వారసులందరూ తప్పనిసరిగా అమలు చేసే పద్ధతులను కలిగి ఉన్నారు. ఇక్కడ ప్రధానమైనవి:

void write(int b)

void write(byte[] buffer)

void write(byte[] buffer, off, len)

void flush()

void close()

మీరు వారసత్వంగా పొందే తరగతి యొక్క ఆబ్జెక్ట్‌ను సృష్టించినప్పుడు InputStream, మీరు సాధారణంగా డేటాను చదివే మూల వస్తువును పేర్కొంటారు InputStream. మీరు వారసత్వంగా పొందే తరగతి యొక్క ఆబ్జెక్ట్‌ను సృష్టించినప్పుడు OutputStream, మీరు సాధారణంగా టార్గెట్ ఆబ్జెక్ట్ లేదా డేటా వ్రాయబడే స్ట్రీమ్‌ను కూడా పేర్కొంటారు.

తరగతి యొక్క అన్ని పద్ధతుల ద్వారా క్లుప్తంగా వెళ్దాం OutputStream:

write(int b)పద్ధతి

intఈ పద్ధతి అవుట్‌పుట్ స్ట్రీమ్‌కు ఒక బైట్ (ఒక కాదు) వ్రాస్తుంది . ఆమోదించబడిన విలువ బైట్‌కి ప్రసారం చేయబడుతుంది మరియు పూర్ణాంకానికి చెందిన మొదటి మూడు బైట్‌లు విస్మరించబడతాయి.

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

అవుట్‌పుట్ స్ట్రీమ్‌కు ఇవ్వబడిన బైట్‌ల శ్రేణిని వ్రాస్తుంది. అంతే.

write(byte[] buffer, int offset, int length)పద్ధతి

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

flush()పద్ధతి

flush()ప్రస్తుత స్ట్రీమ్‌లో సంభావ్యంగా బఫర్ చేయబడిన ఏదైనా డేటాను టార్గెట్ స్ట్రీమ్‌కు వ్రాయమని బలవంతం చేయడానికి ఈ పద్ధతి ఉపయోగించబడుతుంది. గొలుసులో అమర్చబడిన బఫరింగ్ మరియు/లేదా బహుళ ప్రసార వస్తువులను ఉపయోగిస్తున్నప్పుడు ఇది సంబంధితంగా ఉంటుంది.

close()పద్ధతి

లక్ష్య వస్తువుకు ఏదైనా రాయని డేటాను వ్రాస్తుంది. close()మీరు బ్లాక్‌ని ఉపయోగిస్తే పద్ధతిని పిలవవలసిన అవసరం లేదు try-with-resources.

ఫైల్‌ను కాపీ చేయడానికి ఉదాహరణ

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);
   }
}

2. Writerతరగతి

తరగతి Writerఖచ్చితంగా తరగతికి సమానంగా ఉంటుంది OutputStream, కానీ మరోసారి ఒకే తేడా: ఇది charబైట్‌లకు బదులుగా అక్షరాలు ( )తో పని చేస్తుంది.

ఇది వియుక్త తరగతి: మీరు తరగతి వస్తువులను సృష్టించలేరు Writer. వందలాది వారసుల తరగతులకు సాధారణ పేరెంట్ క్లాస్‌గా ఉండటం మరియు క్యారెక్టర్ స్ట్రీమ్‌లతో పని చేయడానికి వారికి సాధారణ పద్ధతులను అందించడం దీని ప్రధాన లక్ష్యం.

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

void write(int b)

void write(char[] buffer)

void write(char[] buffer, off, len)

void write(String str)

void write(String str, off, len)

void flush()

void close()

పద్ధతులు తరగతి యొక్క పద్ధతులకు చాలా పోలి ఉంటాయి OutputStream, కానీ అవి బైట్‌లకు బదులుగా అక్షరాలతో పని చేస్తాయి.

పద్ధతుల వివరణ:

write(int b)పద్ధతి

ఈ పద్ధతి అవుట్‌పుట్ స్ట్రీమ్‌కు ఒకే అక్షరాన్ని ( char— a కాదు ) వ్రాస్తుంది. intపాస్ చేసిన విలువ a కు ప్రసారం చేయబడుతుంది charమరియు మొదటి రెండు బైట్‌లు విస్మరించబడతాయి.

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

అవుట్‌పుట్ స్ట్రీమ్‌కు ఇచ్చిన అక్షరాల శ్రేణిని వ్రాస్తుంది.

write(char[] buffer, int offset, int length)పద్ధతి

అవుట్‌పుట్ స్ట్రీమ్‌కు పాస్ చేసిన అక్షరాల శ్రేణిలో కొంత భాగాన్ని వ్రాస్తుంది. వేరియబుల్ offsetశ్రేణి యొక్క మొదటి మూలకం యొక్క సూచికను సూచిస్తుంది మరియు lengthఇది వ్రాయవలసిన ఉపసమితి యొక్క పొడవు.

write(String str)పద్ధతి

ఇచ్చిన స్ట్రింగ్‌ను అవుట్‌పుట్ స్ట్రీమ్‌కు వ్రాస్తుంది.

write(String str, int offset, int length)పద్ధతి

ఇచ్చిన స్ట్రింగ్‌లోని కొంత భాగాన్ని అవుట్‌పుట్ స్ట్రీమ్‌కు వ్రాస్తుంది: స్ట్రింగ్ అక్షరాల శ్రేణికి మార్చబడుతుంది. వేరియబుల్ offsetశ్రేణి యొక్క మొదటి మూలకం యొక్క సూచికను సూచిస్తుంది మరియు lengthఇది వ్రాయవలసిన ఉపసమితి యొక్క పొడవు.

flush()పద్ధతి

flush()ప్రస్తుత స్ట్రీమ్‌లో సంభావ్యంగా బఫర్ చేయబడిన ఏదైనా డేటాను టార్గెట్ స్ట్రీమ్‌కు వ్రాయమని బలవంతం చేయడానికి ఈ పద్ధతి ఉపయోగించబడుతుంది. గొలుసులో అమర్చబడిన బఫరింగ్ మరియు/లేదా బహుళ ప్రసార వస్తువులను ఉపయోగిస్తున్నప్పుడు ఇది సంబంధితంగా ఉంటుంది.

close()పద్ధతి

లక్ష్య వస్తువుకు ఏదైనా రాయని డేటాను వ్రాస్తుంది. close()మీరు బ్లాక్‌ని ఉపయోగిస్తే పద్ధతిని పిలవవలసిన అవసరం లేదు try-with-resources.

టెక్స్ట్ ఫైల్‌ను కాపీ చేసే ప్రోగ్రామ్ యొక్క ఉదాహరణ:

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);
   }
}

StringWriterతరగతి

తరగతిని వారసత్వంగా పొందే మరొక ఆసక్తికరమైన తరగతి ఉంది Writer: దీనిని అంటారు StringWriter. ఇది మార్చగల స్ట్రింగ్‌ను కలిగి ఉంది - ఒక StringBufferవస్తువు. మరియు మీరు ఆబ్జెక్ట్‌కు ఏదైనా "వ్రాయడానికి" ప్రతిసారీ StringWriter, టెక్స్ట్ దాని అంతర్గత బఫర్‌కు జోడించబడుతుంది.

ఉదాహరణ:

StringWriter writer = new StringWriter();
writer.write("Hello");
writer.write(String.valueOf(123));

String result = writer.toString();

ఈ సందర్భంలో, StringWriterక్లాస్ తప్పనిసరిగా క్లాస్‌పై రేపర్ StringBuffer, కానీ StringWriterక్లాస్ స్ట్రీమ్ క్లాస్ యొక్క వారసుడు Writerమరియు ఇది స్ట్రీమ్ ఆబ్జెక్ట్‌ల చైన్‌లలో ఉపయోగించబడుతుంది. ఇది ఆచరణలో చాలా ఉపయోగకరమైన ఆస్తి.