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

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మరియు ఇది స్ట్రీమ్ ఆబ్జెక్ట్‌ల చైన్‌లలో ఉపయోగించబడుతుంది. ఇది ఆచరణలో చాలా ఉపయోగకరమైన ఆస్తి.

3. PrintStreamతరగతి

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

అన్ని ఇంటర్మీడియట్ అవుట్‌పుట్ స్ట్రీమ్‌లలో అత్యంత ఆసక్తికరమైన మరియు బహుముఖమైనది PrintStream. దీనికి పదుల సంఖ్యలో పద్ధతులు మరియు 12 మంది కన్స్ట్రక్టర్‌లు ఉన్నాయి.

తరగతి PrintStreamతరగతిని వారసత్వంగా పొందుతుంది FilterOutputStream, ఇది వారసత్వంగా పొందుతుంది OutputStream. అంటే తరగతి దాని స్వంత పద్ధతులతో పాటు మాతృ తరగతుల అన్ని పద్ధతులనుPrintStream కలిగి ఉంటుంది . ఇక్కడ అత్యంత ఆసక్తికరమైనవి ఉన్నాయి:

void print(obj)

void println(obj)

void println()

PrintStream format(String format, args...)

మరియు ఈ పదుల పద్ధతులు ఎక్కడ ఉన్నాయి, మీరు అడగండి?

బాగా, ఇది వివిధ పారామితులతో అనేక రకాలు print()మరియు println()పద్ధతులను కలిగి ఉంది. వాటిని ఈ పట్టికలో సంగ్రహించవచ్చు.

మేము ఈ పద్ధతుల్లోకి ప్రవేశించము, ఎందుకంటే మీకు ఇప్పటికే ఇవి బాగా తెలుసు. నేను ఏమి పొందుతున్నానో మీరు ఊహించగలరా?

గుర్తుందా System.out.println()? కానీ దానిని రెండు పంక్తులలో వ్రాయవచ్చు:

PrintStream stream = System.out;
stream.println("Hello!");

Hello!

మాకు ఇష్టమైన కమాండ్ క్లాస్ యొక్క స్టాటిక్ వేరియబుల్‌లోని పద్ధతికి కాల్ . మరియు ఈ వేరియబుల్ రకం .System.out.println()println()outSystemPrintStream

చాలా కోడ్‌జిమ్ స్థాయిలలో మరియు దాదాపు ప్రతి టాస్క్‌లో, మీకు PrintStreamతెలియకుండానే మీరు క్లాస్ పద్ధతులకు కాల్ చేస్తున్నారు!

ఆచరణాత్మక ఉపయోగం

Java ఈ ఆసక్తికరమైన తరగతిని కలిగి ఉంది ByteArrayOutputStream, ఇది వారసత్వంగా పొందే డైనమిక్‌గా పెరుగుతున్న బైట్ శ్రేణి OutputStream.

ఒక ByteArrayOutputStreamవస్తువు మరియు PrintStreamవస్తువును ఇలా బంధించవచ్చు:

ByteArrayOutputStream baos = new ByteArrayOutputStream();

try(PrintStream stream = new PrintStream(baos))
{
   stream.println("Hello");
   stream.println(123);
}

String result = baos.toString();

System.out.println(result);

Hello!
123