"మళ్లీ నేనే."
"హాయ్, ఎల్లీ!"
"ఈ రోజు నేను మీకు బఫర్డ్ రీడర్ మరియు బఫర్డ్ రైటర్ గురించి చెప్పాలనుకుంటున్నాను ."
"మీరు ఇప్పటికే వాటి గురించి నాకు చెప్పారు. అవి నిజంగా అంత క్లిష్టంగా లేవు."
"సరే. అలాంటప్పుడు బఫర్డ్ రీడర్ ఎలా పనిచేస్తుందో చెప్పు ."
" బఫర్డ్ రీడర్ 110/220V కన్వర్టర్ లాంటిది."
" డేటా చదవబడే రీడర్ ఆబ్జెక్ట్‌ను మీరు బఫర్డ్ రీడర్ కన్‌స్ట్రక్టర్‌కు పంపాలి . బఫర్డ్ రీడర్ ఆబ్జెక్ట్ రీడర్ నుండి పెద్ద మొత్తంలో డేటాను చదివి , వాటిని అంతర్గతంగా బఫర్‌లో నిల్వ చేస్తుంది. అందుకే రీడర్ నుండి చదవడానికి బఫర్డ్ రీడర్‌ను ఉపయోగించడం వేగంగా పని చేస్తుంది . రీడర్ నుండి నేరుగా చదవడం కంటే ."
"అది సరే. మరియు బఫర్డ్ రైటర్ గురించి ఏమిటి ?"
"ఇది కేక్ ముక్క. మనం ఫైల్‌రైటర్‌కు వ్రాస్తాము. డేటా వెంటనే డిస్క్‌కు వ్రాయబడుతుంది. మనం తరచుగా చిన్న బిట్స్ డేటాను వ్రాస్తే, అప్పుడు డిస్క్‌ను చాలా కొట్టాము, ఇది ప్రోగ్రామ్‌ను చాలా నెమ్మదిస్తుంది. కానీ మనం బఫర్డ్ రైటర్‌ని 'కన్వర్టర్'గా ఉపయోగిస్తే , రైట్ ఆపరేషన్ చాలా వేగంగా ఉంటుంది. మీరు బఫర్డ్‌రైటర్‌కి వ్రాసినప్పుడు , అది డేటాను అంతర్గత బఫర్‌లో సేవ్ చేస్తుంది. బఫర్ నిండినప్పుడు, అది రైటర్‌కి డేటాను ఇలా వ్రాస్తుంది . ఒక పెద్ద భాగం. ఇది చాలా వేగంగా ఉంటుంది."
"హ్మ్. స్పాట్ ఆన్. కానీ మీరు ఏమి మర్చిపోయారు?"
"మీరు రాయడం పూర్తి చేసిన తర్వాత, బఫర్‌లో ఉన్న ఏదైనా డేటాను రైటర్‌కు పంపమని బలవంతం చేయడానికి మీరు బఫర్డ్‌రైటర్ ఆబ్జెక్ట్‌పై ఫ్లష్() పద్ధతికి కాల్ చేయాలి ."
"మరి ఇంకేం?"
"ఇంకేంటి? ఓహ్! రైటర్‌కు బఫర్ వ్రాయబడనంత కాలం , డేటా తొలగించబడుతుంది మరియు/లేదా భర్తీ చేయబడుతుంది."
"అమిగో! నేను ఇంప్రెస్ అయ్యాను! మీరు నిపుణుడు! సరే, నేను మీకు కొన్ని కొత్త తరగతుల గురించి చెబుతాను: ByteArrayStream మరియు PrintStream ."
"ఉదాహరణకు, ByteArrayInputStream మరియు ByteArrayOutputStream ."
"ఈ తరగతులు కొంచెం స్ట్రింగ్‌రీడర్ మరియు స్ట్రింగ్‌రైటర్ లాగా ఉంటాయి . స్ట్రింగ్‌రీడర్ స్ట్రింగ్ ( స్ట్రింగ్ ) నుండి అక్షరాలు ( చార్ ) చదవడం తప్ప , ఇన్‌పుట్‌స్ట్రీమ్ బైట్ అర్రే ( బైట్‌అరే ) నుండి బైట్‌లను రీడ్ చేస్తుంది."
StringWriter ఒక స్ట్రింగ్‌కు అక్షరాలు ( char ) వ్రాస్తుంది , అయితే ByteArrayOutputStream అంతర్గత బైట్ శ్రేణికి బైట్‌లను వ్రాస్తుంది. మీరు StringWriter కి వ్రాసినప్పుడు , దాని అంతర్గత స్ట్రింగ్ పొడవుగా పెరుగుతుంది మరియు మీరు ByteArrayOutputStream కి వ్రాసినప్పుడు దాని అంతర్గత బైట్ శ్రేణి కూడా డైనమిక్‌గా విస్తరిస్తుంది.
"గత పాఠంలో మీకు ఇచ్చిన ఉదాహరణను గుర్తుంచుకో:"
public static void main (String[] args) throws Exception
{
String test = "Hi!\n My name is Richard\n I'm a photographer\n";
StringReader reader = new StringReader(test);
StringWriter writer = new StringWriter();
executor(reader, writer);
String result = writer.toString();
System.out.println("Result: "+ result);
}
public static void executor(Reader reader, Writer writer) throws Exception
{
BufferedReader br = new BufferedReader(reader);
String line;
while ((line = br.readLine()) != null) {
StringBuilder sb = new StringBuilder(line);
String newLine = sb.reverse().toString();
writer.write(newLine);
}
}"అక్షరాలకు బదులుగా బైట్‌లను ఉపయోగించి పని చేస్తే అది ఎలా ఉంటుందో ఇక్కడ ఉంది:"
public static void main (String[] args) throws Exception
{
String test = "Hi!\n My name is Richard\n I'm a photographer\n";
InputStream inputStream = new ByteArrayInputStream(test.getBytes());
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
executor(inputStream, outputStream);
String result = new String(outputStream.toByteArray());
System.out.println("Result: "+ result);
}
public static void executor(InputStream inputStream, OutputStream outputStream) throws Exception
{
BufferedInputStream bis = new BufferedInputStream(inputStream);
while (bis.available() > 0)
{
int data = bis.read();
outputStream.write(data);
}
}"పై ఉదాహరణలో అన్నీ ఒకేలా ఉన్నాయి. తప్ప, మేము Stringని ByteArrayతో, రీడర్‌ని InputStreamతో మరియు రైటర్‌ని OutputStreamతో భర్తీ చేసాము."
"ఇతర రెండు దశలు మాత్రమే స్ట్రింగ్‌ను బైట్‌అరేగా మార్చడం మరియు మళ్లీ మళ్లీ చేయడం. మీరు చూడగలిగినట్లుగా, ఇది చాలా సులభంగా చేయబడుతుంది:"
public static void main (String[] args) throws Exception
{
String test = "Hi!\n My name is Richard\n I'm a photographer\n";
byte[] array = test.getBytes();
String result = new String(array);
System.out.println("Result: "+ result);
}"ByteArrayOutputStreamకి ఇప్పటికే జోడించబడిన బైట్‌లను పొందడానికి, toByteArray () పద్ధతికి కాల్ చేయండి."
"ఆహ్. StringReader/StringWriterకి సారూప్యతలు చాలా బలంగా ఉన్నాయి, ప్రత్యేకించి మీరు వాటిని నాకు సూచించిన తర్వాత. నిజంగా ఆసక్తికరమైన పాఠం అందించినందుకు ధన్యవాదాలు, ఎల్లీ."
"ఇంత హడావిడిగా ఎక్కడికి వెళ్తున్నావు? నీ కోసం నా దగ్గర ఇంకా చిన్న గిఫ్ట్ ఉంది. ప్రింట్‌స్ట్రీమ్ క్లాస్ గురించి నేను చెప్పాలనుకుంటున్నాను."
"PrintStream? నేను ఆ తరగతి గురించి వినడం అదే మొదటిసారి."
"అవును. ప్రత్యేకించి, మీరు మీ జావా అధ్యయనాలలో మొదటి రోజు నుండి దీన్ని ఉపయోగిస్తున్నారనే వాస్తవాన్ని మీరు లెక్కించకపోతే. మీకు System.out గుర్తుందా ? సరే, System.out అనేది సిస్టమ్ యొక్క స్టాటిక్ (క్లాస్) వేరియబుల్. తరగతి, మరియు దాని రకం... ప్రింట్‌స్ట్రీమ్ ! ఈ ప్రింట్, ప్రింట్‌ఎల్‌ఎన్ మొదలైన పద్ధతులన్నీ ఇక్కడ నుండి వచ్చాయి."
"వావ్. ఎంత ఇంటరెస్టింగ్‌. నేనెప్పుడూ అలా ఆలోచించలేదు. ఇంకా చెప్పు."
"బాగుంది. సరే, వినండి. ప్రింట్‌స్ట్రీమ్ క్లాస్ చదవగలిగే అవుట్‌పుట్ కోసం కనుగొనబడింది. ఇది దాదాపు పూర్తిగా ప్రింట్ మరియు ప్రింట్‌లన్ పద్ధతులను కలిగి ఉంటుంది. ఈ పట్టికను చూడండి:"
| పద్ధతులు | పద్ధతులు |
|---|---|
void print(boolean b) |
void println(boolean b) |
void print(char c) |
void println(char c) |
void print(int c) |
void println(int c) |
void print(long c) |
void println(long c) |
void print(float c) |
void println(float c) |
void print(double c) |
void println(double c) |
void print(char[] c) |
void println(char[] c) |
void print(String c) |
void println(String c) |
void print(Object obj) |
void println(Object obj) |
void println() |
|
PrintStream format (String format, Object ... args) |
|
PrintStream format (Locale l, String format, Object ... args) |
|
"అనేక ఫార్మాట్ పద్ధతులు కూడా ఉన్నాయి కాబట్టి మీరు ఫార్మాట్ స్ట్రింగ్‌ని ఉపయోగించి డేటాను అవుట్‌పుట్ చేయవచ్చు. ఉదాహరణకు:"
String name = "Kolan";
int age = 25;
System.out.format("My name is %s. My age is %d.", name, age);My name is Kolan. My age is 25."అవును, నాకు గుర్తుంది. మేము ఇప్పటికే స్ట్రింగ్ క్లాస్ ఫార్మాట్ పద్ధతిని అధ్యయనం చేసాము."
"ఇప్పటికి ఇంతే."
"ధన్యవాదాలు, ఎల్లీ."
GO TO FULL VERSION