நிலையான இடைமுகங்கள்: InputStream, OutputStream

"வணக்கம், அமிகோ! இப்போது நான் உங்களுக்கு இரண்டு இடைமுகங்களைப் பற்றி சொல்கிறேன்: InputStream மற்றும் OutputStream . அவை சுருக்க வகுப்புகளாக அறிவிக்கப்படுகின்றன, ஆனால் நீங்கள் ஆழமாக தோண்டினால் அவை அடிப்படையில் இடைமுகங்கள் என்பதை நீங்கள் காணலாம் . அவற்றின் அனைத்து முறைகளும் சுருக்கமானவை, தவிர ஒரு சில முக்கியமற்ற முறைகள், நாம் முன்பு கருதிய " உடலாளர் " போன்றது ."

இவை மிகவும் சுவாரஸ்யமான இடைமுகங்கள். இப்போதைக்கு, நான் வேண்டுமென்றே அவற்றை இடைமுகங்கள் என்று அழைக்கப் போகிறேன் , எனவே அவை நமக்கு ஏன் தேவை என்பதை நீங்கள் புரிந்துகொள்கிறீர்கள். பின்னர் அவை உண்மையில் சுருக்க வகுப்புகள் ஏன் என்பதைப் பற்றி பேசுவோம்.

"சரி. இந்த இடைமுகங்கள் என்ன?"

"மேலும் பேசாமல் சொல்கிறேன்."

" ஸ்ட்ரீம் " என்று அழைக்கப்படும் இந்த சுவாரஸ்யமான விஷயத்தை ஜாவா கொண்டுள்ளது. ஸ்ட்ரீம் என்பது மிகவும் எளிமையான ஒரு பொருள். தரவு பரிமாற்றத்திற்கான மிகவும் சக்திவாய்ந்த வழிக்கு அதன் எளிமை முக்கியமானது. இரண்டு வகையான நீரோடைகள் உள்ளன: வாசிப்புக்கான நீரோடைகள் மற்றும் எழுதுவதற்கான நீரோடைகள் .

நீங்கள் ஏற்கனவே யூகித்தபடி, எழுதுவதற்கு ஒரு ஸ்ட்ரீமில் தரவை எழுதலாம் . இதற்கு எழுதும் முறை உள்ளது . நீங்கள் படிக்க ஒரு ஸ்ட்ரீமில் இருந்து தரவைப் படிக்கலாம் . இதற்கு ஒரு வாசிப்பு () முறை உள்ளது .

இன்புட்ஸ்ட்ரீம்  என்பது வாசிப்பை ஆதரிக்கும் ஸ்ட்ரீமிற்கான இடைமுகமாகும். இது பின்வரும் திறனை வரையறுக்கிறது: «பைட்டுகளை என்னிடமிருந்து படிக்க முடியும்».

இதேபோல், OutputStream , ஒரு OutputStream என்பது எழுதுவதை ஆதரிக்கும் ஸ்ட்ரீமிற்கான இடைமுகமாகும். இது பின்வரும் திறனை வரையறுக்கிறது: «பைட்டுகள் எனக்கு எழுதப்படலாம்».

"அவ்வளவுதான்?"

"அழகான விஷயம். ஆனால் ஜாவாவில் இன்புட்ஸ்ட்ரீம் மற்றும் அவுட்புட்ஸ்ட்ரீம் ஆகியவற்றுடன் வேலை செய்யக்கூடிய பல வகுப்புகள் உள்ளன . எடுத்துக்காட்டாக, நீங்கள் வட்டில் இருந்து ஒரு கோப்பைப் படித்து அதன் உள்ளடக்கங்களைத் திரையில் காட்ட விரும்புகிறீர்கள். எதுவும் எளிதாக இருக்க முடியாது."

வட்டில் உள்ள ஒரு கோப்பிலிருந்து தரவைப் படிக்க, எங்களிடம் சிறப்பு FileInputStream வகுப்பு உள்ளது, இது InputStream இடைமுகத்தை செயல்படுத்துகிறது . இந்தத் தரவை வேறொரு கோப்பில் எழுத விரும்புகிறீர்களா? இதற்கு, எங்களிடம் 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();
}

நாம் ஒரு வகுப்பை எழுதி,  அதில் InputStream  மற்றும்  OutputStream திறன்களைச் சேர்த்துள்ளோம் என்று கற்பனை செய்து பாருங்கள்.

இந்த இடைமுகங்களை நாம் சரியாக செயல்படுத்தினால், எங்கள் வகுப்பின் நிகழ்வுகளை இப்போது ஒரு கோப்பில் சேமிக்கலாம் அல்லது படிக்கலாம். வாசிப்பு முறையைப் பயன்படுத்தி அவற்றின் உள்ளடக்கங்களைப் படிப்பதன் மூலம் . அல்லது ஒரு பொருளை உருவாக்கி, கோப்பு உள்ளடக்கங்களை எழுத எழுதும் முறையைப் பயன்படுத்தி அவற்றை ஒரு கோப்பிலிருந்து ஏற்றலாம் .

"ஒரு உதாரணம் இருக்கலாம்?"

"நிச்சயம்."

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
}

"ஹோலி மோலி! இது உண்மையில் இன்புட்ஸ்ட்ரீம்/அவுட்புட் ஸ்ட்ரீமுடன் வேலை செய்வதைப் போன்றது. ஸ்ட்ரீம்கள் இனிமையானவை!"

"பின்னர் சில!"

3

பணி

Java உள்ளகம், நிலை 3, பாடம் 8

பூட்டப்பட்டது

Code entry

Sometimes you don't need to think, you just need to hammer it out! As paradoxical as it may seem, sometimes your fingers will "remember" better than your conscious mind. That's why while training at the secret CodeGym center you will sometimes encounter tasks that require you to enter code. By entering code, you get used to the syntax and assimilate some material. What's more, you combat laziness.

திற