தரவு உள்ளீட்டிற்கான ஸ்ட்ரீம்கள்

1. தரவு ஸ்ட்ரீம்கள்

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

இந்த நடத்தைகள் அனைத்தையும் நாம் ஒரே வார்த்தையில் குறிப்பிடலாம்: நிரலுக்கும் வெளி உலகத்திற்கும் இடையிலான தரவு பரிமாற்றம் . காத்திருங்கள், இது ஒரு வார்த்தை அல்ல.

நிச்சயமாக, தரவு பரிமாற்றத்தை இரண்டு பகுதிகளாகப் பிரிக்கலாம்: தரவைப் பெறுதல் மற்றும் தரவை அனுப்புதல். எடுத்துக்காட்டாக, ஒரு Scannerபொருளைப் பயன்படுத்தி விசைப்பலகையில் இருந்து தரவைப் படிக்கிறீர்கள் - இது தரவைப் பெறுகிறது. நீங்கள் ஒரு கட்டளையைப் பயன்படுத்தி திரையில் தரவைக் காண்பிக்கிறீர்கள் System.out.println()- இது தரவை அனுப்புகிறது.

நிரலாக்கத்தில், தரவு பரிமாற்றத்தை விவரிக்க "ஸ்ட்ரீம்" என்ற சொல் பயன்படுத்தப்படுகிறது. அந்த சொல் எங்கிருந்து வந்தது?

நிஜ வாழ்க்கையில், நீங்கள் ஒரு நீரோடை அல்லது நனவின் நீரோட்டத்தைக் கொண்டிருக்கலாம். நிரலாக்கத்தில், எங்களிடம் தரவு ஸ்ட்ரீம்கள் உள்ளன .

ஸ்ட்ரீம்கள் ஒரு பல்துறை கருவி. அவை நிரலை எங்கிருந்தும் தரவைப் பெற அனுமதிக்கின்றன (உள்ளீடு ஸ்ட்ரீம்கள்) மற்றும் தரவை எங்கும் அனுப்பவும் (வெளியீட்டு ஸ்ட்ரீம்கள்). எனவே, இரண்டு வகைகள் உள்ளன:

• உள்ளீட்டு ஸ்ட்ரீம் என்பது தரவைப் பெறுவதற்கானது
• ஒரு வெளியீட்டு ஸ்ட்ரீம் என்பது தரவுகளை அனுப்புவதற்காகும்

ஸ்ட்ரீம்களை 'உறுதியானதாக' மாற்ற, ஜாவாவின் படைப்பாளிகள் இரண்டு வகுப்புகளை எழுதினர்: InputStreamமற்றும் OutputStream.

வகுப்பில் தரவைப் படிக்க உதவும் InputStreamஒரு முறை உள்ளது . read()வகுப்பில் தரவை எழுத உங்களை அனுமதிக்கும் OutputStreamஒரு முறை உள்ளது . write()அவர்களுக்கு மற்ற முறைகளும் உள்ளன, ஆனால் பின்னர் அதைப் பற்றி மேலும்.

பைட் ஸ்ட்ரீம்கள்

நாம் எந்த வகையான தரவுகளைப் பற்றி பேசுகிறோம்? அது என்ன வடிவம் எடுக்கிறது? வேறு வார்த்தைகளில் கூறுவதானால், இந்த வகுப்புகள் எந்த தரவு வகைகளை ஆதரிக்கின்றன?

இவை பொதுவான வகுப்புகள், எனவே அவை மிகவும் பொதுவான தரவு வகையை ஆதரிக்கின்றன - தி byte. ஒரு OutputStreamபைட்டுகளை எழுத முடியும் (மற்றும் பைட் வரிசைகள்), மற்றும் ஒரு InputStreamபொருள் பைட்டுகளை (அல்லது பைட் வரிசைகள்) படிக்க முடியும். அவ்வளவுதான் — அவை வேறு எந்த தரவு வகைகளையும் ஆதரிக்காது.

இதன் விளைவாக, இந்த ஸ்ட்ரீம்கள் பைட் ஸ்ட்ரீம்கள் என்றும் அழைக்கப்படுகின்றன .

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

வகுப்பின் மூலம் விசைப்பலகையில் இருந்து தரவைப் படிப்பது இப்படித்தான் செயல்படுகிறது Scanner: விசைப்பலகையில் இருந்து தரவை வரிசையாக வரியாகப் படிக்கிறீர்கள். ஒரு வரி, அடுத்த வரி, அடுத்த வரி, மற்றும் பலவற்றைப் படிக்கிறோம். பொருத்தமாக, வரிகளைப் படிக்கும் முறை அழைக்கப்படுகிறது nextLine().

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

எழுத்து ஓட்டங்கள்

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

