1. OutputStream
తరగతి
మేము ఇటీవల ఇన్పుట్ స్ట్రీమ్లను అన్వేషించాము. అవుట్పుట్ స్ట్రీమ్ల గురించి మాట్లాడాల్సిన సమయం ఇది.
బైట్ అవుట్పుట్కు మద్దతు ఇచ్చే అన్ని తరగతులకు తరగతి OutputStream
మాతృ తరగతి. ఇది స్వంతంగా ఏమీ చేయని ఒక వియుక్త తరగతి, కానీ ప్రతి సందర్భంలోనూ ఇది సంతతి తరగతులను కలిగి ఉంటుంది.
ఇది చాలా క్లిష్టంగా అనిపిస్తుంది. మరింత సరళంగా చెప్పాలంటే, ఈ తరగతి బైట్లపై పనిచేస్తుంది మరియు ఉదాహరణకు, అక్షరాలు లేదా ఇతర డేటా రకాలు కాదు. మరియు ఇది వియుక్తమైనది అంటే మనం సాధారణంగా దీనిని ఉపయోగించము, కానీ దాని వారసులలో ఒకటి. ఉదాహరణకు, FileOutputStream
మరియు వంటివి.
కానీ తిరిగి తరగతికి OutputStream
. ఈ తరగతికి దాని వారసులందరూ తప్పనిసరిగా అమలు చేసే పద్ధతులను కలిగి ఉన్నారు. ఇక్కడ ప్రధానమైనవి:
పద్ధతులు | వివరణ |
---|---|
|
int స్ట్రీమ్కి ఒక బైట్ (ఒక కాదు) వ్రాస్తుంది . |
|
స్ట్రీమ్కు బైట్ల శ్రేణిని వ్రాస్తుంది |
|
స్ట్రీమ్కు బైట్ల శ్రేణిలో కొంత భాగాన్ని వ్రాస్తుంది |
|
బఫర్లో నిల్వ చేయబడిన మొత్తం డేటాను స్ట్రీమ్కు వ్రాస్తుంది |
|
ప్రవాహాన్ని మూసివేస్తుంది |
మీరు వారసత్వంగా పొందే తరగతి యొక్క ఆబ్జెక్ట్ను సృష్టించినప్పుడు 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
.
ఫైల్ను కాపీ చేయడానికి ఉదాహరణ
కోడ్ | గమనిక |
---|---|
|
InputStream ఫైల్ నుండి చదవడం OutputStream కోసం ఫైల్ బఫర్కి వ్రాయడం కోసం మేము డేటాను చదువుతాము స్ట్రీమ్లో డేటా ఉన్నంత వరకు డేటాను బఫర్లోకి చదవండి బఫర్ నుండి డేటాను రెండవ స్ట్రీమ్కు వ్రాయండి |
2. Writer
తరగతి
తరగతి Writer
ఖచ్చితంగా తరగతికి సమానంగా ఉంటుంది OutputStream
, కానీ మరోసారి ఒకే తేడా: ఇది char
బైట్లకు బదులుగా అక్షరాలు ( )తో పని చేస్తుంది.
ఇది వియుక్త తరగతి: మీరు తరగతి వస్తువులను సృష్టించలేరు Writer
. వందలాది వారసుల తరగతులకు సాధారణ పేరెంట్ క్లాస్గా ఉండటం మరియు క్యారెక్టర్ స్ట్రీమ్లతో పని చేయడానికి వారికి సాధారణ పద్ధతులను అందించడం దీని ప్రధాన లక్ష్యం.
తరగతి యొక్క పద్ధతులు Writer
(మరియు దాని అన్ని వారసుల తరగతులు):
పద్ధతులు | వివరణ |
---|---|
|
int స్ట్రీమ్కు ఒక అక్షరాన్ని (ఒక కాదు) వ్రాస్తుంది . |
|
స్ట్రీమ్కు అక్షరాల శ్రేణిని వ్రాస్తుంది |
|
స్ట్రీమ్కు అక్షరాల శ్రేణిలో కొంత భాగాన్ని వ్రాస్తుంది |
|
స్ట్రీమ్కి స్ట్రింగ్ వ్రాస్తుంది |
|
స్ట్రింగ్లో కొంత భాగాన్ని స్ట్రీమ్కి వ్రాస్తుంది |
|
బఫర్లో నిల్వ చేయబడిన మొత్తం డేటాను స్ట్రీమ్కు వ్రాస్తుంది |
|
ప్రవాహాన్ని మూసివేస్తుంది |
పద్ధతులు తరగతి యొక్క పద్ధతులకు చాలా పోలి ఉంటాయి 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
.
టెక్స్ట్ ఫైల్ను కాపీ చేసే ప్రోగ్రామ్ యొక్క ఉదాహరణ:
కోడ్ | గమనిక |
---|---|
|
Reader Writer ఫైల్ బఫర్కి వ్రాయడం కోసం ఫైల్ నుండి చదవడం కోసం మేము డేటాను చదువుతాము దీనిలో డేటా ఉన్నంత వరకు స్ట్రీమ్లో డేటాను చదవండి బఫర్లోకి డేటాను బఫర్ నుండి రెండవ స్ట్రీమ్కు వ్రాయండి |
StringWriter
తరగతి
తరగతిని వారసత్వంగా పొందే మరొక ఆసక్తికరమైన తరగతి ఉంది Writer
: దీనిని అంటారు StringWriter
. ఇది మార్చగల స్ట్రింగ్ను కలిగి ఉంది - ఒక StringBuffer
వస్తువు. మరియు మీరు ఆబ్జెక్ట్కు ఏదైనా "వ్రాయడానికి" ప్రతిసారీ StringWriter
, టెక్స్ట్ దాని అంతర్గత బఫర్కు జోడించబడుతుంది.
ఉదాహరణ:
కోడ్ | గమనిక |
---|---|
|
లక్ష్య అక్షర ప్రవాహం ( ) StringWriter సృష్టించబడింది స్ట్రింగ్ లోపల ఉన్న StringWriter బఫర్కు స్ట్రింగ్ వ్రాయబడుతుంది StringWriter |
ఈ సందర్భంలో, StringWriter
క్లాస్ తప్పనిసరిగా క్లాస్పై రేపర్ StringBuffer
, కానీ StringWriter
క్లాస్ స్ట్రీమ్ క్లాస్ యొక్క వారసుడు Writer
మరియు ఇది స్ట్రీమ్ ఆబ్జెక్ట్ల చైన్లలో ఉపయోగించబడుతుంది. ఇది ఆచరణలో చాలా ఉపయోగకరమైన ఆస్తి.