ప్రామాణిక ఇంటర్‌ఫేస్‌లు: ఇన్‌పుట్ స్ట్రీమ్, అవుట్‌పుట్ స్ట్రీమ్

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

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

"సరే. ఐతే ఈ ఇంటర్‌ఫేస్‌లు ఏమిటి?"

"మరేం మాట్లాడకుండా చెప్తాను."

జావాలో " స్ట్రీమ్ " అని పిలువబడే ఈ ఆసక్తికరమైన విషయం ఉంది. స్ట్రీమ్ అనేది చాలా సులభమైన అంశం. మరియు దాని సరళత డేటా మార్పిడికి చాలా శక్తివంతమైన మార్గానికి కీలకం. రెండు రకాల స్ట్రీమ్‌లు ఉన్నాయి: చదవడానికి స్ట్రీమ్‌లు మరియు రాయడానికి స్ట్రీమ్‌లు .

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

ఇన్‌పుట్‌స్ట్రీమ్  అనేది పఠనానికి మద్దతు ఇచ్చే స్ట్రీమ్ కోసం ఇంటర్‌ఫేస్. ఇది క్రింది సామర్థ్యాన్ని నిర్వచిస్తుంది: «బైట్లను నా నుండి చదవవచ్చు».

అదేవిధంగా, అవుట్‌పుట్‌స్ట్రీమ్ , అవుట్‌పుట్ స్ట్రీమ్ అనేది రాయడానికి మద్దతు ఇచ్చే స్ట్రీమ్ కోసం ఇంటర్‌ఫేస్. ఇది క్రింది సామర్థ్యాన్ని నిర్వచిస్తుంది: «బైట్లను నాకు వ్రాయవచ్చు».

"అంతే?"

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

డిస్క్‌లోని ఫైల్ నుండి డేటాను చదవడానికి, మేము ఇన్‌పుట్‌స్ట్రీమ్ ఇంటర్‌ఫేస్‌ను అమలు చేసే ప్రత్యేక ఫైల్‌ఇన్‌పుట్‌స్ట్రీమ్ క్లాస్‌ని కలిగి ఉన్నాము . మీరు ఈ డేటాను మరొక ఫైల్‌కి వ్రాయాలనుకుంటున్నారా? దీని కోసం, మేము FileOutputStream తరగతిని కలిగి ఉన్నాము, ఇది OutputStream ఇంటర్‌ఫేస్‌ను అమలు చేస్తుంది. ఒక ఫైల్ నుండి మరొక ఫైల్‌కి డేటాను కాపీ చేయడానికి మీరు ఏమి చేయాలో క్రింది కోడ్ చూపుతుంది.

public static void main(String[] args) throws IOException
{
 InputStream inStream = new FileInputStream("c:/source.txt");
 OutputStream outStream = new FileOutputStream("c:/result.txt");

 while (inStream.available() > 0)
 {
  int data = inStream.read(); //read one byte from the input stream
  outStream.write(data); //write that byte to the other stream.
 }

 inStream.close(); //close the streams
 outStream.close();
}

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

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

"బహుశా ఒక ఉదాహరణ?"

"తప్పకుండా."

class MyClass
{
private ArrayList<Integer> list;
}

ఇప్పుడు మనం దానికి చదవడం మరియు వ్రాయడం పద్ధతులను జోడిస్తాము

class MyClass
{
private ArrayList<Integer> list;
public void write(int data)
{
list.add(data);
}
public int read()
{
int first = list.get(0);
list.remove(0);
return first;
}

public int available()
{
return list.size();
}
}

వాస్తవానికి, ఇది InputStream మరియు OutputStream ఇంటర్‌ఫేస్‌ల అమలు కాదు, కానీ ఇది చాలా పోలి ఉంటుంది.

"అవును, నాకు అర్థమైంది. అలాంటప్పుడు మీరు అటువంటి వస్తువు యొక్క కంటెంట్‌లను ఫైల్‌లో ఎలా సేవ్ చేస్తారు?"

"నేను మీకు ఒక ఉదాహరణ చెప్తాను:"

public static void main(String[] args)
{
 MyClass myObject = new MyClass();
 OutputStream outStream = new FileOutputStream ("c:/my-object-data.txt");

 while (myObject.available() > 0)
 {
  int data = myObject.read(); //read one int from the input stream
  outStream.write(data); //write that int to the other stream.
 }

 outStream.close();
}

public static void main(String[] args)
{
 InputStream inStream = new FileInputStream("c:/my-object-data.txt");
 MyClass myObject = new MyClass();

 while (inStream.available() > 0)
 {
  int data = inStream.read(); //read one int from the input stream
  myObject.write(data); //write that int to the other stream.
 }

 inStream.close(); //close the streams
}

"హోలీ మోలీ! ఇది నిజంగా ఇన్‌పుట్‌స్ట్రీమ్/అవుట్‌పుట్‌స్ట్రీమ్‌తో పని చేయడం చాలా పోలి ఉంటుంది. స్ట్రీమ్‌లు చాలా మధురమైనవి!"

"మరియు అప్పుడు కొన్ని!"