இந்த உண்மையைக் கணக்கிட்டு, ஜாவா புரோகிராமர்கள் மேலும் இரண்டு வகுப்புகளை எழுதினர்: Readerமற்றும் Writer. வர்க்கம் வகுப்பிற்கு Readerஒப்பானது InputStream, ஆனால் அதன் read()முறையானது பைட்டுகள் அல்ல, ஆனால் எழுத்துக்கள் ( ) படிக்கிறது char. வகுப்பு Writerவகுப்பிற்கு ஒத்திருக்கிறது OutputStream. வகுப்பைப் போலவே , இது பைட்டுகள் அல்ல, Readerஎழுத்துகளுடன் ( ) வேலை செய்கிறது .char

இந்த நான்கு வகுப்புகளை ஒப்பிட்டுப் பார்த்தால், பின்வரும் படத்தைப் பெறுகிறோம்:

InputStream

Reader

OutputStream

Writer

நடைமுறை பயன்பாடு

, InputStream, OutputStreamமற்றும் Readerவகுப்புகள் Writerயாராலும் நேரடியாகப் பயன்படுத்தப்படுவதில்லை. ஆனால் இந்த நான்கு வகுப்புகளும் நிறைய செய்யக்கூடிய சந்ததி வகுப்புகள் ஏராளமாக உள்ளன.

2. InputStreamவர்க்கம்

InputStreamநூற்றுக்கணக்கான சந்ததி வகுப்புகளுக்கு பெற்றோர் வகுப்பாக இருப்பதால் வகுப்பு சுவாரஸ்யமானது . இது அதன் சொந்த தரவு எதுவும் இல்லை, ஆனால் அதன் அனைத்து பெறப்பட்ட வகுப்புகள் மரபுரிமையாக முறைகள் உள்ளன.

பொதுவாக, ஸ்ட்ரீம் பொருள்கள் தரவை உள்நாட்டில் சேமிப்பது அரிது. ஸ்ட்ரீம் என்பது தரவைப் படிக்க/எழுதுவதற்கான ஒரு கருவி, ஆனால் சேமிப்பகம் அல்ல. விதிவிலக்குகள் உள்ளன என்றார்.

வகுப்பின் முறைகள் InputStreamமற்றும் அதன் அனைத்து சந்ததி வகுப்புகள்:

int read()

int read(byte[] buffer)

byte[] readAllBytes()

long skip(long n)

int available()

void close()

இந்த முறைகளை சுருக்கமாகப் பார்ப்போம்:

read()முறை

இந்த முறை ஸ்ட்ரீமில் இருந்து ஒரு பைட்டைப்read() படித்து அதைத் திருப்பித் தருகிறது. திரும்பும் வகையால் நீங்கள் குழப்பமடையலாம் . நிலையான முழு எண் வகை என்பதால் இந்த வகை தேர்ந்தெடுக்கப்பட்டது . முதல் மூன்று பைட்டுகள் பூஜ்ஜியமாக இருக்கும்.intintint

read(byte[] buffer)முறை

இது முறையின் இரண்டாவது மாறுபாடு read(). ஒரு பைட் வரிசையை InputStreamஒரே நேரத்தில் படிக்க இது உங்களை அனுமதிக்கிறது. பைட்டுகளை சேமிக்கும் வரிசை ஒரு வாதமாக அனுப்பப்பட வேண்டும். முறை ஒரு எண்ணை வழங்குகிறது - உண்மையில் படித்த பைட்டுகளின் எண்ணிக்கை.

உங்களிடம் 10 கிலோபைட் பஃபர் உள்ளது மற்றும் வகுப்பைப் பயன்படுத்தி ஒரு கோப்பிலிருந்து தரவைப் படிக்கிறீர்கள் என்று வைத்துக்கொள்வோம் FileInputStream. கோப்பில் 2 கிலோபைட்டுகள் மட்டுமே இருந்தால், எல்லா தரவும் இடையக வரிசையில் ஏற்றப்படும், மேலும் முறை 2048 (2 கிலோபைட்கள்) எண்ணை வழங்கும்.

readAllBytes()முறை

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

skip(long n)முறை

இந்த முறையானது பொருளிலிருந்து முதல் n பைட்டுகளைத் தவிர்க்க உங்களை அனுமதிக்கிறது InputStream. தரவு கண்டிப்பாக தொடர்ச்சியாகப் படிக்கப்படுவதால், இந்த முறையானது ஸ்ட்ரீமில் இருந்து முதல் n பைட்டுகளைப் படித்து அவற்றை நிராகரிக்கிறது.

உண்மையில் தவிர்க்கப்பட்ட பைட்டுகளின் எண்ணிக்கையை வழங்கும் ( nபைட்டுகள் தவிர்க்கப்படுவதற்கு முன் ஸ்ட்ரீம் முடிந்தால்).

int available()முறை

இந்த முறை ஸ்ட்ரீமில் இன்னும் எஞ்சியிருக்கும் பைட்டுகளின் எண்ணிக்கையை வழங்குகிறது

void close()முறை

இந்த close()முறை தரவு ஸ்ட்ரீமை மூடுகிறது மற்றும் அதனுடன் தொடர்புடைய வெளிப்புற ஆதாரங்களை வெளியிடுகிறது. ஒரு ஸ்ட்ரீம் மூடப்பட்டவுடன், அதிலிருந்து எந்த தரவையும் படிக்க முடியாது.

மிகப் பெரிய கோப்பை நகலெடுக்கும் ஒரு எடுத்துக்காட்டு நிரலை எழுதுவோம். readAllBytes()முழு கோப்பையும் நினைவகத்தில் படிக்கும் முறையைப் பயன்படுத்த முடியாது . உதாரணமாக:

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);
   }
}

இந்த எடுத்துக்காட்டில், நாங்கள் இரண்டு வகுப்புகளைப் பயன்படுத்தினோம்: இது ஒரு கோப்பிலிருந்து தரவைப் படிப்பதற்கான FileInputStreamவழித்தோன்றல் மற்றும் ஒரு கோப்பில் தரவை எழுதுவதற்கான வழித்தோன்றல் . இரண்டாம் வகுப்பு பற்றி சிறிது நேரம் கழித்து பேசுவோம்.InputStreamFileOutputStreamOutputStream

இங்கே மற்றொரு சுவாரஸ்யமான புள்ளி realமாறி உள்ளது. ஒரு கோப்பிலிருந்து தரவின் கடைசித் தொகுதியைப் படிக்கும்போது, ​​அது எளிதாக 64KB க்கும் குறைவான தரவைக் கொண்டிருக்கலாம். அதன்படி, நாம் முழு இடையகத்தையும் அல்ல, ஆனால் அதன் ஒரு பகுதியை மட்டுமே வெளியிட வேண்டும் - முதல் realபைட்டுகள். இதுவே முறையாக நடக்கும் write().

3. Readerவர்க்கம்

வகுப்பு Readerஎன்பது வகுப்பின் முழுமையான அனலாக் ஆகும் InputStream. ஒரே ஒரு வித்தியாசம் என்னவென்றால், இது charபைட்டுகளுடன் அல்ல, எழுத்துகளுடன் ( ) வேலை செய்கிறது. வகுப்பைப் போலவே InputStream, Readerவர்க்கமும் சொந்தமாக எங்கும் பயன்படுத்தப்படுவதில்லை: இது நூற்றுக்கணக்கான சந்ததி வகுப்புகளுக்கான பெற்றோர் வகுப்பாகும், மேலும் அவை அனைத்திற்கும் பொதுவான முறைகளை வரையறுக்கிறது.

வகுப்பின் முறைகள் Reader(மற்றும் அதன் அனைத்து சந்ததி வகுப்புகள்):

int read()

int read(char[] buffer)

long skip(long n)

boolean ready()

void close()

InputStreamசிறிய வேறுபாடுகள் இருந்தாலும், முறைகள் வகுப்பின் முறைகளுக்கு மிகவும் ஒத்தவை .

int read()முறை

இந்த முறை charஸ்ட்ரீமில் இருந்து ஒன்றைப் படித்து அதைத் திருப்பித் தருகிறது. வகை charவிரிவடைகிறது int, ஆனால் முடிவின் முதல் இரண்டு பைட்டுகள் எப்போதும் பூஜ்ஜியமாக இருக்கும்.

int read(char[] buffer)முறை

இது முறையின் இரண்டாவது மாறுபாடு read(). ஒரு சார் வரிசையை Readerஒரே நேரத்தில் படிக்க இது உங்களை அனுமதிக்கிறது. எழுத்துக்களை சேமிக்கும் வரிசை ஒரு வாதமாக அனுப்பப்பட வேண்டும். முறை ஒரு எண்ணை வழங்குகிறது - உண்மையில் படித்த எழுத்துக்களின் எண்ணிக்கை.

skip(long n)முறை

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

boolean ready()முறை

trueஸ்ட்ரீமில் படிக்காத பைட்டுகள் இருந்தால் திரும்பும் .

void close()முறை

இந்த close()முறை தரவு ஸ்ட்ரீமை மூடுகிறது மற்றும் அதனுடன் தொடர்புடைய வெளிப்புற ஆதாரங்களை வெளியிடுகிறது. ஒரு ஸ்ட்ரீம் மூடப்பட்டவுடன், அதிலிருந்து எந்த தரவையும் படிக்க முடியாது.

ஒப்பிடுவதற்கு, உரை கோப்பை நகலெடுக்கும் நிரலை எழுதுவோம்:

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);
   }
}